@req-inspect/core 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Luis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,35 @@
-# Temporary Holding Version
+# @req-inspect/core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Framework-agnostic core of [req-inspect](https://github.com/Hurishihara/req-inspect): record storage, redaction and the dashboard handler.
+
+## Install
+
+```sh
+npm i @req-inspect/core
+```
+
+## Usage
+
+Using Express? Install [`@req-inspect/express`](https://www.npmjs.com/package/@req-inspect/express) instead; it captures requests for you.
+
+The core package is for writing an adapter for another framework. It serves the dashboard and stores the records you hand it:
+
+```js
+import http from 'node:http'
+import { createInspector } from '@req-inspect/core'
+
+const inspector = createInspector() // same options as the Express middleware
+const app = (req, res) => res.end('hello')
+
+http.createServer((req, res) => {
+  const { pathname } = new URL(req.url, 'http://x')
+  if (inspector.options.enabled && inspector.isInspectorPath(pathname)) return inspector.handle(req, res)
+  app(req, res)
+}).listen(3000)
+```
+
+To capture traffic, build a `RecordDraft` for each finished request and pass it to `inspector.record(draft)`. Use `inspector.captureRequestBody(parsedBody, contentType)` for the request body and `captureRawBody(...)` for the response body. Redaction of headers, query strings and bodies happens inside `record`; drafts are unredacted.
+
+Open `http://localhost:3000/_inspect/` in your browser. Without `auth` it is only reachable from localhost.
+
+See the [root README](https://github.com/Hurishihara/req-inspect#readme) for options, security and known limitations.

package/dist/index.cjs

@@ -0,0 +1,589 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BODY_KEYS_DEFAULT: () => BODY_KEYS_DEFAULT,
+  DEFAULT_MAX_BODY_BYTES: () => DEFAULT_MAX_BODY_BYTES,
+  DEFAULT_MAX_REQUESTS: () => DEFAULT_MAX_REQUESTS,
+  DEFAULT_PATH: () => DEFAULT_PATH,
+  REDACTED: () => REDACTED,
+  REDACTED_HEADERS_DEFAULT: () => REDACTED_HEADERS_DEFAULT,
+  RingStore: () => RingStore,
+  captureParsedBody: () => captureParsedBody,
+  captureRawBody: () => captureRawBody,
+  checkAccess: () => checkAccess,
+  createHandler: () => createHandler,
+  createInspector: () => createInspector,
+  normalizeHeaders: () => normalizeHeaders,
+  redactBody: () => redactBody,
+  redactHeaders: () => redactHeaders,
+  resolveOptions: () => resolveOptions,
+  toSummary: () => toSummary,
+  warnOnce: () => warnOnce
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../../node_modules/.bun/tsup@9.0.0+c1a88b5bd57970a6/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/options.ts
+var DEFAULT_PATH = "/_inspect";
+var DEFAULT_MAX_REQUESTS = 500;
+var DEFAULT_MAX_BODY_BYTES = 65536;
+var REDACTED_HEADERS_DEFAULT = ["authorization", "cookie", "set-cookie", "x-api-key"];
+var BODY_KEYS_DEFAULT = [/password|token|secret|apikey|api_key/i];
+function normalizePath(path) {
+  let p = path.startsWith("/") ? path : `/${path}`;
+  while (p.length > 1 && p.endsWith("/")) p = p.slice(0, -1);
+  return p;
+}
+var isNonEmptyString = (v) => typeof v === "string" && v.length > 0;
+function resolveOptions(opts = {}, env = process.env) {
+  const auth = opts.auth ?? null;
+  if (auth !== null && !(isNonEmptyString(auth.user) && isNonEmptyString(auth.pass))) {
+    throw new TypeError("[req-inspect] auth.user and auth.pass must be non-empty strings");
+  }
+  const path = normalizePath(opts.path ?? DEFAULT_PATH);
+  if (path === "/") throw new TypeError("[req-inspect] path must not be the root");
+  const enabled = opts.enabled ?? (env.NODE_ENV !== "production" || auth !== null);
+  return {
+    path,
+    enabled,
+    auth,
+    maxRequests: opts.maxRequests ?? DEFAULT_MAX_REQUESTS,
+    maxBodyBytes: opts.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES,
+    ignore: opts.ignore ?? [],
+    redact: {
+      headers: /* @__PURE__ */ new Set([...REDACTED_HEADERS_DEFAULT, ...(opts.redact?.headers ?? []).map((h) => h.toLowerCase())]),
+      bodyKeys: [...BODY_KEYS_DEFAULT, ...opts.redact?.bodyKeys ?? []]
+    }
+  };
+}
+
+// src/store.ts
+var DEFAULT_LIST_LIMIT = 100;
+var MAX_LIST_LIMIT = 500;
+var numericId = (id) => Number(id.slice(2));
+var RingStore = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.buf = new Array(Math.max(1, Math.floor(capacity)));
+  }
+  capacity;
+  buf;
+  head = 0;
+  // index of the next write
+  size = 0;
+  counter = 0;
+  subs = /* @__PURE__ */ new Set();
+  nextId() {
+    this.counter += 1;
+    return `r_${String(this.counter).padStart(6, "0")}`;
+  }
+  add(record) {
+    this.buf[this.head] = record;
+    this.head = (this.head + 1) % this.buf.length;
+    if (this.size < this.buf.length) this.size += 1;
+    for (const fn of [...this.subs]) {
+      try {
+        fn(record);
+      } catch {
+        this.subs.delete(fn);
+      }
+    }
+  }
+  get(id) {
+    for (let i = 0; i < this.size; i++) {
+      const r = this.at(i);
+      if (r && r.id === id) return r;
+    }
+    return void 0;
+  }
+  /** Newest first. */
+  list(q = {}) {
+    const limit = Math.min(MAX_LIST_LIMIT, Math.max(1, Math.floor(q.limit ?? DEFAULT_LIST_LIMIT)));
+    const before = q.before === void 0 ? NaN : numericId(q.before);
+    const out = [];
+    for (let i = this.size - 1; i >= 0 && out.length < limit; i--) {
+      const r = this.at(i);
+      if (!r) continue;
+      if (!Number.isNaN(before) && numericId(r.id) >= before) continue;
+      out.push(r);
+    }
+    return out;
+  }
+  clear() {
+    this.buf.fill(void 0);
+    this.head = 0;
+    this.size = 0;
+  }
+  subscribe(fn) {
+    this.subs.add(fn);
+    return () => {
+      this.subs.delete(fn);
+    };
+  }
+  /** i-th oldest record (0 = oldest). */
+  at(i) {
+    const len = this.buf.length;
+    return this.buf[(this.head - this.size + i + len * 2) % len];
+  }
+};
+
+// src/body.ts
+var OCTET = "application/octet-stream";
+function baseType(ct) {
+  return (ct ?? "").split(";")[0].trim().toLowerCase();
+}
+function classifyContentType(ct) {
+  const t = baseType(ct);
+  if (t === "application/json" || t.endsWith("+json")) return "json";
+  if (t.startsWith("text/") || t === "application/x-www-form-urlencoded" || t === "application/xml" || t.endsWith("+xml")) return "text";
+  return "binary";
+}
+function truncateText(buf, maxBytes) {
+  const truncated = buf.length > maxBytes;
+  return { value: (truncated ? buf.subarray(0, maxBytes) : buf).toString("utf8"), truncated };
+}
+function captureParsedBody(value, contentType, maxBytes) {
+  if (value === void 0) return { kind: "none" };
+  if (Buffer.isBuffer(value)) {
+    return { kind: "binary", contentType: baseType(contentType) || OCTET, size: value.length };
+  }
+  if (typeof value === "string") {
+    const buf2 = Buffer.from(value, "utf8");
+    return { kind: "text", ...truncateText(buf2, maxBytes), size: buf2.length };
+  }
+  if (typeof value === "object" && value !== null && !contentType && !Array.isArray(value) && Object.keys(value).length === 0) {
+    return { kind: "none" };
+  }
+  let json;
+  try {
+    json = JSON.stringify(value);
+  } catch {
+    return { kind: "text", value: "[unserializable]", truncated: false, size: 0 };
+  }
+  if (json === void 0) return { kind: "text", value: "[unserializable]", truncated: false, size: 0 };
+  const buf = Buffer.from(json, "utf8");
+  if (buf.length <= maxBytes) return { kind: "json", value, truncated: false, size: buf.length };
+  return { kind: "text", ...truncateText(buf, maxBytes), size: buf.length };
+}
+function captureRawBody(chunks, totalSize, contentType, contentEncoding, maxBytes) {
+  if (totalSize === 0) return { kind: "none" };
+  if (contentEncoding) {
+    return { kind: "binary", contentType: baseType(contentType) || OCTET, size: totalSize, encoding: contentEncoding };
+  }
+  const kind = classifyContentType(contentType);
+  if (kind === "binary") return { kind: "binary", contentType: baseType(contentType) || OCTET, size: totalSize };
+  const { value, truncated } = truncateText(Buffer.concat(chunks), maxBytes);
+  const isTruncated = totalSize > maxBytes;
+  if (kind === "json" && !isTruncated) {
+    try {
+      return { kind: "json", value: JSON.parse(value), truncated: false, size: totalSize };
+    } catch {
+    }
+  }
+  return { kind: "text", value, truncated: isTruncated || truncated, size: totalSize };
+}
+
+// src/redact.ts
+var REDACTED = "[redacted]";
+function normalizeHeaders(h) {
+  const out = {};
+  for (const [name, value] of Object.entries(h)) {
+    if (value === void 0) continue;
+    out[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : String(value);
+  }
+  return out;
+}
+function redactHeaders(h, names) {
+  const out = {};
+  for (const [name, value] of Object.entries(h)) {
+    out[name] = names.has(name.toLowerCase()) ? REDACTED : value;
+  }
+  return out;
+}
+function isPlainObject(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+function keyMatcher(keys) {
+  const strings = /* @__PURE__ */ new Set();
+  const patterns = [];
+  for (const k of keys) {
+    if (typeof k === "string") strings.add(k.toLowerCase());
+    else patterns.push(k);
+  }
+  return (key) => {
+    if (strings.has(key.toLowerCase())) return true;
+    return patterns.some((re) => {
+      re.lastIndex = 0;
+      const hit = re.test(key);
+      re.lastIndex = 0;
+      return hit;
+    });
+  };
+}
+var JSON_PAIR = /"((?:[^"\\]|\\.)*)"(\s*:\s*)(?:"(?:[^"\\]|\\.)*(?:"|\\?$)|-?\d[\d.eE+-]*|true|false|null)/g;
+function decodeJsonKey(raw) {
+  try {
+    return JSON.parse(`"${raw}"`);
+  } catch {
+    return raw;
+  }
+}
+function scrubJsonText(text, keys) {
+  const matches = keyMatcher(keys);
+  return text.replace(JSON_PAIR, (whole, rawKey, sep2) => matches(decodeJsonKey(rawKey)) ? `"${rawKey}"${sep2}"${REDACTED}"` : whole);
+}
+function decodeQueryKey(raw) {
+  for (const k of new URLSearchParams(`${raw}=`).keys()) return k;
+  return raw;
+}
+function redactUrl(url, keys) {
+  const q = url.indexOf("?");
+  if (q < 0) return url;
+  const matches = keyMatcher(keys);
+  let changed = false;
+  const parts = url.slice(q + 1).split("&").map((part) => {
+    const eq = part.indexOf("=");
+    const rawKey = eq < 0 ? part : part.slice(0, eq);
+    if (rawKey === "" || !matches(decodeQueryKey(rawKey))) return part;
+    changed = true;
+    return `${rawKey}=${REDACTED}`;
+  });
+  return changed ? `${url.slice(0, q + 1)}${parts.join("&")}` : url;
+}
+function redactBody(value, keys) {
+  const matches = keyMatcher(keys);
+  const ancestors = /* @__PURE__ */ new Set();
+  const walk = (v) => {
+    const isArr = Array.isArray(v);
+    if (!isArr && !isPlainObject(v)) return v;
+    if (ancestors.has(v)) return "[circular]";
+    ancestors.add(v);
+    let out;
+    if (isArr) {
+      out = v.map(walk);
+    } else {
+      const obj = Object.getPrototypeOf(v) === null ? /* @__PURE__ */ Object.create(null) : {};
+      for (const [k, val] of Object.entries(v)) {
+        obj[k] = matches(k) ? REDACTED : walk(val);
+      }
+      out = obj;
+    }
+    ancestors.delete(v);
+    return out;
+  };
+  return walk(value);
+}
+
+// src/guard.ts
+var import_node_crypto = require("crypto");
+var LOOPBACK = /* @__PURE__ */ new Set(["127.0.0.1", "::1", "::ffff:127.0.0.1"]);
+var BASIC = /^basic\s+([A-Za-z0-9+/]+={0,2})\s*$/i;
+var digest = (s) => (0, import_node_crypto.createHash)("sha256").update(s).digest();
+var safeEqual = (a, b) => (0, import_node_crypto.timingSafeEqual)(digest(a), digest(b));
+function firstValue(v) {
+  return Array.isArray(v) ? v[0] : v;
+}
+function hostname(host) {
+  const h = host.trim().toLowerCase();
+  if (h.startsWith("[")) {
+    const end = h.indexOf("]");
+    return end < 0 ? "" : h.slice(1, end);
+  }
+  const colon = h.indexOf(":");
+  return colon >= 0 && colon === h.lastIndexOf(":") ? h.slice(0, colon) : h;
+}
+function isLocalHost(host) {
+  if (host === void 0) return false;
+  const name = hostname(host);
+  return name === "localhost" || name.endsWith(".localhost") || name === "127.0.0.1" || name === "::1";
+}
+function parseBasic(header) {
+  const m = header === void 0 ? null : BASIC.exec(header);
+  if (!m) return null;
+  const decoded = Buffer.from(m[1], "base64").toString("utf8");
+  const i = decoded.indexOf(":");
+  if (i < 0) return null;
+  return { user: decoded.slice(0, i), pass: decoded.slice(i + 1) };
+}
+function checkAccess(req, auth) {
+  if (!auth) {
+    const forwarded = req.headers["x-forwarded-for"] !== void 0 || req.headers["forwarded"] !== void 0;
+    if (forwarded || req.remoteAddress === void 0 || !LOOPBACK.has(req.remoteAddress)) return { ok: false, status: 403 };
+    if (!isLocalHost(firstValue(req.headers["host"]))) return { ok: false, status: 403 };
+    return { ok: true };
+  }
+  const creds = parseBasic(firstValue(req.headers["authorization"]));
+  if (!creds) return { ok: false, status: 401 };
+  const userOk = safeEqual(creds.user, auth.user);
+  const passOk = safeEqual(creds.pass, auth.pass);
+  return userOk && passOk ? { ok: true } : { ok: false, status: 401 };
+}
+
+// src/inspector.ts
+var import_node_path2 = require("path");
+var import_node_url = require("url");
+
+// src/http.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+
+// src/warn.ts
+var seen = /* @__PURE__ */ new Set();
+function warnOnce(key, err) {
+  if (seen.has(key)) return;
+  seen.add(key);
+  const message = err instanceof Error ? err.message : String(err);
+  console.warn(`[req-inspect] ${key}: ${message}`);
+}
+
+// src/http.ts
+var CONTENT_TYPES = {
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2",
+  ".html": "text/html; charset=utf-8",
+  ".json": "application/json; charset=utf-8"
+};
+function sendJson(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store",
+    "content-length": Buffer.byteLength(payload)
+  });
+  res.end(payload);
+}
+function fail(res, err) {
+  warnOnce("handler", err);
+  try {
+    if (!res.headersSent) sendJson(res, 500, { error: "internal error" });
+    else res.destroy();
+  } catch {
+    res.destroy();
+  }
+}
+var notFound = (res) => sendJson(res, 404, { error: "not found" });
+function decode(s) {
+  try {
+    const d = decodeURIComponent(s);
+    return d.includes("\0") ? null : d;
+  } catch {
+    return null;
+  }
+}
+async function sendFile(res, file) {
+  let data;
+  try {
+    data = await (0, import_promises.readFile)(file);
+  } catch {
+    return notFound(res);
+  }
+  res.writeHead(200, {
+    "content-type": CONTENT_TYPES[(0, import_node_path.extname)(file).toLowerCase()] ?? "application/octet-stream",
+    "content-length": data.length,
+    "x-content-type-options": "nosniff"
+  });
+  res.end(data);
+}
+async function serveIndex(res, uiDir) {
+  let data;
+  try {
+    data = await (0, import_promises.readFile)((0, import_node_path.resolve)(uiDir, "index.html"));
+  } catch {
+    res.writeHead(500, { "content-type": "text/plain; charset=utf-8" });
+    res.end(`req-inspect: dashboard files missing from package (expected at ${uiDir})`);
+    return;
+  }
+  res.writeHead(200, {
+    "content-type": CONTENT_TYPES[".html"],
+    "content-length": data.length,
+    "x-content-type-options": "nosniff"
+  });
+  res.end(data);
+}
+async function serveAsset(res, uiDir, rawRest) {
+  const rel = decode(rawRest);
+  if (rel === null || rel === "") return notFound(res);
+  const assetsDir = (0, import_node_path.resolve)(uiDir, "assets");
+  const target = (0, import_node_path.resolve)(uiDir, "assets", rel);
+  if (!target.startsWith(assetsDir + import_node_path.sep)) return notFound(res);
+  return sendFile(res, target);
+}
+function stream(res, req, store, keepAliveMs) {
+  res.writeHead(200, {
+    "content-type": "text/event-stream",
+    "cache-control": "no-store, no-transform",
+    connection: "keep-alive"
+  });
+  res.flushHeaders();
+  res.write("retry: 2000\n\n");
+  const unsubscribe = store.subscribe((r) => {
+    res.write(`event: record
+data: ${JSON.stringify(toSummary(r))}
+
+`);
+  });
+  const timer = setInterval(() => res.write(": ping\n\n"), keepAliveMs);
+  req.on("close", () => {
+    clearInterval(timer);
+    unsubscribe();
+  });
+}
+function createHandler(store, options, uiDir, keepAliveMs = 15e3) {
+  const mount = options.path === "/" ? "" : options.path;
+  const root = (0, import_node_path.resolve)(uiDir);
+  const dispatch = (req, res) => {
+    const access = checkAccess({ remoteAddress: req.socket.remoteAddress, headers: req.headers }, options.auth);
+    if (!access.ok) {
+      if (access.status === 401) res.setHeader("WWW-Authenticate", 'Basic realm="req-inspect"');
+      return sendJson(res, access.status, { error: access.status === 401 ? "unauthorized" : "forbidden" });
+    }
+    const url = req.originalUrl ?? req.url ?? "/";
+    const q = url.indexOf("?");
+    const pathname = q < 0 ? url : url.slice(0, q);
+    const query = new URLSearchParams(q < 0 ? "" : url.slice(q + 1));
+    if (mount !== "" && pathname === mount) {
+      res.writeHead(302, { Location: `${mount}/` });
+      return res.end();
+    }
+    if (!pathname.startsWith(`${mount}/`)) return notFound(res);
+    const rest = pathname.slice(mount.length);
+    const method = req.method ?? "GET";
+    if (method === "GET") {
+      if (rest === "/") {
+        serveIndex(res, root).catch((e) => fail(res, e));
+        return;
+      }
+      if (rest.startsWith("/assets/")) {
+        serveAsset(res, root, rest.slice("/assets/".length)).catch((e) => fail(res, e));
+        return;
+      }
+      if (rest === "/api/stream") return stream(res, req, store, keepAliveMs);
+      if (rest === "/api/requests") {
+        const n = Number(query.get("limit"));
+        const limit = query.get("limit") !== null && query.get("limit") !== "" && Number.isFinite(n) ? n : void 0;
+        const before = query.get("before") ?? void 0;
+        return sendJson(res, 200, store.list({ limit, before }).map(toSummary));
+      }
+      if (rest.startsWith("/api/requests/")) {
+        const id = decode(rest.slice("/api/requests/".length));
+        const record = id === null ? void 0 : store.get(id);
+        return record ? sendJson(res, 200, record) : notFound(res);
+      }
+    } else if (method === "DELETE" && rest === "/api/requests") {
+      store.clear();
+      res.writeHead(204, { "cache-control": "no-store" });
+      return res.end();
+    }
+    return notFound(res);
+  };
+  return (req, res) => {
+    try {
+      dispatch(req, res);
+    } catch (err) {
+      fail(res, err);
+    }
+  };
+}
+
+// src/inspector.ts
+function toSummary(r) {
+  const { request: _request, response: _response, ...summary } = r;
+  return summary;
+}
+function createInspector(options = {}, internal = {}) {
+  const opts = resolveOptions(options);
+  const store = new RingStore(opts.maxRequests);
+  const uiDir = internal.uiDir ?? (0, import_node_path2.join)((0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl)), "ui");
+  const handle = createHandler(store, opts, uiDir);
+  const keys = opts.redact.bodyKeys;
+  const redactCaptured = (b, contentType) => {
+    if (b.kind !== "json" && b.kind !== "text") return b;
+    if (typeof b.value !== "string") return { ...b, value: redactBody(b.value, keys) };
+    if (classifyContentType(contentType) === "json") return { ...b, value: scrubJsonText(b.value, keys) };
+    return b;
+  };
+  return {
+    options: opts,
+    store,
+    handle,
+    isInspectorPath: (p) => p === opts.path || p.startsWith(`${opts.path}/`),
+    shouldIgnore: (p) => opts.ignore.some((i) => typeof i === "string" ? p.startsWith(i) : i.test(p)),
+    captureRequestBody: (value, contentType) => captureParsedBody(redactBody(value, keys), contentType, opts.maxBodyBytes),
+    record(draft) {
+      setImmediate(() => {
+        try {
+          const { request, response } = draft;
+          const record = {
+            ...draft,
+            v: 1,
+            id: store.nextId(),
+            url: redactUrl(draft.url, keys),
+            request: {
+              ...request,
+              headers: redactHeaders(request.headers, opts.redact.headers),
+              query: redactBody(request.query, keys),
+              body: redactCaptured(request.body, request.headers["content-type"])
+            },
+            response: {
+              ...response,
+              headers: redactHeaders(response.headers, opts.redact.headers),
+              body: redactCaptured(response.body, response.headers["content-type"])
+            }
+          };
+          store.add(record);
+        } catch (err) {
+          warnOnce("record", err);
+        }
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BODY_KEYS_DEFAULT,
+  DEFAULT_MAX_BODY_BYTES,
+  DEFAULT_MAX_REQUESTS,
+  DEFAULT_PATH,
+  REDACTED,
+  REDACTED_HEADERS_DEFAULT,
+  RingStore,
+  captureParsedBody,
+  captureRawBody,
+  checkAccess,
+  createHandler,
+  createInspector,
+  normalizeHeaders,
+  redactBody,
+  redactHeaders,
+  resolveOptions,
+  toSummary,
+  warnOnce
+});