@vitest-evals/core 0.12.0

package/dist/node.js

@@ -0,0 +1,628 @@
+"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/node.ts
+var node_exports = {};
+__export(node_exports, {
+  readReportWorkspace: () => readReportWorkspace,
+  readVitestJsonReportFile: () => readVitestJsonReportFile,
+  resolveReportFiles: () => resolveReportFiles,
+  resolveResultFiles: () => resolveResultFiles,
+  splitReportInput: () => splitReportInput,
+  splitResultsInput: () => splitResultsInput
+});
+module.exports = __toCommonJS(node_exports);
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+
+// src/report/workspace.ts
+var import_zod6 = require("zod");
+
+// src/report/metadata.ts
+var import_zod4 = require("zod");
+
+// src/harness/index.ts
+var import_zod3 = require("zod");
+
+// src/json.ts
+var import_zod = require("zod");
+var JsonPrimitiveSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.number().finite(),
+  import_zod.z.boolean(),
+  import_zod.z.null()
+]);
+var JsonValueSchema = import_zod.z.lazy(
+  () => import_zod.z.union([
+    JsonPrimitiveSchema,
+    import_zod.z.array(JsonValueSchema),
+    import_zod.z.record(import_zod.z.string(), JsonValueSchema)
+  ])
+);
+var JsonObjectSchema = import_zod.z.record(import_zod.z.string(), JsonValueSchema);
+
+// src/schema-utils.ts
+var import_zod2 = require("zod");
+var FiniteNumberSchema = import_zod2.z.number().finite();
+var OptionalFiniteNumberSchema = import_zod2.z.preprocess(
+  (value) => value === null || typeof value === "number" && !Number.isFinite(value) ? void 0 : value,
+  FiniteNumberSchema.optional()
+);
+var NullableFiniteNumberSchema = import_zod2.z.preprocess(
+  (value) => typeof value === "number" && !Number.isFinite(value) ? null : value,
+  FiniteNumberSchema.nullable().optional()
+);
+function parseWithSchema(schema, input, label) {
+  const parsed = schema.safeParse(input);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  const reason = parsed.error.issues.slice(0, 3).map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+    return `${path}: ${issue.message}`;
+  }).join("; ");
+  throw new Error(`Invalid ${label}: ${reason}`);
+}
+function isJsonObject(value) {
+  return isRecord(value);
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/harness/index.ts
+var UsageSummarySchema = import_zod3.z.object({
+  provider: import_zod3.z.string().optional(),
+  model: import_zod3.z.string().optional(),
+  inputTokens: FiniteNumberSchema.optional(),
+  outputTokens: FiniteNumberSchema.optional(),
+  reasoningTokens: FiniteNumberSchema.optional(),
+  totalTokens: FiniteNumberSchema.optional(),
+  toolCalls: FiniteNumberSchema.optional(),
+  retries: FiniteNumberSchema.optional(),
+  metadata: JsonObjectSchema.optional()
+}).strict();
+var TimingSummarySchema = import_zod3.z.object({
+  totalMs: FiniteNumberSchema.optional(),
+  metadata: JsonObjectSchema.optional()
+}).strict();
+var NormalizedErrorSchema = import_zod3.z.object({
+  message: import_zod3.z.string(),
+  type: import_zod3.z.string().optional()
+}).catchall(JsonValueSchema);
+var ToolCallRecordSchema = import_zod3.z.object({
+  id: import_zod3.z.string().optional(),
+  name: import_zod3.z.string(),
+  arguments: JsonObjectSchema.optional(),
+  result: JsonValueSchema.optional(),
+  error: NormalizedErrorSchema.optional(),
+  startedAt: import_zod3.z.string().optional(),
+  finishedAt: import_zod3.z.string().optional(),
+  durationMs: FiniteNumberSchema.optional(),
+  metadata: JsonObjectSchema.optional()
+}).strict();
+var NormalizedMessageSchema = import_zod3.z.object({
+  role: import_zod3.z.enum(["system", "user", "assistant", "tool"]),
+  content: JsonValueSchema.optional(),
+  toolCalls: import_zod3.z.array(ToolCallRecordSchema).optional(),
+  metadata: JsonObjectSchema.optional()
+}).strict();
+var NormalizedSessionSchema = import_zod3.z.object({
+  messages: import_zod3.z.array(NormalizedMessageSchema).default([]),
+  provider: import_zod3.z.string().optional(),
+  model: import_zod3.z.string().optional(),
+  metadata: JsonObjectSchema.optional()
+}).strict();
+var NormalizedSpanAttributesSchema = JsonObjectSchema;
+var NormalizedSpanEventSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  timestamp: import_zod3.z.string().optional(),
+  attributes: NormalizedSpanAttributesSchema.optional()
+}).strict();
+var NormalizedSpanSchema = import_zod3.z.object({
+  id: import_zod3.z.string().optional(),
+  traceId: import_zod3.z.string().optional(),
+  parentId: import_zod3.z.string().optional(),
+  name: import_zod3.z.string(),
+  kind: import_zod3.z.enum(["run", "agent", "model", "tool", "guardrail", "handoff", "custom"]).optional(),
+  startedAt: import_zod3.z.string().optional(),
+  finishedAt: import_zod3.z.string().optional(),
+  durationMs: FiniteNumberSchema.optional(),
+  status: import_zod3.z.enum(["ok", "error"]).optional(),
+  error: NormalizedErrorSchema.optional(),
+  attributes: NormalizedSpanAttributesSchema.optional(),
+  events: import_zod3.z.array(NormalizedSpanEventSchema).optional()
+}).strict();
+var NormalizedTraceSchema = import_zod3.z.object({
+  id: import_zod3.z.string().optional(),
+  name: import_zod3.z.string().optional(),
+  startedAt: import_zod3.z.string().optional(),
+  finishedAt: import_zod3.z.string().optional(),
+  durationMs: FiniteNumberSchema.optional(),
+  metadata: JsonObjectSchema.optional(),
+  spans: import_zod3.z.array(NormalizedSpanSchema).default([])
+}).strict();
+var HarnessRunSchema = import_zod3.z.object({
+  output: JsonValueSchema.optional(),
+  session: NormalizedSessionSchema,
+  usage: UsageSummarySchema,
+  timings: TimingSummarySchema.optional(),
+  artifacts: JsonObjectSchema.optional(),
+  traces: import_zod3.z.array(NormalizedTraceSchema).optional(),
+  errors: import_zod3.z.array(JsonObjectSchema).default([])
+}).strict();
+
+// src/report/metadata.ts
+var HarnessMetaSchema = import_zod4.z.object({
+  name: import_zod4.z.string().optional(),
+  run: HarnessRunSchema.optional()
+}).strict();
+var EvalScoreSchema = import_zod4.z.object({
+  name: import_zod4.z.string().optional(),
+  score: NullableFiniteNumberSchema,
+  metadata: JsonObjectSchema.optional()
+}).strict();
+var EvalMetaSchema = import_zod4.z.object({
+  scores: import_zod4.z.array(EvalScoreSchema).optional(),
+  avgScore: NullableFiniteNumberSchema,
+  output: JsonValueSchema.optional(),
+  thresholdFailed: import_zod4.z.boolean().optional(),
+  toolCalls: import_zod4.z.array(ToolCallRecordSchema).optional()
+}).strict();
+var EvalTaskMetaSchema = import_zod4.z.object({
+  eval: EvalMetaSchema.optional(),
+  harness: HarnessMetaSchema.optional()
+}).strict();
+var LenientToolCallRecordSchema = ToolCallRecordSchema.strip();
+var LenientMessageSchema = NormalizedMessageSchema.extend({
+  toolCalls: import_zod4.z.array(LenientToolCallRecordSchema).optional().catch(void 0)
+}).strip();
+var LenientSessionSchema = NormalizedSessionSchema.extend({
+  messages: import_zod4.z.array(LenientMessageSchema).default([]).catch([])
+}).strip();
+var LenientSpanEventSchema = NormalizedSpanEventSchema.strip();
+var LenientSpanSchema = NormalizedSpanSchema.extend({
+  events: import_zod4.z.array(LenientSpanEventSchema).optional().catch(void 0)
+}).strip();
+var LenientTraceSchema = NormalizedTraceSchema.extend({
+  spans: import_zod4.z.array(LenientSpanSchema).default([]).catch([])
+}).strip();
+var LenientHarnessRunSchema = HarnessRunSchema.extend({
+  session: LenientSessionSchema,
+  usage: UsageSummarySchema.strip().default({}),
+  timings: TimingSummarySchema.strip().optional(),
+  traces: import_zod4.z.array(LenientTraceSchema).optional().catch(void 0)
+}).strip();
+var LenientHarnessMetaSchema = HarnessMetaSchema.extend({
+  run: LenientHarnessRunSchema.optional().catch(void 0)
+}).strip();
+var LenientEvalScoreSchema = EvalScoreSchema.strip();
+var LenientEvalMetaSchema = EvalMetaSchema.extend({
+  scores: import_zod4.z.array(LenientEvalScoreSchema).optional().catch(void 0),
+  toolCalls: import_zod4.z.array(LenientToolCallRecordSchema).optional().catch(void 0)
+}).strip();
+function readEvalTaskMeta(input) {
+  if (!isJsonObject(input)) {
+    return void 0;
+  }
+  const evalResult = LenientEvalMetaSchema.safeParse(input.eval);
+  const harnessResult = LenientHarnessMetaSchema.safeParse(input.harness);
+  const meta = {
+    ...evalResult.success && input.eval !== void 0 ? { eval: evalResult.data } : {},
+    ...harnessResult.success && input.harness !== void 0 ? { harness: harnessResult.data } : {}
+  };
+  return meta.eval || meta.harness ? meta : void 0;
+}
+
+// src/report/vitest-json.ts
+var import_zod5 = require("zod");
+var VitestJsonStatusSchema = import_zod5.z.enum([
+  "passed",
+  "failed",
+  "skipped",
+  "pending",
+  "todo",
+  "disabled"
+]);
+var VitestJsonLocationSchema = import_zod5.z.object({
+  line: FiniteNumberSchema,
+  column: FiniteNumberSchema
+}).passthrough();
+var VitestJsonAssertionSchema = import_zod5.z.object({
+  ancestorTitles: import_zod5.z.array(import_zod5.z.string()).default([]),
+  fullName: import_zod5.z.string(),
+  status: VitestJsonStatusSchema,
+  title: import_zod5.z.string(),
+  meta: import_zod5.z.unknown().optional(),
+  duration: FiniteNumberSchema.nullable().optional(),
+  failureMessages: import_zod5.z.array(import_zod5.z.string()).nullable().optional(),
+  location: VitestJsonLocationSchema.nullable().optional(),
+  tags: import_zod5.z.array(import_zod5.z.string()).optional()
+}).passthrough();
+var VitestJsonFileSchema = import_zod5.z.object({
+  message: import_zod5.z.string(),
+  name: import_zod5.z.string(),
+  status: import_zod5.z.enum(["failed", "passed"]),
+  startTime: OptionalFiniteNumberSchema,
+  endTime: OptionalFiniteNumberSchema,
+  assertionResults: import_zod5.z.array(VitestJsonAssertionSchema).default([])
+}).passthrough();
+var VitestJsonReportSchema = import_zod5.z.object({
+  numFailedTests: FiniteNumberSchema,
+  numPassedTests: FiniteNumberSchema,
+  numPendingTests: FiniteNumberSchema,
+  numTodoTests: FiniteNumberSchema,
+  numTotalTests: FiniteNumberSchema,
+  startTime: FiniteNumberSchema,
+  success: import_zod5.z.boolean(),
+  testResults: import_zod5.z.array(VitestJsonFileSchema).default([])
+}).passthrough();
+function parseVitestJsonReport(input) {
+  return parseWithSchema(VitestJsonReportSchema, input, "Vitest JSON report");
+}
+
+// src/report/workspace.ts
+var REPORT_WORKSPACE_SCHEMA_VERSION = 1;
+var ReportRunSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  source: import_zod6.z.string().optional(),
+  status: import_zod6.z.enum(["passed", "failed"]),
+  startedAt: FiniteNumberSchema.optional(),
+  durationMs: FiniteNumberSchema.optional(),
+  totals: import_zod6.z.object({
+    total: FiniteNumberSchema,
+    passed: FiniteNumberSchema,
+    failed: FiniteNumberSchema,
+    skipped: FiniteNumberSchema,
+    evalTotal: FiniteNumberSchema,
+    evalPassed: FiniteNumberSchema,
+    evalFailed: FiniteNumberSchema
+  })
+}).strict();
+var ReportCaseSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  runId: import_zod6.z.string(),
+  source: import_zod6.z.string().optional(),
+  file: import_zod6.z.string(),
+  displayFile: import_zod6.z.string(),
+  title: import_zod6.z.string(),
+  fullName: import_zod6.z.string(),
+  ancestorTitles: import_zod6.z.array(import_zod6.z.string()),
+  tags: import_zod6.z.array(import_zod6.z.string()).optional(),
+  displayName: import_zod6.z.string(),
+  status: VitestJsonStatusSchema,
+  durationMs: FiniteNumberSchema.optional(),
+  location: VitestJsonLocationSchema.optional(),
+  failureMessages: import_zod6.z.array(import_zod6.z.string()).default([]),
+  eval: EvalMetaSchema.optional(),
+  harness: HarnessMetaSchema.optional()
+}).strict();
+var ReportWorkspaceSchema = import_zod6.z.object({
+  schemaVersion: import_zod6.z.literal(REPORT_WORKSPACE_SCHEMA_VERSION),
+  runs: import_zod6.z.array(ReportRunSchema),
+  cases: import_zod6.z.array(ReportCaseSchema)
+}).strict();
+function collectReportWorkspace(input, options = {}) {
+  const entries = Array.isArray(input) ? input : [input];
+  const runs = [];
+  const cases = [];
+  entries.forEach((entry, index) => {
+    const { report, source } = normalizeWorkspaceInput(entry);
+    const runId = source ?? `run-${index + 1}`;
+    const runCases = [];
+    for (const file of report.testResults) {
+      for (const assertion of file.assertionResults) {
+        const meta = readEvalTaskMeta(assertion.meta);
+        if (!meta) {
+          continue;
+        }
+        runCases.push({
+          id: createCaseId(runId, file.name, assertion),
+          runId,
+          ...source ? { source } : {},
+          file: file.name,
+          displayFile: normalizeReportPath(file.name, options.workspace),
+          title: assertion.title,
+          fullName: assertion.fullName,
+          ancestorTitles: assertion.ancestorTitles,
+          ...assertion.tags ? { tags: assertion.tags } : {},
+          displayName: formatDisplayName(assertion),
+          status: assertion.status,
+          ...typeof assertion.duration === "number" ? { durationMs: assertion.duration } : {},
+          ...assertion.location ? { location: assertion.location } : {},
+          failureMessages: assertion.failureMessages ?? [],
+          ...meta.eval ? { eval: meta.eval } : {},
+          ...meta.harness ? { harness: meta.harness } : {}
+        });
+      }
+    }
+    runs.push({
+      id: runId,
+      ...source ? { source } : {},
+      status: report.success && runCases.every((testCase) => testCase.status !== "failed") ? "passed" : "failed",
+      startedAt: report.startTime,
+      durationMs: resolveRunDuration(report),
+      totals: {
+        total: report.numTotalTests,
+        passed: report.numPassedTests,
+        failed: report.numFailedTests,
+        skipped: report.numPendingTests + report.numTodoTests,
+        evalTotal: runCases.length,
+        evalPassed: runCases.filter((testCase) => testCase.status === "passed").length,
+        evalFailed: runCases.filter((testCase) => testCase.status === "failed").length
+      }
+    });
+    cases.push(...runCases);
+  });
+  return {
+    schemaVersion: REPORT_WORKSPACE_SCHEMA_VERSION,
+    runs,
+    cases
+  };
+}
+function normalizeWorkspaceInput(input) {
+  if (isVitestJsonReportLike(input)) {
+    return {
+      report: parseVitestJsonReport(input)
+    };
+  }
+  if (isRecord(input) && "report" in input) {
+    return {
+      report: parseVitestJsonReport(input.report),
+      source: typeof input.source === "string" ? input.source : void 0
+    };
+  }
+  return {
+    report: parseVitestJsonReport(input)
+  };
+}
+function isVitestJsonReportLike(input) {
+  return isRecord(input) && Array.isArray(input.testResults);
+}
+function createCaseId(runId, file, assertion) {
+  return [runId, file, assertion.location?.line ?? 0, assertion.fullName].join(
+    ":"
+  );
+}
+function formatDisplayName(assertion) {
+  return [...assertion.ancestorTitles, assertion.title].filter((part) => part.length > 0).join(" > ");
+}
+function resolveRunDuration(report) {
+  const intervals = report.testResults.map((file) => {
+    const start = file.startTime;
+    const end = file.endTime;
+    if (!isFiniteNumber(start) || !isFiniteNumber(end) || end < start) {
+      return void 0;
+    }
+    return {
+      start,
+      end
+    };
+  }).filter(
+    (interval) => Boolean(interval)
+  );
+  if (intervals.length === 0) {
+    return void 0;
+  }
+  return Math.max(...intervals.map((interval) => interval.end)) - Math.min(...intervals.map((interval) => interval.start));
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function normalizeReportPath(path, workspace) {
+  const normalized = path.replace(/\\/g, "/");
+  if (!workspace) {
+    return normalized;
+  }
+  const workspacePath = workspace.replace(/\\/g, "/").replace(/\/+$/, "");
+  if (normalized !== workspacePath && !normalized.startsWith(`${workspacePath}/`)) {
+    return normalized;
+  }
+  return normalized.slice(workspacePath.length).replace(/^\/+/, "");
+}
+
+// src/node.ts
+var GLOB_META_PATTERN = /[*?]/;
+var DEFAULT_REPORT_EXTENSIONS = [".json"];
+async function resolveReportFiles(patterns, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const extensions = normalizeExtensions(
+    options.extensions ?? DEFAULT_REPORT_EXTENSIONS
+  );
+  const files = [];
+  for (const pattern of patterns.map((entry) => entry.trim()).filter(Boolean)) {
+    if (hasGlob(pattern)) {
+      files.push(...await expandGlob(pattern, cwd));
+      continue;
+    }
+    const candidate = (0, import_node_path.isAbsolute)(pattern) ? pattern : (0, import_node_path.resolve)(cwd, pattern);
+    const candidateStat = await readStat(candidate);
+    if (candidateStat?.isDirectory()) {
+      files.push(...await listReportFiles(candidate, extensions));
+      continue;
+    }
+    files.push(candidate);
+  }
+  return [...new Set(files)].sort();
+}
+var resolveResultFiles = resolveReportFiles;
+function splitReportInput(value) {
+  return (value ?? "").split(/\r?\n/).map((entry) => entry.trim()).filter(Boolean);
+}
+var splitResultsInput = splitReportInput;
+async function readVitestJsonReportFile(resultFile) {
+  try {
+    return parseVitestJsonReport(
+      JSON.parse(await (0, import_promises.readFile)(resultFile, "utf8"))
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to read eval result file ${resultFile}: ${message}`
+    );
+  }
+}
+async function readReportWorkspace(patterns, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const resultFiles = await resolveReportFiles(patterns, { ...options, cwd });
+  if (resultFiles.length === 0) {
+    throw new Error(`No eval result files matched: ${patterns.join(", ")}`);
+  }
+  const reports = await Promise.all(
+    resultFiles.map(async (resultFile) => ({
+      report: await readVitestJsonReportFile(resultFile),
+      source: displayReportSource(resultFile, cwd)
+    }))
+  );
+  return {
+    resultFiles,
+    workspace: collectReportWorkspace(reports, {
+      workspace: options.workspace
+    })
+  };
+}
+function displayReportSource(resultFile, cwd) {
+  const relativeSource = normalizePath((0, import_node_path.relative)((0, import_node_path.resolve)(cwd), resultFile));
+  if (relativeSource === "" || relativeSource === "." || relativeSource.startsWith("../")) {
+    return resultFile;
+  }
+  return relativeSource;
+}
+function hasGlob(pattern) {
+  return GLOB_META_PATTERN.test(pattern);
+}
+async function expandGlob(pattern, cwd) {
+  const normalizedPattern = normalizeGlobPattern(pattern);
+  const absolutePattern = (0, import_node_path.isAbsolute)(pattern);
+  const base = globBase(normalizedPattern);
+  const basePath = absolutePattern ? base || import_node_path.sep : (0, import_node_path.resolve)(cwd, base || ".");
+  const regex = globToRegExp(normalizedPattern);
+  const matches = [];
+  for (const file of await listFiles(basePath)) {
+    const normalizedFile = normalizePath(file);
+    const candidate = absolutePattern ? normalizedFile : normalizePath((0, import_node_path.relative)((0, import_node_path.resolve)(cwd), file));
+    if (regex.test(candidate)) {
+      matches.push(file);
+    }
+  }
+  return matches;
+}
+function globBase(pattern) {
+  const segments = pattern.split("/");
+  const baseSegments = [];
+  for (const segment of segments) {
+    if (hasGlob(segment)) {
+      break;
+    }
+    baseSegments.push(segment);
+  }
+  return baseSegments.join("/");
+}
+async function listReportFiles(directory, extensions) {
+  const files = await listFiles(directory);
+  return files.filter((file) => extensions.has((0, import_node_path.extname)(file).toLowerCase()));
+}
+async function listFiles(directory) {
+  const entries = await readDirectory(directory);
+  if (!entries) {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const child = (0, import_node_path.resolve)(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFiles(child));
+    } else if (entry.isFile()) {
+      files.push(child);
+    }
+  }
+  return files;
+}
+async function readDirectory(directory) {
+  try {
+    return await (0, import_promises.readdir)(directory, { withFileTypes: true });
+  } catch {
+    return void 0;
+  }
+}
+async function readStat(path) {
+  try {
+    return await (0, import_promises.stat)(path);
+  } catch {
+    return void 0;
+  }
+}
+function globToRegExp(pattern) {
+  let source = "";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    const next = pattern[index + 1];
+    if (char === "*" && next === "*") {
+      const following = pattern[index + 2];
+      if (following === "/") {
+        source += "(?:.*/)?";
+        index += 2;
+      } else {
+        source += ".*";
+        index += 1;
+      }
+      continue;
+    }
+    if (char === "*") {
+      source += "[^/]*";
+      continue;
+    }
+    if (char === "?") {
+      source += "[^/]";
+      continue;
+    }
+    source += escapeRegExp(char ?? "");
+  }
+  return new RegExp(`^${source}$`);
+}
+function escapeRegExp(value) {
+  return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function normalizePath(path) {
+  return path.replace(/\\/g, "/");
+}
+function normalizeGlobPattern(pattern) {
+  const normalizedPattern = normalizePath(pattern);
+  if ((0, import_node_path.isAbsolute)(pattern)) {
+    return normalizedPattern;
+  }
+  return normalizedPattern.replace(/^(\.\/)+/, "");
+}
+function normalizeExtensions(extensions) {
+  return new Set(
+    extensions.map(
+      (extension) => extension.startsWith(".") ? extension.toLowerCase() : `.${extension.toLowerCase()}`
+    )
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readReportWorkspace,
+  readVitestJsonReportFile,
+  resolveReportFiles,
+  resolveResultFiles,
+  splitReportInput,
+  splitResultsInput
+});
+//# sourceMappingURL=node.js.map