@blamejs/core 0.5.16 → 0.5.18

package/lib/csv.js

@@ -1,229 +1,275 @@
 "use strict";
 /**
- * csv — RFC 4180 parser + serializer.
+ * csv — RFC 4180 parser + serializer with operator-friendly defaults.
  *
- * Public API:
+ *   var rows = b.csv.parse(text);
+ *     // header row by default — returns array of objects keyed by header
+ *     // [ { name: "alice", age: "30" }, ... ]
  *
- *   b.csv.parse(text, opts?)        → { headers, rows }  (or { rows } if no header)
- *   b.csv.stringify(rows, opts?)    → string
+ *   var arrays = b.csv.parse(text, { header: false });
+ *     // returns array of arrays
  *
- * Opts (parse):
- *   delimiter:    ","   default
- *   header:       true  default — first row becomes column names; rows
- *                       are objects keyed by header
- *   maxBytes:     8 MiB default — refuses parse-bombs the same way
- *                       safeJson does
- *   onBadRow:     "throw" default | "skip" — what to do when a row has
- *                       a different column count than the header
+ *   var out = b.csv.stringify(rows);
+ *     // RFC 4180 + Excel-formula-injection prevention by default
  *
- * Opts (stringify):
- *   delimiter:    ","   default
- *   header:       true  default — emit a header row from object keys
- *   columns:      array of explicit column order (default: first row's keys)
- *   eol:          "\r\n" default — RFC 4180 mandates CRLF; some parsers
- *                       want LF. Operators choose.
+ * Defaults:
+ *   parse:
+ *     header:        true              first row is column names
+ *     delimiter:     ","               single byte; "\t" / ";" supported
+ *     quote:         '"'
+ *     trim:          false             cell whitespace preserved
+ *     maxBytes:      16 MiB
+ *     maxRows:       1,000,000
+ *     maxFieldBytes: 1 MiB
+ *     onBadRow:      "throw"           "skip" tolerates short/long rows
  *
- * Format support:
- *   - Quoted fields with embedded commas, quotes ("" → "), newlines.
- *   - Optional BOM at file start (consumed silently if present).
- *   - Trailing newline tolerated (RFC 4180 says SHOULD; we tolerate).
+ *   stringify:
+ *     header:                  true (or array of explicit columns)
+ *     delimiter:               ","
+ *     quote:                   '"'
+ *     eol:                     "\r\n"  RFC 4180; "\n" via opt
+ *     alwaysQuote:             false   only quote when needed
+ *     preventFormulaInjection: true    prefix '=' / '+' / '-' / '@' / TAB / CR
+ *                                       cells with "'" so Excel doesn't
+ *                                       execute them when the CSV is opened
+ *     formulaPrefixChars:      ["=","+","-","@","\t","\r"]
  *
- * Throws CsvError (FrameworkError) on shape violations.
+ * SECURITY: stringify defends against CSV-injection (Excel/Sheets execute
+ * cells starting with "=" / "+" / "-" / "@" / TAB / CR as formulas).
+ * Operator-controlled cells stay safe; user-supplied cells get the leading
+ * single-quote so the formula engine sees a literal string.
+ *
+ * Throws CsvError (FrameworkError, permanent) on shape violations.
  */
 var C = require("./constants");
 var { defineClass } = require("./framework-error");
 
 var CsvError = defineClass("CsvError", { alwaysPermanent: true });
 
-var DEFAULT_MAX_BYTES = C.BYTES.mib(8);
-var DEFAULT_DELIMITER = ",";
-var DEFAULT_EOL       = "\r\n";
+var DEFAULTS_PARSE = {
+  header:        true,
+  delimiter:     ",",
+  quote:         "\"",
+  trim:          false,
+  maxBytes:      C.BYTES.mib(16),
+  maxRows:       1000000,
+  maxFieldBytes: C.BYTES.mib(1),
+  onBadRow:      "throw",
+};
+
+var DEFAULTS_STRINGIFY = {
+  header:                  true,
+  delimiter:               ",",
+  quote:                   "\"",
+  eol:                     "\r\n",
+  alwaysQuote:             false,
+  preventFormulaInjection: true,
+  formulaPrefixChars:      ["=", "+", "-", "@", "\t", "\r"],
+  columns:                 null,
+};
+
+function _validateDelim(name, value) {
+  if (typeof value !== "string" || value.length !== 1) {
+    throw new CsvError("csv/bad-delimiter",
+      name + " must be a single character, got " + JSON.stringify(value));
+  }
+  if (value === "\r" || value === "\n") {
+    throw new CsvError("csv/bad-delimiter",
+      name + " cannot be CR or LF");
+  }
+}
 
 // ---- parse ----
 
-function parse(text, opts) {
-  opts = opts || {};
-  if (typeof text !== "string" && !Buffer.isBuffer(text)) {
+function parse(input, opts) {
+  opts = Object.assign({}, DEFAULTS_PARSE, opts || {});
+
+  var s;
+  if (typeof input === "string") s = input;
+  else if (Buffer.isBuffer(input)) s = input.toString("utf8");
+  else if (input instanceof Uint8Array) s = Buffer.from(input).toString("utf8");
+  else {
     throw new CsvError("csv/bad-input",
-      "parse: input must be a string or Buffer, got " + typeof text);
+      "parse: input must be string, Buffer, or Uint8Array, got " + typeof input);
   }
-  var s = Buffer.isBuffer(text) ? text.toString("utf8") : text;
-  var maxBytes = opts.maxBytes != null ? opts.maxBytes : DEFAULT_MAX_BYTES;
-  if (Buffer.byteLength(s, "utf8") > maxBytes) {
+  if (s.charCodeAt(0) === 0xFEFF) s = s.slice(1);
+  if (Buffer.byteLength(s, "utf8") > opts.maxBytes) {
     throw new CsvError("csv/too-large",
-      "parse: input exceeds maxBytes (" + maxBytes + ")");
-  }
-  var delimiter = opts.delimiter || DEFAULT_DELIMITER;
-  if (typeof delimiter !== "string" || delimiter.length !== 1) {
-    throw new CsvError("csv/bad-delimiter",
-      "parse: delimiter must be a single character, got " + JSON.stringify(delimiter));
+      "parse: input exceeds maxBytes (" + opts.maxBytes + ")");
   }
-  if (delimiter === "\"" || delimiter === "\r" || delimiter === "\n") {
+
+  _validateDelim("delimiter", opts.delimiter);
+  _validateDelim("quote",     opts.quote);
+  if (opts.delimiter === opts.quote) {
     throw new CsvError("csv/bad-delimiter",
-      "parse: delimiter cannot be quote / CR / LF");
+      "delimiter and quote must differ");
   }
-  var hasHeader = opts.header !== false;
-  var onBadRow = opts.onBadRow || "throw";
-  if (onBadRow !== "throw" && onBadRow !== "skip") {
+  if (opts.onBadRow !== "throw" && opts.onBadRow !== "skip") {
     throw new CsvError("csv/bad-opt",
-      "parse: onBadRow must be 'throw' or 'skip'");
+      "onBadRow must be 'throw' or 'skip'");
   }
 
-  // Strip BOM if present.
-  if (s.charCodeAt(0) === 0xfeff) s = s.slice(1);
-
+  var len = s.length;
+  var pos = 0;
   var rows = [];
-  var field = "";
   var row = [];
-  var inQuotes = false;
-  var i = 0;
-  var len = s.length;
-  while (i < len) {
-    var c = s.charAt(i);
-    if (inQuotes) {
-      if (c === "\"") {
-        if (i + 1 < len && s.charAt(i + 1) === "\"") {
-          field += "\"";    // escaped quote
-          i += 2;
+  var field = "";
+  var inQuote = false;
+
+  function pushField() {
+    if (Buffer.byteLength(field, "utf8") > opts.maxFieldBytes) {
+      throw new CsvError("csv/field-too-large",
+        "field exceeds maxFieldBytes at row " + (rows.length + 1));
+    }
+    row.push(opts.trim ? field.trim() : field);
+    field = "";
+  }
+  function pushRow() {
+    pushField();
+    rows.push(row);
+    if (rows.length > opts.maxRows) {
+      throw new CsvError("csv/too-many-rows",
+        "row count exceeds maxRows (" + opts.maxRows + ")");
+    }
+    row = [];
+  }
+
+  while (pos < len) {
+    var ch = s.charAt(pos);
+    if (inQuote) {
+      if (ch === opts.quote) {
+        if (pos + 1 < len && s.charAt(pos + 1) === opts.quote) {
+          field += opts.quote;
+          pos += 2;
           continue;
         }
-        inQuotes = false;
-        i++;
+        inQuote = false;
+        pos += 1;
         continue;
       }
-      field += c;
-      i++;
-      continue;
-    }
-    if (c === "\"") {
-      // Quote at the start of a field (or anywhere — treat as start of
-      // quoted run). RFC 4180 says quoted fields begin with a quote;
-      // fields that contain a quote not at the start are technically
-      // malformed but we tolerate by appending literally.
-      if (field.length === 0) {
-        inQuotes = true;
-        i++;
-        continue;
+      field += ch;
+      pos += 1;
+    } else {
+      if (ch === opts.delimiter) {
+        pushField();
+        pos += 1;
+      } else if (ch === "\r") {
+        pushRow();
+        pos += 1;
+        if (pos < len && s.charAt(pos) === "\n") pos += 1;
+      } else if (ch === "\n") {
+        pushRow();
+        pos += 1;
+      } else if (ch === opts.quote && field === "") {
+        inQuote = true;
+        pos += 1;
+      } else {
+        field += ch;
+        pos += 1;
       }
-      field += "\"";
-      i++;
-      continue;
-    }
-    if (c === delimiter) {
-      row.push(field);
-      field = "";
-      i++;
-      continue;
-    }
-    if (c === "\r") {
-      // CRLF or bare CR — treat both as row terminator.
-      row.push(field);
-      rows.push(row);
-      field = "";
-      row = [];
-      if (i + 1 < len && s.charAt(i + 1) === "\n") i += 2;
-      else i++;
-      continue;
-    }
-    if (c === "\n") {
-      row.push(field);
-      rows.push(row);
-      field = "";
-      row = [];
-      i++;
-      continue;
     }
-    field += c;
-    i++;
   }
-  // Flush any trailing field/row (no trailing newline case)
-  if (field.length > 0 || row.length > 0) {
-    row.push(field);
-    rows.push(row);
+  if (inQuote) {
+    throw new CsvError("csv/unterminated-quote",
+      "unterminated quoted field");
   }
+  if (field.length > 0 || row.length > 0) pushRow();
 
-  if (!hasHeader) {
-    return { rows: rows };
-  }
-  if (rows.length === 0) {
-    return { headers: [], rows: [] };
-  }
-  var headers = rows[0];
+  if (!opts.header) return rows;
+  if (rows.length === 0) return [];
+
+  var header = rows[0];
   var out = [];
   for (var r = 1; r < rows.length; r++) {
-    var current = rows[r];
-    if (current.length === 1 && current[0] === "") continue;   // skip blank lines
-    if (current.length !== headers.length) {
-      if (onBadRow === "skip") continue;
+    var rec = rows[r];
+    if (rec.length !== header.length) {
+      if (opts.onBadRow === "skip") continue;
       throw new CsvError("csv/row-length-mismatch",
-        "parse: row " + r + " has " + current.length + " columns, expected " + headers.length);
+        "row " + r + " has " + rec.length + " fields, header has " + header.length);
     }
     var obj = {};
-    for (var k = 0; k < headers.length; k++) obj[headers[k]] = current[k];
+    for (var i = 0; i < header.length; i++) obj[header[i]] = rec[i];
     out.push(obj);
   }
-  return { headers: headers, rows: out };
+  return out;
 }
 
 // ---- stringify ----
 
 function stringify(rows, opts) {
-  opts = opts || {};
+  opts = Object.assign({}, DEFAULTS_STRINGIFY, opts || {});
   if (!Array.isArray(rows)) {
     throw new CsvError("csv/bad-input",
-      "stringify: rows must be an array");
+      "stringify: rows must be an array, got " + typeof rows);
+  }
+  _validateDelim("delimiter", opts.delimiter);
+  _validateDelim("quote",     opts.quote);
+  if (opts.delimiter === opts.quote) {
+    throw new CsvError("csv/bad-delimiter",
+      "delimiter and quote must differ");
+  }
+  if (opts.eol !== "\r\n" && opts.eol !== "\n") {
+    throw new CsvError("csv/bad-opt",
+      "eol must be '\\r\\n' or '\\n'");
   }
-  var delimiter = opts.delimiter || DEFAULT_DELIMITER;
-  var eol       = opts.eol || DEFAULT_EOL;
-  var hasHeader = opts.header !== false;
   if (rows.length === 0) return "";
 
-  var columns;
-  if (Array.isArray(opts.columns)) {
-    columns = opts.columns.slice();
-  } else if (Array.isArray(rows[0])) {
-    // Array-of-arrays input — no headers to derive; emit as-is.
-    columns = null;
-  } else if (rows[0] && typeof rows[0] === "object") {
-    columns = Object.keys(rows[0]);
+  var first = rows[0];
+  var asObjects;
+  var header;
+  if (Array.isArray(first)) {
+    asObjects = false;
+    header = Array.isArray(opts.columns) ? opts.columns : null;
+  } else if (first !== null && typeof first === "object") {
+    asObjects = true;
+    header = Array.isArray(opts.columns) ? opts.columns : Object.keys(first);
   } else {
     throw new CsvError("csv/bad-input",
-      "stringify: rows[0] must be an object or array");
+      "stringify: rows must be arrays or plain objects");
   }
 
-  var lines = [];
-  if (hasHeader && columns) lines.push(columns.map(_quoteCell).join(delimiter));
+  var prefixSet = Object.create(null);
+  for (var pi = 0; pi < opts.formulaPrefixChars.length; pi++) {
+    prefixSet[opts.formulaPrefixChars[pi]] = true;
+  }
 
-  for (var r = 0; r < rows.length; r++) {
-    var row = rows[r];
-    var cells;
-    if (Array.isArray(row)) {
-      cells = row.map(_quoteCell);
-    } else if (row && typeof row === "object") {
-      cells = (columns || Object.keys(row)).map(function (col) {
-        return _quoteCell(row[col]);
-      });
-    } else {
-      throw new CsvError("csv/bad-input",
-        "stringify: rows[" + r + "] must be an object or array");
+  function escapeCell(value) {
+    var str = value == null ? "" : String(value);
+    if (opts.preventFormulaInjection && str.length > 0 && prefixSet[str.charAt(0)]) {
+      str = "'" + str;
+    }
+    var needsQuote = opts.alwaysQuote ||
+      str.indexOf(opts.delimiter) !== -1 ||
+      str.indexOf(opts.quote) !== -1 ||
+      str.indexOf("\n") !== -1 ||
+      str.indexOf("\r") !== -1;
+    if (needsQuote) {
+      str = opts.quote + str.split(opts.quote).join(opts.quote + opts.quote) + opts.quote;
     }
-    lines.push(cells.join(delimiter));
+    return str;
   }
-  return lines.join(eol) + eol;
-}
 
-function _quoteCell(value) {
-  if (value === null || value === undefined) return "";
-  var s = typeof value === "string" ? value : String(value);
-  if (s.indexOf("\"") !== -1 || s.indexOf(",") !== -1 ||
-      s.indexOf("\r") !== -1 || s.indexOf("\n") !== -1) {
-    return "\"" + s.replace(/"/g, "\"\"") + "\"";
+  var out = [];
+  if (opts.header && header) {
+    out.push(header.map(escapeCell).join(opts.delimiter));
+  }
+  for (var i = 0; i < rows.length; i++) {
+    var rec = rows[i];
+    var cells;
+    if (asObjects) {
+      cells = header.map(function (k) { return escapeCell(rec[k]); });
+    } else {
+      cells = rec.map(escapeCell);
+    }
+    out.push(cells.join(opts.delimiter));
   }
-  return s;
+  return out.join(opts.eol);
 }
 
 module.exports = {
-  parse:     parse,
-  stringify: stringify,
-  CsvError:  CsvError,
+  parse:               parse,
+  stringify:           stringify,
+  CsvError:            CsvError,
+  DEFAULTS_PARSE:      DEFAULTS_PARSE,
+  DEFAULTS_STRINGIFY:  DEFAULTS_STRINGIFY,
 };

package/lib/db.js

@@ -55,10 +55,17 @@ var cryptoField = require("./crypto-field");
 var { Query } = require("./db-query");
 var dbSchema = require("./db-schema");
 var { boot } = require("./log");
+var lazyRequire = require("./lazy-require");
+var safeAsync = require("./safe-async");
 var safeEnv = require("./parsers/safe-env");
 var safeJson = require("./safe-json");
 var vault = require("./vault");
 
+// Lazy: cluster-storage's _localDb pulls db back in, so eager require
+// would deadlock the load order. cluster-storage is only used on the
+// purge-audit-chain external-db path, which always runs after init.
+var clusterStorage = lazyRequire(function () { return require("./cluster-storage"); });
+
 var AUDIT_TIP_SCHEMA = {
   type: "object",
   required: ["atMonotonicCounter"],
@@ -797,12 +804,11 @@ async function init(opts) {
 
   // Start periodic encrypt timer (encrypted mode only)
   if (atRest === "encrypted") {
-    encTimer = setInterval(function () {
+    encTimer = safeAsync.repeating(function () {
       try { encryptToDisk(); } catch (e) {
         log.error("periodic encrypt failed: " + e.message);
       }
-    }, C.TIME.minutes(5));
-    encTimer.unref();
+    }, C.TIME.minutes(5), { name: "db-periodic-encrypt" });
 
     // Final encrypt on process exit. We don't try to unlink the plaintext
     // here — the SQLite handle may still be open, and the OS reclaims tmpfs
@@ -914,7 +920,7 @@ function hashFor(table, field, value) {
 function close() {
   if (!initialized) return;
   if (encTimer) {
-    clearInterval(encTimer);
+    encTimer.stop();
     encTimer = null;
   }
   // Best-effort final checkpoint before shutdown so the audit.tip sidecar
@@ -1070,7 +1076,7 @@ async function _runNtpBootCheck(opts) {
 
 // Test helpers — not part of public contract
 function _resetForTest() {
-  if (encTimer) { clearInterval(encTimer); encTimer = null; }
+  if (encTimer) { encTimer.stop(); encTimer = null; }
   try { if (database) database.close(); } catch (_e) {}
   database = null;
   dbPath = null;
@@ -1119,10 +1125,9 @@ module.exports = {
     if (!Number.isFinite(lastPurgedCounter) || lastPurgedCounter < 0) {
       throw new Error("purgeAuditChain: lastPurgedCounter must be a non-negative number");
     }
-    var c = require("./cluster");
-    if (c.isClusterMode()) {
+    if (cluster.isClusterMode()) {
       // External-db has no append-only triggers; ordinary DELETE works.
-      var cs = require("./cluster-storage");
+      var cs = clusterStorage();
       var d = await cs.execute(
         "DELETE FROM audit_log WHERE monotonicCounter <= ?", [lastPurgedCounter]
       );

package/lib/deprecate.js

@@ -50,6 +50,7 @@
  * call counter is still incremented so dep.list() shows usage volume.
  */
 
+var safeEnv = require("./parsers/safe-env");
 var { FrameworkError } = require("./framework-error");
 
 class DeprecateError extends FrameworkError {
@@ -65,12 +66,12 @@ class DeprecateError extends FrameworkError {
 var _seen = new Map();
 
 function _modeFromEnv() {
-  var env = process.env.BLAMEJS_DEPRECATIONS;
+  var env = safeEnv.readVar("BLAMEJS_DEPRECATIONS");
   if (typeof env === "string" && env.length > 0) {
     var v = env.toLowerCase();
     if (v === "warn" || v === "silent" || v === "error") return v;
   }
-  if (process.env.NODE_ENV === "production") return "silent";
+  if (safeEnv.readVar("NODE_ENV") === "production") return "silent";
   return "warn";
 }
 

package/lib/error-page.js

@@ -40,6 +40,7 @@
 
 var lazyRequire = require("./lazy-require");
 var requestHelpers = require("./request-helpers");
+var safeEnv = require("./parsers/safe-env");
 var template = require("./template");
 var audit = lazyRequire(function () { return require("./audit"); });
 
@@ -273,7 +274,7 @@ function create(opts) {
   if (modeOpt === "dev" || modeOpt === "prod") {
     mode = modeOpt;
   } else {
-    var nodeEnv = process.env.NODE_ENV;
+    var nodeEnv = safeEnv.readVar("NODE_ENV");
     mode = (nodeEnv === "production") ? "prod" : "dev";
   }
 

package/lib/external-db.js

@@ -53,6 +53,7 @@
 var retryHelper = require("./retry");
 var C = require("./constants");
 var lazyRequire = require("./lazy-require");
+var safeAsync = require("./safe-async");
 var { ExternalDbError } = require("./framework-error");
 
 var audit = lazyRequire(function () { return require("./audit"); });
@@ -78,8 +79,8 @@ class Pool {
     this.idle = [];     // [{ client, lastUsedAt }]
     this.active = 0;    // count of in-use clients
     this.waiters = [];  // queued acquisitions when at max
-    this._reaper = setInterval(this._reapIdle.bind(this), C.TIME.seconds(10));
-    this._reaper.unref();
+    this._reaper = safeAsync.repeating(this._reapIdle.bind(this),
+      C.TIME.seconds(10), { name: "external-db-reaper" });
   }
 
   async acquire() {
@@ -141,7 +142,7 @@ class Pool {
   }
 
   async drain() {
-    if (this._reaper) { clearInterval(this._reaper); this._reaper = null; }
+    if (this._reaper) { this._reaper.stop(); this._reaper = null; }
     var idleClients = this.idle.map(function (e) { return e.client; });
     this.idle = [];
     var self = this;

package/lib/forms.js

@@ -35,7 +35,7 @@
  *   forms.escapeAttribute(value)       → string (double-quoted-attr context)
  *   forms.escapeHtml = template.escapeHtml (re-export for convenience)
  */
-var nodeCrypto = require("crypto");
+var crypto = require("./crypto");
 var safeSchema = require("./safe-schema");
 var safeUrl = require("./safe-url");
 var template = require("./template");
@@ -47,16 +47,13 @@ var template = require("./template");
 var CSRF_TOKEN_BYTES = 32;
 
 function generateCsrfToken() {
-  return nodeCrypto.randomBytes(CSRF_TOKEN_BYTES).toString("hex");
+  return crypto.generateToken(CSRF_TOKEN_BYTES);
 }
 
 function verifyCsrfToken(submitted, expected) {
   if (typeof submitted !== "string" || typeof expected !== "string") return false;
   if (submitted.length === 0 || submitted.length !== expected.length) return false;
-  var a = Buffer.from(submitted, "utf8");
-  var b = Buffer.from(expected, "utf8");
-  if (a.length !== b.length) return false;
-  return nodeCrypto.timingSafeEqual(a, b);
+  return crypto.timingSafeEqual(submitted, expected);
 }
 
 // ============================================================

package/lib/http-client-cookie-jar.js

@@ -43,6 +43,7 @@
  *   }
  */
 
+var C = require("./constants");
 var safeUrl = require("./safe-url");
 var { defineClass } = require("./framework-error");
 
@@ -186,7 +187,7 @@ function create(opts) {
     if (attrs["max-age"] !== undefined) {
       var maxAge = parseInt(attrs["max-age"], 10);
       if (!isNaN(maxAge)) {
-        expiresAt = maxAge <= 0 ? 0 : (now + maxAge * 1000);
+        expiresAt = maxAge <= 0 ? 0 : (now + C.TIME.seconds(maxAge));
       }
     } else if (attrs.expires) {
       expiresAt = _parseHttpDate(attrs.expires);

package/lib/http-client.js

@@ -64,10 +64,10 @@
 var http  = require("http");
 var https = require("https");
 var http2 = require("http2");
-var nodeCrypto = require("node:crypto");
 var nodeStream = require("node:stream");
 var { URL } = require("url");
 var C = require("./constants");
+var crypto = require("./crypto");
 var pqcAgent = require("./pqc-agent");
 var safeAsync = require("./safe-async");
 var safeBuffer = require("./safe-buffer");
@@ -356,7 +356,7 @@ function _attachJarCookie(headers, jar, url) {
 // parser accepts so round-trip from one blamejs app's outbound to
 // another's inbound is exact.
 function _buildMultipartBody(spec) {
-  var boundary = "----blamejs-mp-" + nodeCrypto.randomBytes(16).toString("hex");
+  var boundary = "----blamejs-mp-" + crypto.generateToken(16);
   var CRLF = "\r\n";
   var parts = [];
 

package/lib/log.js

@@ -60,6 +60,7 @@
  */
 
 var { AsyncLocalStorage } = require("node:async_hooks");
+var nodeCrypto = require("node:crypto");
 var redact = require("./redact");
 var validateOpts = require("./validate-opts");
 var { FrameworkError } = require("./framework-error");
@@ -315,7 +316,7 @@ function create(opts) {
         ? mwOpts.generate
         : function () {
           // 16 random hex chars — short, sufficient correlation entropy
-          return require("crypto").randomBytes(8).toString("hex");
+          return nodeCrypto.randomBytes(8).toString("hex");
         };
       return function logRequestIdMiddleware(req, res, next) {
         var inbound = req.headers && req.headers[headerName];