@redocly/cli 2.39.0 → 2.41.0

package/lib/chunks/{WST4KAJO.js → ZBZADNJT.js}

@@ -1,5 +1,19 @@
 import { createRequire as __createRequire } from 'node:module';
 const require = __createRequire(import.meta.url);
+import {
+  compileOpenApiPath,
+  getPathWithoutTrailingSlash,
+  isJsonMime,
+  isSyntheticHost,
+  listOpenApiFiles,
+  normalizeServerPrefix,
+  parseHeaderIgnoreList,
+  parseUrl,
+  pickSchemaByMime,
+  resolvePathForServer,
+  shouldIgnoreHeaderAsUndocumented,
+  splitSetCookieHeader
+} from "./ER45DAHG.js";
 import {
   BaseResolver,
   blue,
@@ -21,7 +35,7 @@ import {
   require_dist,
   walkDocument,
   yellow
-} from "./KYZEVOA2.js";
+} from "./YK6T7IHG.js";
 import {
   __toESM
 } from "./5ILQMFXK.js";
@@ -422,278 +436,9 @@ function renderReport(result, options) {
   }
 }
 
-// src/commands/drift/utils/files.ts
-import { open, readdir, stat } from "node:fs/promises";
-import path2 from "node:path";
-var SPEC_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml", ".json"]);
-async function listOpenApiFiles(rootDir) {
-  const output = [];
-  async function walk(currentDir) {
-    const entries = await readdir(currentDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name.startsWith(".")) {
-        continue;
-      }
-      const absolutePath = path2.join(currentDir, entry.name);
-      if (entry.isDirectory()) {
-        await walk(absolutePath);
-        continue;
-      }
-      if (entry.isFile() && SPEC_FILE_EXTENSIONS.has(path2.extname(entry.name).toLowerCase())) {
-        output.push(absolutePath);
-      }
-    }
-  }
-  await walk(rootDir);
-  output.sort();
-  return output;
-}
-async function readProbe(filePath, maxBytes = 4096) {
-  const fileHandle = await open(filePath, "r");
-  try {
-    const buffer = Buffer.allocUnsafe(maxBytes);
-    const { bytesRead } = await fileHandle.read(buffer, 0, maxBytes, 0);
-    return buffer.toString("utf8", 0, bytesRead);
-  } finally {
-    await fileHandle.close();
-  }
-}
-function normalizeFsPath(value) {
-  return path2.resolve(process.cwd(), value);
-}
-async function listFilesRecursively(rootPath) {
-  const stats = await stat(rootPath);
-  if (stats.isFile()) {
-    return [rootPath];
-  }
-  if (!stats.isDirectory()) {
-    return [];
-  }
-  const output = [];
-  async function walk(currentDir) {
-    const entries = await readdir(currentDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name.startsWith(".")) {
-        continue;
-      }
-      const absolutePath = path2.join(currentDir, entry.name);
-      if (entry.isDirectory()) {
-        await walk(absolutePath);
-        continue;
-      }
-      if (entry.isFile()) {
-        output.push(absolutePath);
-      }
-    }
-  }
-  await walk(rootPath);
-  output.sort();
-  return output;
-}
-
 // src/commands/drift/engine/validation-session.ts
 import { randomUUID } from "node:crypto";
 
-// src/commands/drift/utils/http.ts
-var DUMMY_HOST = "drift.local";
-var DUMMY_BASE_URL = `http://${DUMMY_HOST}`;
-function isSyntheticHost(host) {
-  return host === DUMMY_HOST;
-}
-var IGNORED_UNDOCUMENTED_HEADERS = /* @__PURE__ */ new Set([
-  "accept",
-  "accept-charset",
-  "accept-encoding",
-  "accept-language",
-  "authorization",
-  "baggage",
-  "cache-control",
-  "cdn-loop",
-  "cookie",
-  "connection",
-  "content-length",
-  "content-type",
-  "dpr",
-  "dnt",
-  "downlink",
-  "ect",
-  "forwarded",
-  "host",
-  "if-match",
-  "if-modified-since",
-  "if-none-match",
-  "if-range",
-  "if-unmodified-since",
-  "origin",
-  "pragma",
-  "priority",
-  "range",
-  "referer",
-  "sec-fetch-dest",
-  "sec-fetch-mode",
-  "sec-fetch-site",
-  "sec-fetch-user",
-  "sec-gpc",
-  "sentry-trace",
-  "te",
-  "traceparent",
-  "tracestate",
-  "upgrade",
-  "upgrade-insecure-requests",
-  "user-agent",
-  "via",
-  "x-amzn-trace-id",
-  "x-client-trace-id",
-  "x-cloud-trace-context",
-  "x-correlation-id",
-  "x-http-method-override",
-  "x-method-override",
-  "x-real-ip",
-  "x-request-id",
-  "x-forwarded-for",
-  "x-forwarded-host",
-  "x-forwarded-port",
-  "x-forwarded-proto"
-]);
-var IGNORED_UNDOCUMENTED_HEADER_PREFIXES = [
-  "cf-",
-  "sec-ch-",
-  "sec-fetch-",
-  "x-b3-",
-  "x-envoy-",
-  "x-forwarded-"
-];
-var SET_COOKIE_SEPARATOR = "\n";
-function splitSetCookieHeader(value) {
-  return value.split(SET_COOKIE_SEPARATOR);
-}
-function appendHeaderValue(result, name, value) {
-  const key = name.toLowerCase();
-  const existing = result[key];
-  if (existing === void 0) {
-    result[key] = value;
-    return;
-  }
-  result[key] = key === "set-cookie" ? `${existing}${SET_COOKIE_SEPARATOR}${value}` : `${existing},${value}`;
-}
-function normalizeHeaders(input) {
-  if (!isPlainObject(input) && !Array.isArray(input)) {
-    return {};
-  }
-  const result = {};
-  if (Array.isArray(input)) {
-    for (const item of input) {
-      if (!isPlainObject(item)) {
-        continue;
-      }
-      const { name, value } = item;
-      if (typeof name === "string" && value !== void 0) {
-        appendHeaderValue(result, name, String(value));
-      }
-    }
-    return result;
-  }
-  for (const [key, value] of Object.entries(input)) {
-    if (value === void 0 || value === null) {
-      continue;
-    }
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        appendHeaderValue(result, key, String(item));
-      }
-      continue;
-    }
-    appendHeaderValue(result, key, String(value));
-  }
-  return result;
-}
-function parseUrl(input) {
-  try {
-    return new URL(input);
-  } catch {
-    return new URL(input, DUMMY_BASE_URL);
-  }
-}
-function getPathWithoutTrailingSlash(pathname) {
-  if (pathname.length > 1 && pathname.endsWith("/")) {
-    return pathname.slice(0, -1);
-  }
-  return pathname;
-}
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function compileOpenApiPath(pathTemplate) {
-  const params = [];
-  let score = 0;
-  const absolutePath = pathTemplate.startsWith("/") ? pathTemplate : `/${pathTemplate}`;
-  const normalizedPath = getPathWithoutTrailingSlash(absolutePath);
-  const regexBody = normalizedPath.split("/").map((segment) => {
-    if (!segment) {
-      return "";
-    }
-    const paramMatch = segment.match(/^\{([^}]+)\}$/);
-    if (paramMatch) {
-      params.push(paramMatch[1]);
-      return "([^/]+)";
-    }
-    score += 2;
-    return escapeRegex(segment);
-  }).join("/");
-  return {
-    regex: new RegExp(`^${regexBody || "/"}$`),
-    params,
-    score
-  };
-}
-function parseJsonBodyIfPresent(contentType, bodyText) {
-  if (!bodyText) {
-    return void 0;
-  }
-  if (!isJsonMime(contentType)) {
-    return void 0;
-  }
-  try {
-    return JSON.parse(bodyText);
-  } catch {
-    return void 0;
-  }
-}
-function normalizeContentType(contentType) {
-  if (!contentType) {
-    return "";
-  }
-  return contentType.split(";")[0]?.trim().toLowerCase() ?? "";
-}
-function isJsonMime(contentType) {
-  const mime = normalizeContentType(contentType);
-  return mime === "application/json" || mime.endsWith("+json");
-}
-function pickSchemaByMime(contentMap, contentType) {
-  const requestedMime = normalizeContentType(contentType);
-  if (!requestedMime) {
-    return contentMap["application/json"] ?? contentMap["*/*"];
-  }
-  if (contentMap[requestedMime] !== void 0) {
-    return contentMap[requestedMime];
-  }
-  const [type, subtype] = requestedMime.split("/");
-  if (type && subtype) {
-    const wildcardSubtype = `${type}/*`;
-    if (contentMap[wildcardSubtype] !== void 0) {
-      return contentMap[wildcardSubtype];
-    }
-  }
-  return contentMap["*/*"];
-}
-function shouldIgnoreHeaderAsUndocumented(headerName) {
-  const normalizedHeaderName = headerName.toLowerCase();
-  if (normalizedHeaderName.startsWith(":")) {
-    return true;
-  }
-  return IGNORED_UNDOCUMENTED_HEADERS.has(normalizedHeaderName) || IGNORED_UNDOCUMENTED_HEADER_PREFIXES.some((prefix) => normalizedHeaderName.startsWith(prefix));
-}
-
 // src/commands/drift/openapi/matcher.ts
 function toRelativePath(requestPath, server) {
   const normalizedRequestPath = getPathWithoutTrailingSlash(requestPath || "/") || "/";
@@ -1278,11 +1023,30 @@ function validateParameter(parameter, actualValue, context, findings) {
     });
   }
 }
+var DEEP_OBJECT_QUERY_KEY_REGEX = /^([^[\]]+)\[([^[\]]+)\]$/;
+function parseDeepObjectQueryKey(key) {
+  const keyMatch = key.match(DEEP_OBJECT_QUERY_KEY_REGEX);
+  return keyMatch ? { parameterName: keyMatch[1], property: keyMatch[2] } : void 0;
+}
+function getDeepObjectParameterValue(parameterName, query) {
+  let objectValue;
+  for (const [key, value] of query) {
+    const deepObjectKey = parseDeepObjectQueryKey(key);
+    if (deepObjectKey?.parameterName === parameterName) {
+      objectValue ??= {};
+      objectValue[deepObjectKey.property] = value;
+    }
+  }
+  return objectValue;
+}
 function getActualParameterValue(parameter, context, cookies) {
   switch (parameter.in) {
     case "path":
       return context.matchedOperation?.pathParams[parameter.name];
     case "query": {
+      if (parameter.style === "deepObject") {
+        return getDeepObjectParameterValue(parameter.name, context.exchange.request.query);
+      }
       const values = context.exchange.request.query.getAll(parameter.name);
       if (values.length === 0) {
         return void 0;
@@ -1308,29 +1072,38 @@ function createUndocumentedParameterFindings(context, matchedOperation) {
     header: /* @__PURE__ */ new Set(),
     cookie: /* @__PURE__ */ new Set()
   };
+  const deepObjectQueryParams = /* @__PURE__ */ new Set();
   for (const parameter of matchedOperation.operation.requestParameters) {
     if (parameter.in === "header") {
       paramsByLocation.header.add(parameter.name.toLowerCase());
     } else if (parameter.in === "query" || parameter.in === "cookie") {
       paramsByLocation[parameter.in].add(parameter.name);
+      if (parameter.in === "query" && parameter.style === "deepObject") {
+        deepObjectQueryParams.add(parameter.name);
+      }
     }
   }
   for (const name of new Set(context.exchange.request.query.keys())) {
-    if (!paramsByLocation.query.has(name)) {
-      findings.push({
-        ruleId: "schema-consistency",
-        severity: "warning",
-        category: "documentation",
-        message: `Undocumented query parameter in traffic: "${name}"`,
-        exchangeIndex: context.exchange.index,
-        operationId: matchedOperation.operation.operationId,
-        specSource: matchedOperation.operation.specSource,
-        target: "request"
-      });
+    if (paramsByLocation.query.has(name)) {
+      continue;
     }
+    const deepObjectKey = parseDeepObjectQueryKey(name);
+    if (deepObjectKey && deepObjectQueryParams.has(deepObjectKey.parameterName)) {
+      continue;
+    }
+    findings.push({
+      ruleId: "schema-consistency",
+      severity: "warning",
+      category: "documentation",
+      message: `Undocumented query parameter in traffic: "${name}"`,
+      exchangeIndex: context.exchange.index,
+      operationId: matchedOperation.operation.operationId,
+      specSource: matchedOperation.operation.specSource,
+      target: "request"
+    });
   }
   for (const headerName of Object.keys(context.exchange.request.headers)) {
-    if (shouldIgnoreHeaderAsUndocumented(headerName)) {
+    if (shouldIgnoreHeaderAsUndocumented(headerName, context.ignoreHeaders)) {
       continue;
     }
     if (!paramsByLocation.header.has(headerName.toLowerCase())) {
@@ -1348,6 +1121,10 @@ function createUndocumentedParameterFindings(context, matchedOperation) {
   }
   return findings;
 }
+function isRequestRejectedByServer(context) {
+  const response = context.exchange.response;
+  return response !== void 0 && response.status >= 400 && response.status < 500;
+}
 function pickResponseSchema(context, matchedOperation) {
   const response = context.exchange.response;
   if (!response) {
@@ -1393,65 +1170,67 @@ var SchemaConsistencyRule = class {
     const findings = [];
     const cookies = parseCookies(context.exchange.request.headers.cookie);
     findings.push(...createUndocumentedParameterFindings(context, matchedOperation));
-    for (const parameter of matchedOperation.operation.requestParameters) {
-      if (context.ignoreCookies && parameter.in === "cookie") {
-        continue;
+    if (!isRequestRejectedByServer(context)) {
+      for (const parameter of matchedOperation.operation.requestParameters) {
+        if (context.ignoreCookies && parameter.in === "cookie") {
+          continue;
+        }
+        const actualValue = getActualParameterValue(parameter, context, cookies);
+        if (parameter.required && (actualValue === void 0 || actualValue === null)) {
+          findings.push({
+            ruleId: this.id,
+            severity: "error",
+            category: "documentation",
+            message: `Missing required ${parameter.in} parameter: "${parameter.name}"`,
+            exchangeIndex: context.exchange.index,
+            operationId: matchedOperation.operation.operationId,
+            specSource: matchedOperation.operation.specSource,
+            target: "request"
+          });
+          continue;
+        }
+        validateParameter(parameter, actualValue, context, findings);
       }
-      const actualValue = getActualParameterValue(parameter, context, cookies);
-      if (parameter.required && (actualValue === void 0 || actualValue === null)) {
+      const requestContentType = context.exchange.request.contentType;
+      const requestSchema = pickSchemaByMime(
+        matchedOperation.operation.requestBodyContent,
+        requestContentType
+      );
+      const hasRequestBody = hasBodyContent(context.exchange.request.bodyText);
+      if (matchedOperation.operation.requestBodyRequired && !hasRequestBody) {
         findings.push({
           ruleId: this.id,
           severity: "error",
           category: "documentation",
-          message: `Missing required ${parameter.in} parameter: "${parameter.name}"`,
+          message: "Missing required request body",
           exchangeIndex: context.exchange.index,
           operationId: matchedOperation.operation.operationId,
           specSource: matchedOperation.operation.specSource,
           target: "request"
         });
-        continue;
       }
-      validateParameter(parameter, actualValue, context, findings);
-    }
-    const requestContentType = context.exchange.request.contentType;
-    const requestSchema = pickSchemaByMime(
-      matchedOperation.operation.requestBodyContent,
-      requestContentType
-    );
-    const hasRequestBody = hasBodyContent(context.exchange.request.bodyText);
-    if (matchedOperation.operation.requestBodyRequired && !hasRequestBody) {
-      findings.push({
-        ruleId: this.id,
-        severity: "error",
-        category: "documentation",
-        message: "Missing required request body",
-        exchangeIndex: context.exchange.index,
-        operationId: matchedOperation.operation.operationId,
-        specSource: matchedOperation.operation.specSource,
-        target: "request"
-      });
-    }
-    if (requestSchema && hasRequestBody && isJsonMime(requestContentType)) {
-      if (context.exchange.request.bodyJson === void 0) {
-        findings.push({
-          ruleId: this.id,
-          severity: "error",
-          category: "schema",
-          message: "Request body is not valid JSON for JSON content-type",
-          exchangeIndex: context.exchange.index,
-          operationId: matchedOperation.operation.operationId,
-          specSource: matchedOperation.operation.specSource,
-          target: "request"
-        });
-      } else {
-        findings.push(
-          ...validateSchemaResult(
-            requestSchema,
-            context.exchange.request.bodyJson,
-            context,
-            "request"
-          )
-        );
+      if (requestSchema && hasRequestBody && isJsonMime(requestContentType)) {
+        if (context.exchange.request.bodyJson === void 0) {
+          findings.push({
+            ruleId: this.id,
+            severity: "error",
+            category: "schema",
+            message: "Request body is not valid JSON for JSON content-type",
+            exchangeIndex: context.exchange.index,
+            operationId: matchedOperation.operation.operationId,
+            specSource: matchedOperation.operation.specSource,
+            target: "request"
+          });
+        } else {
+          findings.push(
+            ...validateSchemaResult(
+              requestSchema,
+              context.exchange.request.bodyJson,
+              context,
+              "request"
+            )
+          );
+        }
       }
     }
     const responseSchema = pickResponseSchema(context, matchedOperation);
@@ -1732,7 +1511,9 @@ function createSecuritySummary(issues) {
   if (optionSummaries.length === 1) {
     return `Authentication check failed. ${optionSummaries[0]}`;
   }
-  return `None of the documented authentication options matched. Any one of these options would satisfy the OpenAPI security requirements: ${optionSummaries.join(" | ")}`;
+  return `None of the documented authentication options matched. Any one of these options would satisfy the OpenAPI security requirements: ${optionSummaries.join(
+    " | "
+  )}`;
 }
 function getSensitiveQueryKeys(context) {
   return Array.from(context.exchange.request.query.keys()).filter((key) => {
@@ -1740,8 +1521,21 @@ function getSensitiveQueryKeys(context) {
     return normalizedKey.includes("token") || normalizedKey.includes("apikey") || normalizedKey.includes("api_key") || normalizedKey.includes("access_key");
   });
 }
+var LOOPBACK_HOSTNAME_PATTERN = /^(?:(?:.+\.)?localhost|127(?:\.\d{1,3}){3}|::1)$/i;
+function isLoopbackRequest(request) {
+  let hostname;
+  try {
+    hostname = new URL(request.url).hostname;
+  } catch {
+    hostname = request.host?.replace(/:\d+$/, "");
+  }
+  if (!hostname) {
+    return false;
+  }
+  return LOOPBACK_HOSTNAME_PATTERN.test(hostname.replace(/^\[|\]$/g, ""));
+}
 function shouldFlagInsecureTransport(context) {
-  if (context.exchange.request.protocol !== "http:" || !context.exchange.request.protocolKnown) {
+  if (context.exchange.request.protocol !== "http:" || !context.exchange.request.protocolKnown || isLoopbackRequest(context.exchange.request)) {
     return {
       flag: false,
       hasAuthHeader: false,
@@ -1835,9 +1629,9 @@ var UndocumentedEndpointRule = class {
     if (context.matchedOperation) {
       return [];
     }
-    const { method, path: path3, host } = context.exchange.request;
+    const { method, path: path2, host } = context.exchange.request;
     const isHostMismatch = context.matchMode === "strict-host" && !context.hostCompatibleWithSpecServers;
-    const message = isHostMismatch ? `Undocumented server: ${method} ${path3} was sent to "${host}", which does not match any server in the description` : `Undocumented endpoint: ${method} ${path3}`;
+    const message = isHostMismatch ? `Undocumented server: ${method} ${path2} was sent to "${host}", which does not match any server in the description` : `Undocumented endpoint: ${method} ${path2}`;
     return [
       {
         ruleId: this.id,
@@ -1879,34 +1673,6 @@ function loadRules(activeRuleIds) {
   });
 }
 
-// src/commands/drift/utils/server.ts
-function normalizeServerPrefix(server) {
-  const trimmed = server?.replace(/\/+$/, "");
-  return trimmed || void 0;
-}
-function stripPrefixFromPath(pathname, prefixPath) {
-  if (!prefixPath || prefixPath === "/") {
-    return pathname || "/";
-  }
-  if (pathname === prefixPath) {
-    return "/";
-  }
-  if (!pathname.startsWith(`${prefixPath}/`)) {
-    return void 0;
-  }
-  return pathname.slice(prefixPath.length) || "/";
-}
-function resolvePathForServer(request, server) {
-  if (server.startsWith("/")) {
-    return stripPrefixFromPath(request.path, server);
-  }
-  const serverUrl = parseUrl(server.includes("://") ? server : `http://${server}`);
-  if (isSyntheticHost(serverUrl.host) || request.host !== void 0 && request.host.toLowerCase() !== serverUrl.host) {
-    return void 0;
-  }
-  return stripPrefixFromPath(request.path, getPathWithoutTrailingSlash(serverUrl.pathname));
-}
-
 // src/commands/drift/engine/schema-validator.ts
 var import__ = __toESM(require__(), 1);
 var import_ajv_formats = __toESM(require_dist(), 1);
@@ -2175,6 +1941,7 @@ var ValidationSession = class _ValidationSession {
   problemKeyStats = /* @__PURE__ */ new Map();
   totalProblemGroups = 0;
   server;
+  ignoreHeaders;
   minSeverityRank;
   specServerHosts;
   hasHostlessSpecServer;
@@ -2182,6 +1949,7 @@ var ValidationSession = class _ValidationSession {
     this.options = options;
     this.rules = rules;
     this.server = normalizeServerPrefix(options.server);
+    this.ignoreHeaders = options.ignoreHeaders ? parseHeaderIgnoreList(options.ignoreHeaders) : void 0;
     const { specServerHosts, hasHostlessSpecServer } = collectSpecServerHosts(options.openApiIndex);
     this.specServerHosts = specServerHosts;
     this.hasHostlessSpecServer = hasHostlessSpecServer;
@@ -2229,6 +1997,7 @@ var ValidationSession = class _ValidationSession {
       matchMode: this.options.matchMode,
       hostCompatibleWithSpecServers: relativePathOverride !== void 0 || hostCompatible,
       ignoreCookies: this.options.ignoreCookies ?? false,
+      ignoreHeaders: this.ignoreHeaders,
       validateSchema: (schema, value, options) => options?.coerce ? this.coercingSchemaValidator.validate(schema, value, options?.target) : this.schemaValidator.validate(schema, value, options?.target)
     });
     const records = [];
@@ -2295,7 +2064,7 @@ var ValidationSession = class _ValidationSession {
 };
 
 // src/commands/drift/openapi/loader.ts
-import { stat as stat2 } from "node:fs/promises";
+import { stat } from "node:fs/promises";
 
 // src/commands/drift/utils/openapi.ts
 function resolveServerUrl(rawUrl, variables) {
@@ -2351,6 +2120,7 @@ function normalizeParameters(parameters) {
       name: String(entry.name ?? ""),
       in: location,
       required: Boolean(entry.required) || location === "path",
+      style: typeof entry.style === "string" ? entry.style : void 0,
       schema: entry.schema
     });
   }
@@ -2570,7 +2340,7 @@ function finalizeIndex(operationsByMethod, loadedSpecs) {
   return { operationsByMethod, loadedSpecs, loadedOperations };
 }
 async function resolveSpecFiles(specPath) {
-  const stats = await stat2(specPath);
+  const stats = await stat(specPath);
   if (stats.isDirectory()) {
     return { specFiles: await listOpenApiFiles(specPath), fromDirectory: true };
   }
@@ -2626,162 +2396,8 @@ function parseCsv(input) {
   return input.split(",").map((value) => value.trim()).filter(Boolean);
 }
 
-// src/commands/drift/log-formats/helpers.ts
-import { createReadStream } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { createInterface } from "node:readline";
-function coerceString(value) {
-  if (value === void 0 || value === null) {
-    return void 0;
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  if (Buffer.isBuffer(value)) {
-    return value.toString("utf8");
-  }
-  if (isPlainObject(value) || Array.isArray(value)) {
-    try {
-      return JSON.stringify(value);
-    } catch {
-      return String(value);
-    }
-  }
-  return String(value);
-}
-function coerceNumber(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) {
-      return parsed;
-    }
-  }
-  return void 0;
-}
-function decodeBody(value, encoding) {
-  if (value === void 0 || value === null) {
-    return void 0;
-  }
-  if (encoding === "base64" && typeof value === "string") {
-    try {
-      return Buffer.from(value, "base64").toString("utf8");
-    } catch {
-      return value;
-    }
-  }
-  return coerceString(value);
-}
-function createNormalizedExchange(seed, index, source) {
-  const method = seed.method?.toUpperCase();
-  const url = seed.url;
-  if (!method || !url) {
-    return null;
-  }
-  const requestHeaders = normalizeHeaders(seed.requestHeaders);
-  let parsedUrl = parseUrl(url);
-  if (isSyntheticHost(parsedUrl.host) && requestHeaders.host) {
-    try {
-      parsedUrl = new URL(
-        `${parsedUrl.protocol}//${requestHeaders.host}${parsedUrl.pathname}${parsedUrl.search}`
-      );
-    } catch {
-      parsedUrl = parseUrl(url);
-    }
-  }
-  const requestContentType = seed.requestContentType ?? requestHeaders["content-type"];
-  const requestBodyText = decodeBody(seed.requestBody);
-  const request = {
-    method,
-    url: parsedUrl.toString(),
-    path: parsedUrl.pathname,
-    query: parsedUrl.searchParams,
-    protocol: parsedUrl.protocol,
-    protocolKnown: seed.schemeKnown ?? /^https?:\/\//i.test(url),
-    host: isSyntheticHost(parsedUrl.host) ? void 0 : parsedUrl.host || void 0,
-    headers: requestHeaders,
-    contentType: requestContentType,
-    bodyText: requestBodyText,
-    bodyJson: parseJsonBodyIfPresent(requestContentType, requestBodyText)
-  };
-  let response;
-  const responseStatus = seed.responseStatus;
-  if (responseStatus !== void 0) {
-    const responseHeaders = normalizeHeaders(seed.responseHeaders);
-    const responseContentType = seed.responseContentType ?? responseHeaders["content-type"];
-    const responseBodyText = decodeBody(seed.responseBody);
-    response = {
-      status: responseStatus,
-      statusText: seed.responseStatusText,
-      headers: responseHeaders,
-      contentType: responseContentType,
-      bodyText: responseBodyText,
-      bodyJson: parseJsonBodyIfPresent(responseContentType, responseBodyText)
-    };
-  }
-  return {
-    index,
-    source,
-    startedAt: seed.startedAt,
-    request,
-    response,
-    raw: seed.raw
-  };
-}
-async function* streamNdjsonObjects(filePath) {
-  const readStream = createReadStream(filePath, { encoding: "utf8" });
-  const reader = createInterface({ input: readStream, crlfDelay: Infinity });
-  for await (const line of reader) {
-    const trimmed = line.trim();
-    if (!trimmed) {
-      continue;
-    }
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (isPlainObject(parsed)) {
-        yield parsed;
-      }
-    } catch {
-    }
-  }
-}
-async function* iterateJsonArray(filePath, arrayPath) {
-  const content = await readFile(filePath, "utf8");
-  let value = JSON.parse(content);
-  if (arrayPath) {
-    for (const key of arrayPath.split(".")) {
-      value = isPlainObject(value) ? value[key] : void 0;
-    }
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      if (isPlainObject(item)) {
-        yield item;
-      }
-    }
-  }
-}
-function pickHeaderContentType(headers) {
-  const normalized = normalizeHeaders(headers);
-  return normalized["content-type"];
-}
-
 export {
   renderReport,
-  readProbe,
-  normalizeFsPath,
-  listFilesRecursively,
-  normalizeContentType,
-  isJsonMime,
-  coerceString,
-  coerceNumber,
-  decodeBody,
-  createNormalizedExchange,
-  streamNdjsonObjects,
-  iterateJsonArray,
-  pickHeaderContentType,
   ValidationSession,
   loadOpenApiIndex,
   parseCsv