agentv 4.17.1 → 4.18.0-next.1

package/dist/chunk-HBDOJJFY.js

@@ -0,0 +1,689 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  DEFAULT_THRESHOLD,
+  toTranscriptJsonLines
+} from "./chunk-RCOAXXHP.js";
+
+// src/commands/eval/artifact-writer.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path2 from "node:path";
+
+// src/utils/case-conversion.ts
+function toSnakeCase(str) {
+  if (/^[A-Z]/.test(str)) {
+    return str;
+  }
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function toSnakeCaseDeep(obj) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => toSnakeCaseDeep(item));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const snakeKey = toSnakeCase(key);
+      result[snakeKey] = toSnakeCaseDeep(value);
+    }
+    return result;
+  }
+  return obj;
+}
+
+// src/commands/eval/result-layout.ts
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+var RESULT_INDEX_FILENAME = "index.jsonl";
+var RESULT_RUNS_DIRNAME = "runs";
+var DEFAULT_EXPERIMENT_NAME = "default";
+function normalizeExperimentName(experiment) {
+  const trimmed = experiment?.trim();
+  if (!trimmed) {
+    return DEFAULT_EXPERIMENT_NAME;
+  }
+  if (!/^[A-Za-z0-9._-]+$/.test(trimmed)) {
+    throw new Error(
+      `Invalid experiment name "${trimmed}". Use only letters, numbers, ".", "_" and "-".`
+    );
+  }
+  return trimmed;
+}
+function createRunDirName(timestamp = /* @__PURE__ */ new Date()) {
+  return timestamp.toISOString().replace(/[:.]/g, "-");
+}
+function buildDefaultRunDir(cwd, experiment, timestamp = /* @__PURE__ */ new Date()) {
+  return path.join(
+    cwd,
+    ".agentv",
+    "results",
+    RESULT_RUNS_DIRNAME,
+    normalizeExperimentName(experiment),
+    createRunDirName(timestamp)
+  );
+}
+function resolveRunIndexPath(runDir) {
+  return path.join(runDir, RESULT_INDEX_FILENAME);
+}
+function isRunManifestPath(filePath) {
+  return path.basename(filePath) === RESULT_INDEX_FILENAME;
+}
+function resolveExistingRunPrimaryPath(runDir) {
+  const indexPath = resolveRunIndexPath(runDir);
+  if (existsSync(indexPath)) {
+    return indexPath;
+  }
+  return void 0;
+}
+function isDirectoryPath(filePath) {
+  try {
+    return statSync(filePath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function resolveWorkspaceOrFilePath(filePath) {
+  if (!isDirectoryPath(filePath)) {
+    return filePath;
+  }
+  const existing = resolveExistingRunPrimaryPath(filePath);
+  if (!existing) {
+    throw new Error(`Result workspace is missing ${RESULT_INDEX_FILENAME}: ${filePath}`);
+  }
+  return existing;
+}
+function resolveRunManifestPath(filePath) {
+  if (isDirectoryPath(filePath)) {
+    return resolveWorkspaceOrFilePath(filePath);
+  }
+  if (!isRunManifestPath(filePath)) {
+    throw new Error(
+      `Expected a run workspace directory or ${RESULT_INDEX_FILENAME} manifest: ${filePath}`
+    );
+  }
+  return filePath;
+}
+
+// src/commands/eval/artifact-writer.ts
+function buildTestTargetKey(testId, target) {
+  return `${testId ?? "unknown"}::${target ?? "unknown"}`;
+}
+function deduplicateByTestIdTarget(results) {
+  const seen = /* @__PURE__ */ new Map();
+  for (let i = 0; i < results.length; i++) {
+    seen.set(buildTestTargetKey(results[i].testId, results[i].target), i);
+  }
+  const deduped = [];
+  for (let i = 0; i < results.length; i++) {
+    const key = buildTestTargetKey(results[i].testId, results[i].target);
+    if (seen.get(key) === i) {
+      deduped.push(results[i]);
+    }
+  }
+  return deduped;
+}
+async function aggregateRunDir(runDir, options) {
+  const indexPath = path2.join(runDir, RESULT_INDEX_FILENAME);
+  const content = await readFile(indexPath, "utf8");
+  const allResults = parseJsonlResults(content);
+  const results = deduplicateByTestIdTarget(allResults);
+  const timing = buildTimingArtifact(results);
+  const timingPath = path2.join(runDir, "timing.json");
+  await writeFile(timingPath, `${JSON.stringify(timing, null, 2)}
+`, "utf8");
+  const benchmark = buildBenchmarkArtifact(results, options?.evalFile, options?.experiment);
+  const benchmarkPath = path2.join(runDir, "benchmark.json");
+  await writeFile(benchmarkPath, `${JSON.stringify(benchmark, null, 2)}
+`, "utf8");
+  const targetSet = new Set(results.map((r) => r.target ?? "unknown"));
+  return { benchmarkPath, timingPath, testCount: results.length, targetCount: targetSet.size };
+}
+function computeStats(values) {
+  if (values.length === 0) {
+    return { mean: 0, stddev: 0 };
+  }
+  const mean = values.reduce((sum, v) => sum + v, 0) / values.length;
+  const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length;
+  return {
+    mean: Math.round(mean * 1e3) / 1e3,
+    stddev: Math.round(Math.sqrt(variance) * 1e3) / 1e3
+  };
+}
+function computePassRate(result) {
+  const scores = result.scores;
+  if (scores && scores.length > 0) {
+    const passed = scores.filter((s) => s.score >= DEFAULT_THRESHOLD).length;
+    return passed / scores.length;
+  }
+  return (result.score ?? 0) >= DEFAULT_THRESHOLD ? 1 : 0;
+}
+function countToolCalls(result) {
+  const toolCalls = {};
+  let total = 0;
+  const trace = result.trace;
+  if (trace?.steps) {
+    for (const step of trace.steps) {
+      if (step.toolName || step.type === "tool") {
+        const name = step.toolName ?? "unknown";
+        toolCalls[name] = (toolCalls[name] ?? 0) + 1;
+        total += 1;
+      }
+    }
+  }
+  return { toolCalls, total };
+}
+function parseWorkspaceChanges(fileChanges) {
+  if (!fileChanges) {
+    return void 0;
+  }
+  let filesModified = 0;
+  let filesCreated = 0;
+  const lines = fileChanges.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("--- /dev/null")) {
+      filesCreated += 1;
+    } else if (line.startsWith("--- a/")) {
+      filesModified += 1;
+    }
+  }
+  const summaryLines = lines.slice(0, 20);
+  const diffSummary = lines.length > 20 ? `${summaryLines.join("\n")}
+... (${lines.length - 20} more lines)` : fileChanges;
+  return {
+    files_modified: filesModified,
+    files_created: filesCreated,
+    diff_summary: diffSummary
+  };
+}
+function buildAssertions(result) {
+  if (!result.assertions) return [];
+  return result.assertions.map((a) => ({
+    text: a.text,
+    passed: a.passed,
+    evidence: a.evidence ?? ""
+  }));
+}
+function buildEvaluators(scores) {
+  if (!scores || scores.length === 0) {
+    return void 0;
+  }
+  return scores.map((s) => ({
+    name: s.name,
+    type: s.type,
+    score: s.score,
+    reasoning: "",
+    weight: s.weight,
+    verdict: s.verdict,
+    assertions: s.assertions,
+    details: s.details
+  }));
+}
+function buildGradingArtifact(result) {
+  const assertions = buildAssertions(result);
+  const passed = assertions.filter((e) => e.passed).length;
+  const failed = assertions.filter((e) => !e.passed).length;
+  const total = assertions.length;
+  const { toolCalls, total: totalToolCalls } = countToolCalls(result);
+  const errorsEncountered = result.error ? 1 : 0;
+  return {
+    assertions,
+    summary: {
+      passed,
+      failed,
+      total,
+      pass_rate: total > 0 ? Math.round(passed / total * 1e3) / 1e3 : 0
+    },
+    execution_metrics: {
+      tool_calls: toolCalls,
+      total_tool_calls: totalToolCalls,
+      errors_encountered: errorsEncountered
+    },
+    graders: buildEvaluators(result.scores),
+    workspace_changes: parseWorkspaceChanges(result.fileChanges),
+    conversation: result.conversationId ? {
+      turns: result.trace ? result.trace.steps?.length ?? 0 : 0,
+      conversation_id: result.conversationId
+    } : void 0
+  };
+}
+function buildTimingArtifact(results) {
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalReasoning = 0;
+  let totalDurationMs = 0;
+  for (const result of results) {
+    const usage = result.tokenUsage;
+    if (usage) {
+      totalInput += usage.input ?? 0;
+      totalOutput += usage.output ?? 0;
+      totalReasoning += usage.reasoning ?? 0;
+    }
+    if (result.durationMs != null) {
+      totalDurationMs += result.durationMs;
+    }
+  }
+  return {
+    total_tokens: totalInput + totalOutput,
+    duration_ms: totalDurationMs,
+    total_duration_seconds: Math.round(totalDurationMs / 1e3 * 1e3) / 1e3,
+    token_usage: {
+      input: totalInput,
+      output: totalOutput,
+      reasoning: totalReasoning
+    }
+  };
+}
+function buildBenchmarkArtifact(results, evalFile = "", experiment) {
+  const targetSet = /* @__PURE__ */ new Set();
+  const testIdSet = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    targetSet.add(result.target ?? "unknown");
+    testIdSet.add(result.testId ?? "unknown");
+  }
+  const targets = [...targetSet].sort();
+  const testIds = [...testIdSet].sort();
+  const runSummary = {};
+  const notes = [];
+  for (const target of targets) {
+    const targetResults = results.filter((r) => r.target === target);
+    const passRates = targetResults.map(computePassRate);
+    const timings = targetResults.filter((r) => r.durationMs != null).map((r) => r.durationMs / 1e3);
+    const tokens = targetResults.filter((r) => r.tokenUsage != null).map((r) => {
+      const usage = r.tokenUsage;
+      return (usage.input ?? 0) + (usage.output ?? 0);
+    });
+    const entry = {
+      pass_rate: computeStats(passRates),
+      time_seconds: computeStats(timings),
+      tokens: computeStats(tokens)
+    };
+    const toolCallCounts = targetResults.map((r) => countToolCalls(r).total);
+    if (toolCallCounts.some((c) => c > 0)) {
+      entry.tool_calls = computeStats(toolCallCounts);
+    }
+    const costs = targetResults.filter((r) => r.costUsd != null).map((r) => r.costUsd);
+    if (costs.length > 0) {
+      entry.cost_usd = computeStats(costs);
+    }
+    runSummary[target] = entry;
+  }
+  const evaluatorScores = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    if (result.scores) {
+      for (const score of result.scores) {
+        const key = `${score.name}:${score.type}`;
+        if (!evaluatorScores.has(key)) {
+          evaluatorScores.set(key, []);
+        }
+        evaluatorScores.get(key)?.push(score.score);
+      }
+    }
+  }
+  let perEvaluatorSummary;
+  if (evaluatorScores.size > 0) {
+    perEvaluatorSummary = {};
+    for (const [key, scores] of evaluatorScores) {
+      perEvaluatorSummary[key] = computeStats(scores);
+    }
+  }
+  const errorCount = results.filter(
+    (r) => r.executionStatus != null && r.executionStatus === "execution_error"
+  ).length;
+  if (errorCount > 0) {
+    notes.push(
+      `${errorCount} test(s) had execution errors and are included in pass_rate as failures`
+    );
+  }
+  if (results.length === 0) {
+    notes.push("No results to summarize");
+  }
+  const firstResult = results[0];
+  const timestamp = firstResult?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    metadata: {
+      eval_file: evalFile,
+      timestamp,
+      targets,
+      tests_run: testIds,
+      experiment
+    },
+    run_summary: runSummary,
+    per_grader_summary: perEvaluatorSummary,
+    notes
+  };
+}
+function buildAggregateGradingArtifact(results) {
+  const assertions = [];
+  for (const result of results) {
+    if (!result.assertions) continue;
+    const testId = result.testId ?? "unknown";
+    for (const a of result.assertions) {
+      assertions.push({
+        test_id: testId,
+        text: a.text,
+        passed: a.passed,
+        evidence: a.evidence ?? ""
+      });
+    }
+  }
+  const passed = assertions.filter((a) => a.passed).length;
+  const failed = assertions.filter((a) => !a.passed).length;
+  const total = assertions.length;
+  return {
+    assertions,
+    summary: {
+      passed,
+      failed,
+      total,
+      pass_rate: total > 0 ? Math.round(passed / total * 1e3) / 1e3 : 0
+    }
+  };
+}
+function safeArtifactPathSegment(value, fallback) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return fallback;
+  }
+  return trimmed.replace(/[/\\:*?"<>|]/g, "_");
+}
+function safeTestId(testId) {
+  return safeArtifactPathSegment(testId, "unknown");
+}
+function getSuite(result) {
+  return result.suite;
+}
+function buildArtifactSubdir(result) {
+  const segments = [];
+  const evalSet = getSuite(result);
+  if (evalSet) {
+    segments.push(safeArtifactPathSegment(evalSet, "default"));
+  }
+  segments.push(safeTestId(result.testId));
+  return path2.posix.join(...segments);
+}
+function formatOutputMarkdown(output) {
+  return output.map((msg) => `@[${msg.role}]:
+${String(msg.content ?? "")}`).join("\n\n");
+}
+function extractInput(result) {
+  const input = result.input;
+  if (!input) return null;
+  if (typeof input === "string") return input;
+  if (Array.isArray(input) && input.length > 0) {
+    return formatOutputMarkdown(input);
+  }
+  return null;
+}
+function toRelativeArtifactPath(outputDir, filePath) {
+  return path2.relative(outputDir, filePath).split(path2.sep).join("/");
+}
+function buildIndexArtifactEntry(result, options) {
+  return {
+    timestamp: result.timestamp,
+    test_id: result.testId ?? "unknown",
+    suite: getSuite(result),
+    category: result.category,
+    conversation_id: result.conversationId,
+    score: result.score,
+    target: result.target ?? "unknown",
+    scores: result.scores ? toSnakeCaseDeep(result.scores) : void 0,
+    execution_status: result.executionStatus,
+    error: result.error,
+    failure_stage: result.failureStage,
+    failure_reason_code: result.failureReasonCode,
+    workspace_path: result.workspacePath,
+    grading_path: toRelativeArtifactPath(options.outputDir, options.gradingPath),
+    timing_path: toRelativeArtifactPath(options.outputDir, options.timingPath),
+    output_path: options.outputPath ? toRelativeArtifactPath(options.outputDir, options.outputPath) : void 0,
+    input_path: options.inputPath ? toRelativeArtifactPath(options.outputDir, options.inputPath) : void 0
+  };
+}
+function buildResultIndexArtifact(result) {
+  const artifactSubdir = buildArtifactSubdir(result);
+  const input = extractInput(result);
+  const hasResponse = Array.isArray(result.output) && result.output.length > 0;
+  return {
+    timestamp: result.timestamp,
+    test_id: result.testId ?? "unknown",
+    suite: getSuite(result),
+    category: result.category,
+    conversation_id: result.conversationId,
+    score: result.score,
+    target: result.target ?? "unknown",
+    scores: result.scores ? toSnakeCaseDeep(result.scores) : void 0,
+    execution_status: result.executionStatus,
+    error: result.error,
+    failure_stage: result.failureStage,
+    failure_reason_code: result.failureReasonCode,
+    workspace_path: result.workspacePath,
+    grading_path: path2.posix.join(artifactSubdir, "grading.json"),
+    timing_path: path2.posix.join(artifactSubdir, "timing.json"),
+    input_path: input ? path2.posix.join(artifactSubdir, "input.md") : void 0,
+    output_path: hasResponse ? path2.posix.join(artifactSubdir, "outputs", "response.md") : void 0,
+    response_path: hasResponse ? path2.posix.join(artifactSubdir, "outputs", "response.md") : void 0
+  };
+}
+async function writeJsonlFile(filePath, records) {
+  const content = records.length === 0 ? "" : `${records.map((record) => JSON.stringify(toSnakeCaseDeep(record))).join("\n")}
+`;
+  await writeFile(filePath, content, "utf8");
+}
+function toCamelCase(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function toCamelCaseDeep(obj) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => toCamelCaseDeep(item));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[toCamelCase(key)] = toCamelCaseDeep(value);
+    }
+    return result;
+  }
+  return obj;
+}
+var EXECUTION_STATUSES = /* @__PURE__ */ new Set([
+  "ok",
+  "quality_failure",
+  "execution_error"
+]);
+function isAssertionEntry(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.text === "string" && typeof candidate.passed === "boolean" && (candidate.evidence === void 0 || typeof candidate.evidence === "string");
+}
+function isOutputMessage(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.role === "string";
+}
+function isExecutionStatus(value) {
+  return typeof value === "string" && EXECUTION_STATUSES.has(value);
+}
+function normalizeParsedResult(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const result = value;
+  return {
+    ...result,
+    timestamp: typeof result.timestamp === "string" ? result.timestamp : (/* @__PURE__ */ new Date(0)).toISOString(),
+    testId: typeof result.testId === "string" ? result.testId : "unknown",
+    score: typeof result.score === "number" ? result.score : 0,
+    assertions: Array.isArray(result.assertions) ? result.assertions.filter(isAssertionEntry) : [],
+    target: typeof result.target === "string" ? result.target : "unknown",
+    output: Array.isArray(result.output) ? result.output.filter(isOutputMessage) : [],
+    executionStatus: isExecutionStatus(result.executionStatus) ? result.executionStatus : "ok"
+  };
+}
+function parseJsonlResults(content) {
+  const results = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      const camelCased = toCamelCaseDeep(parsed);
+      const normalized = normalizeParsedResult(camelCased);
+      if (normalized) {
+        results.push(normalized);
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+async function writeArtifacts(jsonlPath, outputDir, options) {
+  const content = await readFile(jsonlPath, "utf8");
+  const results = parseJsonlResults(content);
+  return writeArtifactsFromResults(results, outputDir, options);
+}
+function buildTranscriptMessageLines(results) {
+  const lines = [];
+  for (const result of results) {
+    const transcriptLines = toTranscriptJsonLines(
+      {
+        messages: [...result.input ?? [], ...result.output],
+        source: {
+          provider: result.target,
+          sessionId: result.conversationId ?? result.testId,
+          startedAt: result.timestamp
+        },
+        tokenUsage: result.tokenUsage,
+        durationMs: result.durationMs,
+        costUsd: result.costUsd
+      },
+      {
+        testId: result.testId,
+        target: result.target
+      }
+    );
+    lines.push(...transcriptLines.map((line) => JSON.stringify(line)));
+  }
+  return lines.length > 0 ? `${lines.join("\n")}
+` : "";
+}
+async function writePerTestArtifacts(results, outputDir, options) {
+  await mkdir(outputDir, { recursive: true });
+  for (const result of results) {
+    const grading = buildGradingArtifact(result);
+    const timing = buildTimingArtifact([result]);
+    const artifactSubdir = buildArtifactSubdir(result);
+    const testDir = path2.join(outputDir, artifactSubdir);
+    await mkdir(testDir, { recursive: true });
+    await writeFile(
+      path2.join(testDir, "grading.json"),
+      `${JSON.stringify(grading, null, 2)}
+`,
+      "utf8"
+    );
+    await writeFile(
+      path2.join(testDir, "timing.json"),
+      `${JSON.stringify(timing, null, 2)}
+`,
+      "utf8"
+    );
+    const input = extractInput(result);
+    if (input) {
+      await writeFile(path2.join(testDir, "input.md"), input, "utf8");
+    }
+    if (result.output && result.output.length > 0) {
+      const outputsDir = path2.join(testDir, "outputs");
+      await mkdir(outputsDir, { recursive: true });
+      await writeFile(
+        path2.join(outputsDir, "response.md"),
+        formatOutputMarkdown(result.output),
+        "utf8"
+      );
+    }
+  }
+}
+async function writeArtifactsFromResults(results, outputDir, options) {
+  const testArtifactDir = outputDir;
+  const timingPath = path2.join(outputDir, "timing.json");
+  const benchmarkPath = path2.join(outputDir, "benchmark.json");
+  const indexPath = path2.join(outputDir, RESULT_INDEX_FILENAME);
+  await mkdir(outputDir, { recursive: true });
+  const indexRecords = [];
+  for (const result of results) {
+    const grading = buildGradingArtifact(result);
+    const timing2 = buildTimingArtifact([result]);
+    const artifactSubdir = buildArtifactSubdir(result);
+    const testDir = path2.join(outputDir, artifactSubdir);
+    const gradingPath = path2.join(testDir, "grading.json");
+    const perTestTimingPath = path2.join(testDir, "timing.json");
+    await mkdir(testDir, { recursive: true });
+    await writeFile(gradingPath, `${JSON.stringify(grading, null, 2)}
+`, "utf8");
+    await writeFile(perTestTimingPath, `${JSON.stringify(timing2, null, 2)}
+`, "utf8");
+    const input = extractInput(result);
+    if (input) {
+      await writeFile(path2.join(testDir, "input.md"), input, "utf8");
+    }
+    if (result.output && result.output.length > 0) {
+      const outputsDir = path2.join(testDir, "outputs");
+      await mkdir(outputsDir, { recursive: true });
+      await writeFile(
+        path2.join(outputsDir, "response.md"),
+        formatOutputMarkdown(result.output),
+        "utf8"
+      );
+    }
+    indexRecords.push({
+      ...buildResultIndexArtifact(result),
+      experiment: options?.experiment
+    });
+  }
+  const timing = buildTimingArtifact(results);
+  await writeFile(timingPath, `${JSON.stringify(timing, null, 2)}
+`, "utf8");
+  const benchmark = buildBenchmarkArtifact(results, options?.evalFile, options?.experiment);
+  await writeFile(benchmarkPath, `${JSON.stringify(benchmark, null, 2)}
+`, "utf8");
+  await writeJsonlFile(indexPath, indexRecords);
+  const transcriptPath = path2.join(outputDir, "transcript.jsonl");
+  await writeFile(transcriptPath, buildTranscriptMessageLines(results), "utf8");
+  return { testArtifactDir, timingPath, benchmarkPath, indexPath };
+}
+
+export {
+  toSnakeCaseDeep,
+  RESULT_INDEX_FILENAME,
+  RESULT_RUNS_DIRNAME,
+  normalizeExperimentName,
+  buildDefaultRunDir,
+  resolveRunIndexPath,
+  resolveExistingRunPrimaryPath,
+  isDirectoryPath,
+  resolveWorkspaceOrFilePath,
+  resolveRunManifestPath,
+  buildTestTargetKey,
+  deduplicateByTestIdTarget,
+  aggregateRunDir,
+  buildGradingArtifact,
+  buildTimingArtifact,
+  buildBenchmarkArtifact,
+  buildAggregateGradingArtifact,
+  buildIndexArtifactEntry,
+  buildResultIndexArtifact,
+  parseJsonlResults,
+  writeArtifacts,
+  writePerTestArtifacts,
+  writeArtifactsFromResults
+};
+//# sourceMappingURL=chunk-HBDOJJFY.js.map