promptfoo 0.125.0 → 0.125.1

package/dist/src/util-BD1R_PsR.js

@@ -1,1770 +0,0 @@
-#!/usr/bin/env node
-import { E as sanitizeUrl, F as isApiProvider, I as isProviderOptions, K as refreshConfigDirectoryPathFromEnv, S as sanitizeConfigForOutput, W as loadYaml, c as logger, ct as loadEnvFiles, w as sanitizeRuntimeOptions } from "./logger-pCNnmVuz.js";
-import { a as getStripFlags, i as getResultIndexKey, l as projectTracesForOutput, r as asEvaluateResult, u as sanitizeResultForJsonlArtifact } from "./evalResult-CzjCb5bd.js";
-import { U as TERMINAL_MAX_WIDTH, Y as VERSION, r as fetchWithProxy } from "./fetch-BhfUnKen.js";
-import { t as invariant } from "./invariant-CbHB1xyx.js";
-import { C as OutputFileExtension, O as ResultFailureReason } from "./tables-BONxKPrt.js";
-import { r as getDirectory } from "./esm-B4NX_h4K.js";
-import { i as maybeLoadConfigFromExternalFile } from "./file-DnhgJopr.js";
-import { o as getNunjucksEngine } from "./render-DdqOpT1Z.js";
-import { n as sha256 } from "./createHash-DqA6GWxE.js";
-import "./blobs-BKHs1MZ-.js";
-import { o as collectBlobHashes } from "./extractor-CW3spiLZ.js";
-import { t as isMissingPackageImportError } from "./packageImportErrors-B9NSwzz-.js";
-import fs, * as fs$2 from "fs";
-import path, * as path$1 from "path";
-import * as os$1 from "os";
-import * as yaml from "js-yaml";
-import deepEqual from "fast-deep-equal";
-import dedent from "dedent";
-import * as fsPromises from "fs/promises";
-import { randomUUID } from "crypto";
-import { XMLBuilder } from "fast-xml-parser";
-import { stringify } from "csv-stringify/sync";
-//#region src/util/providerRef.ts
-const PROVIDER_OPTION_KEYS = /* @__PURE__ */ new Set([
-	"id",
-	"label",
-	"config",
-	"prompts",
-	"transform",
-	"delay",
-	"env",
-	"inputs"
-]);
-/** Returns true if the value is a non-empty string suitable as a provider identifier. */
-function isValidProviderId(id) {
-	return typeof id === "string" && id !== "";
-}
-function getProviderLabel(provider) {
-	if ((typeof provider === "object" || typeof provider === "function") && provider !== null && "label" in provider && typeof provider.label === "string") return provider.label;
-}
-/**
-* Resolves relative file paths in provider IDs to absolute paths for consistent matching.
-* Handles file://, exec:, python:, golang: prefixes and bare .js/.ts/.mjs paths.
-*/
-function canonicalizeProviderId(id) {
-	if (id.startsWith("file://")) {
-		const filePath = id.slice(7);
-		return path.isAbsolute(filePath) ? id : `file://${path.resolve(filePath)}`;
-	}
-	for (const prefix of [
-		"exec:",
-		"python:",
-		"golang:"
-	]) if (id.startsWith(prefix)) {
-		const filePath = id.slice(prefix.length);
-		if (filePath.includes("/") || filePath.includes("\\")) return `${prefix}${path.resolve(filePath)}`;
-		return id;
-	}
-	if ((id.endsWith(".js") || id.endsWith(".ts") || id.endsWith(".mjs")) && (id.includes("/") || id.includes("\\"))) return `file://${path.resolve(id)}`;
-	return id;
-}
-/**
-* Returns true for provider refs that should be expanded from YAML/JSON config files.
-*/
-function isProviderConfigFileReference(providerPath) {
-	return providerPath.startsWith("file://") && (providerPath.endsWith(".yaml") || providerPath.endsWith(".yml") || providerPath.endsWith(".json"));
-}
-/**
-* Reads a provider config file and normalizes single-provider and multi-provider files.
-* An explicit base path also scopes nested configuration files; otherwise their
-* caller scope is retained.
-* Returns a `wasArray` flag so callers can detect multi-provider files that require
-* `loadApiProviders` instead of `loadApiProvider`.
-*/
-function readProviderConfigFile(providerPath, basePath) {
-	const relativePath = providerPath.slice(7);
-	const resolvedPath = path.isAbsolute(relativePath) ? relativePath : path.join(basePath || process.cwd(), relativePath);
-	let rawContent;
-	try {
-		rawContent = loadYaml(fs.readFileSync(resolvedPath, "utf8"));
-	} catch (err) {
-		throw new Error(`Failed to load provider config ${relativePath}: ${err instanceof Error ? err.message : err}`);
-	}
-	const fileContent = maybeLoadConfigFromExternalFile(rawContent, void 0, basePath);
-	invariant(fileContent, `Provider config ${relativePath} is undefined`);
-	return {
-		configs: [fileContent].flat(),
-		relativePath,
-		wasArray: Array.isArray(fileContent)
-	};
-}
-/**
-* Loads provider config objects from a file-backed provider reference.
-*/
-function loadProviderConfigsFromFile(providerPath, basePath) {
-	return readProviderConfigFile(providerPath, basePath).configs;
-}
-/**
-* Pure, synchronous classifier that converts every supported provider reference shape
-* into a discriminated descriptor. Does not read files or instantiate providers.
-*/
-function normalizeProviderRef(provider, options = {}) {
-	const { index } = options;
-	if (typeof provider === "string") {
-		if (!isValidProviderId(provider)) return {
-			kind: "unknown",
-			id: index === void 0 ? "unknown" : `unknown-${index}`
-		};
-		if (isProviderConfigFileReference(provider)) return {
-			kind: "file",
-			id: provider,
-			loadProviderPath: provider
-		};
-		return {
-			kind: "named",
-			id: provider,
-			loadProviderPath: provider
-		};
-	}
-	if (typeof provider === "function") {
-		const label = getProviderLabel(provider);
-		return {
-			kind: "function",
-			id: label ?? (index === void 0 ? "custom-function" : `custom-function-${index}`),
-			label
-		};
-	}
-	if (typeof provider === "object" && provider !== null && !Array.isArray(provider)) {
-		const providerId = provider.id;
-		const label = getProviderLabel(provider);
-		if (isValidProviderId(providerId)) return {
-			kind: "options",
-			id: providerId,
-			label,
-			loadOptions: provider,
-			loadProviderPath: providerId
-		};
-		const keys = Object.keys(provider);
-		if (keys.length === 1 && !PROVIDER_OPTION_KEYS.has(keys[0])) {
-			const originalId = keys[0];
-			const providerObject = provider[originalId];
-			if (typeof providerObject === "object" && providerObject !== null && !Array.isArray(providerObject) && isValidProviderId(originalId)) {
-				const id = isValidProviderId(providerObject.id) ? providerObject.id : originalId;
-				return {
-					kind: "map",
-					id,
-					label: getProviderLabel(providerObject),
-					loadOptions: {
-						...providerObject,
-						id
-					},
-					loadProviderPath: originalId
-				};
-			}
-		}
-		if (isValidProviderId(label)) return {
-			kind: "unknown",
-			id: label,
-			label
-		};
-	}
-	return {
-		kind: "unknown",
-		id: index === void 0 ? "unknown" : `unknown-${index}`
-	};
-}
-//#endregion
-//#region src/util/provider.ts
-function providerToIdentifier(provider) {
-	if (!provider) return;
-	if (typeof provider === "string") return canonicalizeProviderId(provider);
-	const { label } = normalizeProviderRef(provider);
-	if (label) return label;
-	if (isApiProvider(provider)) return canonicalizeProviderId(provider.id());
-	if (isProviderOptions(provider)) {
-		if (provider.id) return canonicalizeProviderId(provider.id);
-		return;
-	}
-	if (typeof provider === "object" && "id" in provider && typeof provider.id === "string") return canonicalizeProviderId(provider.id);
-}
-/**
-* Gets the identifier string for a provider (label or id).
-*/
-function getProviderIdentifier(provider) {
-	return provider.label || provider.id();
-}
-/**
-* Gets a descriptive identifier string for a provider, showing both label and ID when both exist.
-* Useful for error messages to help users debug provider reference issues.
-*/
-function getProviderDescription(provider) {
-	const label = provider.label;
-	const id = provider.id();
-	if (label && label !== id) return `${label} (${id})`;
-	return id;
-}
-function sanitizeProviderIdForLog(providerId) {
-	const descriptionMatch = providerId.match(/^(\S+)(\s+\(.+\))$/);
-	if (descriptionMatch) {
-		const [, id, description] = descriptionMatch;
-		return `${sanitizeProviderIdForLog(id)}${description}`;
-	}
-	return providerId.includes("://") || providerId.startsWith("/") ? sanitizeUrl(providerId) : providerId;
-}
-/**
-* Checks if a provider reference matches a given provider.
-* Supports exact matching and wildcard patterns.
-*/
-function doesProviderRefMatch(ref, provider) {
-	const label = provider.label;
-	const id = provider.id();
-	const canonicalRef = canonicalizeProviderId(ref);
-	const canonicalId = canonicalizeProviderId(id);
-	if (label && label === ref) return true;
-	if (id === ref || canonicalId === canonicalRef) return true;
-	if (ref.endsWith("*")) {
-		const prefix = ref.slice(0, -1);
-		if (label?.startsWith(prefix) || id.startsWith(prefix) || canonicalId.startsWith(prefix)) return true;
-	}
-	if (label?.startsWith(`${ref}:`) || id.startsWith(`${ref}:`) || canonicalId.startsWith(`${ref}:`)) return true;
-	return false;
-}
-/**
-* Checks if a provider is allowed based on a list of allowed references.
-*/
-function isProviderAllowed(provider, allowedProviders) {
-	if (!Array.isArray(allowedProviders)) return true;
-	if (allowedProviders.length === 0) return false;
-	return allowedProviders.some((ref) => doesProviderRefMatch(ref, provider));
-}
-/**
-* Detects if a provider uses OpenAI models.
-* This includes direct OpenAI providers and Azure OpenAI.
-*/
-function isOpenAiProvider(providerId) {
-	const lowerProviderId = providerId.toLowerCase();
-	if (lowerProviderId.startsWith("openai:")) return true;
-	if (lowerProviderId.startsWith("azureopenai:")) return true;
-	if (lowerProviderId.startsWith("azure:")) {
-		if ([
-			"gpt",
-			"openai",
-			"davinci",
-			"curie",
-			"babbage",
-			"ada",
-			"text-embedding",
-			"whisper",
-			"dall-e",
-			"tts"
-		].some((indicator) => lowerProviderId.includes(indicator))) return true;
-	}
-	return false;
-}
-/**
-* Detects if a provider uses Anthropic/Claude models.
-* This includes direct Anthropic providers, Bedrock with Claude, and Vertex with Claude.
-*/
-function isAnthropicProvider(providerId) {
-	const lowerProviderId = providerId.toLowerCase();
-	if (lowerProviderId.startsWith("anthropic:")) return true;
-	if (lowerProviderId.startsWith("bedrock:")) {
-		if (lowerProviderId.includes("claude") || lowerProviderId.includes("anthropic")) return true;
-	}
-	if (lowerProviderId.startsWith("vertex:")) {
-		if (lowerProviderId.includes("claude")) return true;
-	}
-	return false;
-}
-const KNOWN_ENV_VARS = {
-	openai: "OPENAI_API_KEY",
-	anthropic: "ANTHROPIC_API_KEY",
-	google: "GOOGLE_API_KEY",
-	mistral: "MISTRAL_API_KEY",
-	cohere: "COHERE_API_KEY",
-	replicate: "REPLICATE_API_TOKEN",
-	voyage: "VOYAGE_API_KEY",
-	ai21: "AI21_API_KEY",
-	xai: "XAI_API_KEY",
-	groq: "GROQ_API_KEY",
-	deepseek: "DEEPSEEK_API_KEY",
-	meta: "MODEL_API_KEY",
-	moonshot: "MOONSHOT_API_KEY",
-	perplexity: "PERPLEXITY_API_KEY",
-	hyperbolic: "HYPERBOLIC_API_KEY",
-	cerebras: "CEREBRAS_API_KEY",
-	togetherai: "TOGETHER_API_KEY",
-	fal: "FAL_KEY",
-	huggingface: "HF_TOKEN",
-	"cloudflare-ai": "CLOUDFLARE_API_KEY"
-};
-function getDefaultEnvVar(providerId) {
-	const prefix = providerId.split(":")[0];
-	return KNOWN_ENV_VARS[prefix] || `${prefix.toUpperCase()}_API_KEY`;
-}
-/**
-* Pre-checks providers for missing API keys before evaluation starts.
-* Assumes getApiKey() is side-effect free (no network calls or token refresh).
-* Returns stable provider IDs by default; descriptions are for user-facing diagnostics only.
-*/
-function checkProviderApiKeys(providers, options = {}) {
-	const missingApiKeys = /* @__PURE__ */ new Map();
-	for (const provider of providers) {
-		const p = provider;
-		if (typeof p.getApiKey !== "function") continue;
-		if (provider.id().startsWith("azure:")) continue;
-		const requiresKey = typeof p.requiresApiKey === "function" ? p.requiresApiKey() : p.config?.apiKeyRequired !== false;
-		let apiKey;
-		try {
-			apiKey = p.getApiKey();
-		} catch {
-			apiKey = void 0;
-		}
-		if (requiresKey && !apiKey) {
-			const envVar = p.config?.apiKeyEnvar || getDefaultEnvVar(provider.id());
-			const providerIdentifier = options.useDescriptions ? getProviderDescription(provider) : provider.id();
-			if (!missingApiKeys.has(envVar)) missingApiKeys.set(envVar, []);
-			missingApiKeys.get(envVar).push(providerIdentifier);
-		}
-	}
-	return missingApiKeys;
-}
-/**
-* Detects if a provider uses Google models.
-* This includes direct Google/Vertex providers with Gemini and other Google models.
-* Note: Vertex with Claude models is NOT counted as Google (it's Anthropic).
-*/
-function isGoogleProvider(providerId) {
-	const lowerProviderId = providerId.toLowerCase();
-	if (lowerProviderId.startsWith("google:")) return true;
-	if (lowerProviderId.startsWith("vertex:")) {
-		if (!lowerProviderId.includes("claude")) return true;
-	}
-	return false;
-}
-//#endregion
-//#region src/util/comparison.ts
-/**
-* Explicit runtime variable names that don't follow the underscore convention.
-* These are added during evaluation but aren't part of the original test definition.
-*
-* - sessionId: Added by multi-turn strategy providers (GOAT, Crescendo)
-*
-* Note: Variables starting with underscore (e.g., _conversation) are automatically
-* treated as runtime variables and filtered out.
-*/
-const EXPLICIT_RUNTIME_VAR_KEYS = ["sessionId"];
-/**
-* Checks if a variable key is a runtime-only variable that should be filtered
-* when comparing test cases.
-*
-* Runtime variables are identified by:
-* 1. Starting with underscore (_) - convention for internal/runtime vars
-* 2. Being in the explicit runtime var list (for legacy vars like sessionId)
-*/
-function isRuntimeVar(key) {
-	return key.startsWith("_") || EXPLICIT_RUNTIME_VAR_KEYS.includes(key);
-}
-/**
-* Filters out runtime-only variables that are added during evaluation
-* but aren't part of the original test definition.
-*
-* This is used when comparing test cases to determine if a result
-* corresponds to a particular test, regardless of runtime state.
-*
-* Runtime variables are identified by:
-* - Starting with underscore (e.g., _conversation, _metadata)
-* - Being in the explicit list (e.g., sessionId for backward compatibility)
-*/
-function filterRuntimeVars(vars) {
-	if (!vars || typeof vars !== "object" || Array.isArray(vars)) return vars;
-	const filtered = {};
-	for (const [key, value] of Object.entries(vars)) if (!isRuntimeVar(key)) filtered[key] = value;
-	return filtered;
-}
-/**
-* Extracts only runtime variables from a vars object.
-* This is the inverse of filterRuntimeVars.
-*
-* Used to restore runtime state when re-running filtered tests.
-*/
-function extractRuntimeVars(vars) {
-	if (!vars || typeof vars !== "object" || Array.isArray(vars)) return;
-	const extracted = {};
-	for (const [key, value] of Object.entries(vars)) if (isRuntimeVar(key)) extracted[key] = value;
-	return Object.keys(extracted).length > 0 ? extracted : void 0;
-}
-function varsMatch(vars1, vars2) {
-	return deepEqual(vars1, vars2);
-}
-/**
-* Generate a unique key for a test case for deduplication purposes.
-* Excludes runtime variables and includes strategyId to distinguish tests
-* with the same prompt but different strategies.
-*
-* @param testCase - The test case to generate a key for
-* @returns A JSON string that uniquely identifies the test case
-*/
-function getTestCaseDeduplicationKey(testCase) {
-	const filteredVars = filterRuntimeVars(testCase.vars);
-	const strategyId = testCase.metadata?.strategyId || "none";
-	return JSON.stringify({
-		vars: filteredVars,
-		strategyId
-	});
-}
-/**
-* Deduplicates an array of test cases based on their vars and strategyId.
-* Tests with the same vars but different strategies are considered different.
-* Runtime variables (like _conversation, sessionId) are filtered out before comparison.
-*
-* @param tests - Array of test cases to deduplicate
-* @returns Deduplicated array of test cases
-*/
-function deduplicateTestCases(tests) {
-	const seen = /* @__PURE__ */ new Set();
-	return tests.filter((test) => {
-		const key = getTestCaseDeduplicationKey(test);
-		if (seen.has(key)) return false;
-		seen.add(key);
-		return true;
-	});
-}
-function resultIsForTestCase(result, testCase) {
-	const testProviderId = testCase.provider ? providerToIdentifier(testCase.provider) : void 0;
-	const resultProviderId = providerToIdentifier(result.provider);
-	const providersMatch = !testProviderId || !resultProviderId || testProviderId === resultProviderId;
-	const resultVars = filterRuntimeVars(result.vars);
-	const testVars = filterRuntimeVars(testCase.vars);
-	const doVarsMatch = varsMatch(testVars, resultVars);
-	const isMatch = doVarsMatch && providersMatch;
-	if (!isMatch) {
-		const varKeys = testVars ? Object.keys(testVars).join(", ") : "none";
-		logger.debug(`[resultIsForTestCase] No match: vars=${doVarsMatch}, providers=${providersMatch}`, {
-			testProvider: testProviderId || "none",
-			resultProvider: resultProviderId || "none",
-			testVarKeys: varKeys
-		});
-	}
-	return isMatch;
-}
-//#endregion
-//#region src/util/env.ts
-/**
-* Load environment variables from .env file(s).
-* @param envPath - Single path, array of paths, or undefined for default .env loading.
-*                  When paths are explicitly specified, all files must exist or an error is thrown.
-*                  When multiple files are provided, later files override values from earlier files.
-*/
-function setupEnv(envPath, options = {}) {
-	const paths = (Array.isArray(envPath) ? envPath : [envPath ?? ""]).flatMap((p) => p.split(",").map((s) => s.trim())).filter(Boolean);
-	if (paths.length > 0) {
-		for (const p of paths) if (!fs$2.existsSync(p)) throw new Error(`Environment file not found: ${p}`);
-		if (paths.length === 1) logger.info(`Loading environment variables from ${paths[0]}`);
-		else logger.info(`Loading environment variables from: ${paths.join(", ")}`);
-	}
-	const previousEnv = { ...options.processEnv };
-	loadEnvFiles(paths.length > 0 ? paths : void 0, {
-		...paths.length > 0 && { override: true },
-		...options.processEnv && { processEnv: options.processEnv }
-	});
-	if (options.processEnv && paths.length === 0) {
-		for (const key of Object.keys(options.processEnv)) if (!Object.prototype.hasOwnProperty.call(previousEnv, key) && process.env[key] !== void 0) delete options.processEnv[key];
-	}
-	if (options.refreshConfigDirectory) refreshConfigDirectoryPathFromEnv();
-}
-//#endregion
-//#region src/googleSheets.ts
-var GoogleSheetAuthenticationRequiredError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "GoogleSheetAuthenticationRequiredError";
-	}
-};
-async function loadGoogleSheetsApi() {
-	try {
-		return await import("@googleapis/sheets");
-	} catch (error) {
-		if (isMissingPackageImportError(error, "@googleapis/sheets")) throw new Error("The @googleapis/sheets package is required for authenticated Google Sheets access. Install it with: npm install @googleapis/sheets");
-		throw error;
-	}
-}
-async function checkGoogleSheetAccess(url) {
-	try {
-		const response = await fetchWithProxy(url);
-		if (response.ok) return {
-			public: true,
-			status: response.status
-		};
-		else return {
-			public: false,
-			status: response.status
-		};
-	} catch (error) {
-		logger.error(`Error checking sheet access: ${error}`);
-		return { public: false };
-	}
-}
-function isHtmlExportResponse(response, body) {
-	const contentType = response.headers?.get("content-type")?.toLowerCase() ?? "";
-	if (contentType.includes("text/html")) return true;
-	if (contentType.includes("text/csv") || contentType.includes("application/csv")) return false;
-	const prefix = body.trimStart().slice(0, 32).toLowerCase();
-	return prefix.startsWith("<!doctype html") || prefix.startsWith("<html");
-}
-/**
-* Returns the sheet id (`gid`) a Google Sheets URL selects. The browser keeps it in the fragment
-* (`/edit#gid=123`); newer URLs also repeat it in the query (`/edit?gid=123#gid=123`). It stays a
-* string so that sheet id 0 is still truthy.
-*/
-function getSheetGid(url) {
-	const { searchParams, hash } = new URL(url);
-	return searchParams.get("gid") || new URLSearchParams(hash.slice(1)).get("gid") || void 0;
-}
-async function fetchCsvFromGoogleSheetUnauthenticated(url) {
-	const { parse: parseCsv } = await import("csv-parse/sync");
-	const gid = getSheetGid(url);
-	const csvUrl = `${url.replace(/\/edit.*$/, "/export")}?format=csv${gid ? `&gid=${gid}` : ""}`;
-	const response = await fetchWithProxy(csvUrl);
-	if (response.status !== 200) throw new Error(`Failed to fetch CSV from Google Sheets URL: ${url}`);
-	const csvData = await response.text();
-	if (isHtmlExportResponse(response, csvData)) throw new GoogleSheetAuthenticationRequiredError(`Failed to fetch CSV from Google Sheets URL: ${url}`);
-	return parseCsv(csvData, { columns: true });
-}
-async function fetchCsvFromGoogleSheetAuthenticated(url) {
-	const { sheets: googleSheets, auth: googleAuth } = await loadGoogleSheetsApi();
-	const auth = new googleAuth.GoogleAuth({ scopes: ["https://www.googleapis.com/auth/spreadsheets.readonly"] });
-	const sheets = googleSheets("v4");
-	const match = url.match(/\/d\/([^/]+)/);
-	if (!match) throw new Error(`Invalid Google Sheets URL: ${url}`);
-	const spreadsheetId = match[1];
-	let range;
-	const gid = getSheetGid(url);
-	if (gid) {
-		const sheet = (await sheets.spreadsheets.get({
-			spreadsheetId,
-			auth
-		})).data.sheets?.find((sheet) => sheet.properties?.sheetId === Number(gid));
-		if (!sheet || !sheet.properties?.title) throw new Error(`Sheet not found for gid: ${gid}`);
-		range = sheet.properties.title;
-	} else {
-		const firstSheet = (await sheets.spreadsheets.get({
-			spreadsheetId,
-			auth
-		})).data.sheets?.[0];
-		if (!firstSheet || !firstSheet.properties?.title) throw new Error(`No sheets found in spreadsheet`);
-		range = firstSheet.properties.title;
-	}
-	const rows = (await sheets.spreadsheets.values.get({
-		spreadsheetId,
-		range,
-		auth
-	})).data.values;
-	if (!rows?.length) throw new Error(`No data found in Google Sheets URL: ${url}`);
-	const headers = rows[0];
-	return rows.slice(1).map((row) => {
-		const csvRow = {};
-		headers.forEach((header, index) => {
-			csvRow[header] = row[index] ?? "";
-		});
-		return csvRow;
-	});
-}
-async function fetchCsvFromGoogleSheet(url) {
-	const access = await checkGoogleSheetAccess(url);
-	const { public: isPublic } = access;
-	logger.debug(`Google Sheets URL: ${url}, isPublic: ${isPublic}`);
-	if (isPublic) try {
-		return await fetchCsvFromGoogleSheetUnauthenticated(url);
-	} catch (error) {
-		if (error instanceof GoogleSheetAuthenticationRequiredError) return fetchCsvFromGoogleSheetAuthenticated(url);
-		throw error;
-	}
-	if (!("status" in access)) try {
-		return await fetchCsvFromGoogleSheetUnauthenticated(url);
-	} catch {
-		return fetchCsvFromGoogleSheetAuthenticated(url);
-	}
-	return fetchCsvFromGoogleSheetAuthenticated(url);
-}
-async function writeCsvToGoogleSheet(rows, url) {
-	const { sheets: googleSheets, auth: googleAuth } = await loadGoogleSheetsApi();
-	const auth = new googleAuth.GoogleAuth({ scopes: ["https://www.googleapis.com/auth/spreadsheets"] });
-	const sheets = googleSheets("v4");
-	const match = url.match(/\/d\/([^/]+)/);
-	if (!match) throw new Error(`Invalid Google Sheets URL: ${url}`);
-	const spreadsheetId = match[1];
-	const headers = Object.keys(rows[0]);
-	const values = [headers, ...rows.map((row) => headers.map((header) => row[header]))];
-	const getColumnLetter = (col) => {
-		let letter = "";
-		while (col > 0) {
-			col--;
-			letter = String.fromCharCode(65 + col % 26) + letter;
-			col = Math.floor(col / 26);
-		}
-		return letter;
-	};
-	const numRows = values.length;
-	const numCols = headers.length;
-	const endColumn = getColumnLetter(numCols);
-	let range;
-	const gid = getSheetGid(url);
-	if (gid) {
-		const sheet = (await sheets.spreadsheets.get({
-			spreadsheetId,
-			auth
-		})).data.sheets?.find((sheet) => sheet.properties?.sheetId === Number(gid));
-		if (!sheet || !sheet.properties?.title) throw new Error(`Sheet not found for gid: ${gid}`);
-		range = `${sheet.properties.title}!A1:${endColumn}${numRows}`;
-	} else {
-		const newSheetTitle = `Sheet${Date.now()}`;
-		await sheets.spreadsheets.batchUpdate({
-			spreadsheetId,
-			auth,
-			requestBody: { requests: [{ addSheet: { properties: { title: newSheetTitle } } }] }
-		});
-		range = `${newSheetTitle}!A1:${endColumn}${numRows}`;
-	}
-	logger.debug(`Writing CSV to Google Sheets URL: ${url} with ${values.length} rows`);
-	await sheets.spreadsheets.values.update({
-		spreadsheetId,
-		range,
-		valueInputOption: "USER_ENTERED",
-		auth,
-		requestBody: { values }
-	});
-}
-//#endregion
-//#region src/util/eval/evalTableUtils.ts
-/**
-* Error thrown when a comparison eval is not found.
-*/
-var ComparisonEvalNotFoundError = class extends Error {
-	constructor(evalId) {
-		super(`Comparison eval not found: ${evalId}`);
-		this.name = "ComparisonEvalNotFoundError";
-	}
-};
-/**
-* Keep this in its current order, as it is used to map the columns in the CSV, so it needs to be static.
-*
-* The keys are the names of the columns in the metadata object, and the values are the names of the columns in the CSV.
-*
-* This is imported by enterprise so it doesn't need to be copied.
-*/
-const REDTEAM_METADATA_KEYS_TO_CSV_COLUMN_NAMES = {
-	messages: "Messages",
-	redteamHistory: "RedteamHistory",
-	redteamTreeHistory: "RedteamTreeHistory",
-	pluginId: "pluginId",
-	strategyId: "strategyId",
-	sessionId: "sessionId",
-	sessionIds: "sessionIds"
-};
-const REDTEAM_METADATA_COLUMNS = Object.values(REDTEAM_METADATA_KEYS_TO_CSV_COLUMN_NAMES);
-/**
-* Get the status string for an output
-*/
-function getOutputStatus(output) {
-	if (output.pass) return "PASS";
-	return output.failureReason === ResultFailureReason.ASSERT ? "FAIL" : "ERROR";
-}
-/**
-* Format named scores for CSV output.
-* Returns empty string if no named scores, otherwise JSON string.
-*/
-function formatNamedScores(namedScores) {
-	if (!namedScores || Object.keys(namedScores).length === 0) return "";
-	const rounded = {};
-	for (const [key, value] of Object.entries(namedScores)) if (typeof value === "number" && !Number.isNaN(value)) rounded[key] = Number(value.toFixed(2));
-	if (Object.keys(rounded).length === 0) return "";
-	return JSON.stringify(rounded);
-}
-function formatNamedScoreValue(value) {
-	return typeof value === "number" && !Number.isNaN(value) ? value.toFixed(2) : "";
-}
-/**
-* Build a per-prompt list of `Metric: <name>` column names, deduplicated and
-* sorted with `localeCompare`. Shared shell for both the row-scanning helper
-* (WebUI path) and the aggregate-reading helper (streaming CLI path); see the
-* two call sites below.
-*/
-function collectMetricNamesByPrompt(items, namesFor) {
-	return items.map((item, index) => [...new Set(namesFor(item, index))].sort((a, b) => a.localeCompare(b)));
-}
-/**
-* Collect per-row named metric names by scanning row outputs. Used by the
-* non-streaming WebUI export, which has the full table in memory.
-*
-* Returns one sorted name list per prompt, aligned with `table.head.prompts`.
-* Names whose only values are non-numeric or NaN are skipped so we don't emit
-* blank columns for invalid data.
-*/
-function collectNamedScoreNamesByPrompt(table) {
-	return collectMetricNamesByPrompt(table.head.prompts, (_, promptIndex) => {
-		const names = [];
-		for (const row of table.body) {
-			const namedScores = row.outputs[promptIndex]?.namedScores;
-			if (!namedScores) continue;
-			for (const [name, value] of Object.entries(namedScores)) if (typeof value === "number" && !Number.isNaN(value)) names.push(name);
-		}
-		return names;
-	});
-}
-/**
-* Collect per-row named metric names from prompt-level aggregate metrics, for
-* use by the streaming CSV path which cannot scan rows up front.
-*
-* Uses `namedScoresCount` because it is incremented only when a per-row
-* result contributes a metric (`src/util/namedMetrics.ts`). Derived metrics
-* write to `namedScores` but not `namedScoresCount` (`src/evaluator.ts`
-* `updateDerivedMetrics`), so this keeps the streaming column set aligned
-* with what `collectNamedScoreNamesByPrompt` would produce from row outputs.
-*
-* Returns an empty list both for prompts with no per-row contributions
-* (`namedScoresCount: {}` — modern eval with no named metrics configured)
-* and for prompts whose count map is missing entirely (legacy/imported
-* evals). Use `promptNeedsDiscoveryFallback` to distinguish the two: only
-* the latter requires a row-scan pre-pass.
-*/
-function collectNamedScoreNamesByPromptFromAggregate(prompts) {
-	return collectMetricNamesByPrompt(prompts, (prompt) => {
-		const counts = prompt.metrics?.namedScoresCount;
-		if (!counts) return [];
-		return Object.keys(counts).filter((name) => (counts[name] ?? 0) > 0);
-	});
-}
-/**
-* True when a prompt's aggregate `metrics.namedScoresCount` is missing/absent,
-* not merely empty. Legacy evals persisted before count tracking shipped, and
-* external imports via `POST /api/eval` that don't backfill the count, both
-* land here. Modern evals always have an object (possibly empty) and skip the
-* discovery pass.
-*/
-function promptNeedsDiscoveryFallback(prompt) {
-	const metrics = prompt.metrics;
-	return !metrics || !metrics.namedScoresCount;
-}
-/**
-* Scan one batch of `EvalResult` rows for the metric names that will need
-* dedicated `Metric: <name>` columns. Only inspects the prompts in
-* `fallbackPromptIndices` (those whose aggregate `namedScoresCount` is
-* missing/empty), and only touches `namedScores` + `testCase.description` —
-* not the full row shape — so the discovery pass stays allocation-light even
-* for very large legacy evals.
-*
-* Mirrors the row-output filter in `collectNamedScoreNamesByPrompt` so the
-* streaming CSV column set matches the WebUI CSV column set.
-*/
-function scanBatchForDiscovery(batchResults, acc, fallbackPromptIndices) {
-	for (const result of batchResults) {
-		if (!acc.hasDescriptions && result.testCase?.description) acc.hasDescriptions = true;
-		if (!fallbackPromptIndices.has(result.promptIdx)) continue;
-		const namedScores = result.namedScores;
-		if (!namedScores) continue;
-		let names = acc.metricNamesByPrompt.get(result.promptIdx);
-		if (!names) {
-			names = /* @__PURE__ */ new Set();
-			acc.metricNamesByPrompt.set(result.promptIdx, names);
-		}
-		for (const [name, value] of Object.entries(namedScores)) if (typeof value === "number" && !Number.isNaN(value)) names.add(name);
-	}
-}
-/**
-* Convert a batch of `EvalResult` rows (grouped by testIdx) into the table-row
-* shape that `tableRowToCsvValues` accepts. Used by `streamEvalCsv` to keep its
-* per-batch processing tight; the outputs array is pre-sized so columns line up
-* with prompts even when results arrive out of promptIdx order.
-*/
-function batchToStreamRows(batchResults, varNames, numPrompts) {
-	const rowsByTestIdx = /* @__PURE__ */ new Map();
-	for (const result of batchResults) {
-		let row = rowsByTestIdx.get(result.testIdx);
-		if (!row) {
-			row = {
-				vars: varNames.map((varName) => {
-					const value = result.testCase?.vars?.[varName];
-					return value === void 0 ? "" : String(value);
-				}),
-				outputs: new Array(numPrompts).fill(null),
-				test: { description: result.testCase?.description }
-			};
-			rowsByTestIdx.set(result.testIdx, row);
-		}
-		row.outputs[result.promptIdx] = {
-			text: result.response?.output ?? "",
-			pass: result.success,
-			score: result.score,
-			namedScores: result.namedScores,
-			failureReason: result.failureReason,
-			gradingResult: result.gradingResult,
-			metadata: result.metadata
-		};
-	}
-	return Array.from(rowsByTestIdx.values());
-}
-/**
-* Build CSV headers for an evaluation table.
-*
-* @param vars - Variable names from the table head
-* @param prompts - Prompt definitions from the table head
-* @param options - Export options
-* @param options.namedScoreNamesByPrompt - Named metric names that should get
-*   dedicated `Metric: <name>` columns, one sorted list per prompt (aligned
-*   with `prompts`). Must match the value passed to `tableRowToCsvValues` so
-*   header and row column counts stay in sync.
-* @returns Array of header strings
-*/
-function buildCsvHeaders(vars, prompts, options = {}) {
-	const headers = [
-		...options.hasDescriptions ? ["Description"] : [],
-		...vars,
-		...prompts.flatMap((prompt, promptIndex) => {
-			const provider = prompt.provider || "";
-			return [
-				provider ? `[${provider}] ${prompt.label}` : prompt.label,
-				"Status",
-				"Score",
-				"Named Scores",
-				...(options.namedScoreNamesByPrompt?.[promptIndex] || []).map((name) => `Metric: ${name}`),
-				"Grader Reason",
-				"Comment"
-			];
-		})
-	];
-	if (options.isRedteam) headers.push(...REDTEAM_METADATA_COLUMNS);
-	return headers;
-}
-/**
-* Convert a single table row to CSV row values.
-*
-* @param row - The table row to convert
-* @param options - Export options (`namedScoreNamesByPrompt` must match the
-*   array passed to `buildCsvHeaders`)
-* @returns Array of values for the CSV row
-*/
-function tableRowToCsvValues(row, options = {}) {
-	const rowValues = [
-		...options.hasDescriptions ? [row.test.description || ""] : [],
-		...row.vars,
-		...row.outputs.flatMap((output, outputIndex) => {
-			const namedScoreNames = options.namedScoreNamesByPrompt?.[outputIndex] || [];
-			if (!output) return [
-				"",
-				"",
-				"",
-				"",
-				...namedScoreNames.map(() => ""),
-				"",
-				""
-			];
-			const status = getOutputStatus(output);
-			const score = output.score?.toFixed(2) ?? "";
-			const namedScores = formatNamedScores(output.namedScores);
-			const namedScoreValues = namedScoreNames.map((name) => formatNamedScoreValue(output.namedScores?.[name]));
-			return [
-				output.text || "",
-				status,
-				score,
-				namedScores,
-				...namedScoreValues,
-				output.gradingResult?.reason || "",
-				output.gradingResult?.comment || ""
-			];
-		})
-	];
-	if (options.isRedteam) {
-		const redteamKeys = Object.keys(REDTEAM_METADATA_KEYS_TO_CSV_COLUMN_NAMES);
-		const firstOutputMetadata = row.outputs[0]?.metadata;
-		for (const key of redteamKeys) {
-			let value = firstOutputMetadata?.[key];
-			if (key === "strategyId" && (value === null || value === void 0)) value = "basic";
-			if (value === null || value === void 0) rowValues.push("");
-			else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") rowValues.push(value.toString());
-			else rowValues.push(JSON.stringify(value));
-		}
-	}
-	return rowValues;
-}
-/**
-* Escape every cell of a CSV row matrix (headers + body) against spreadsheet
-* formula injection (CWE-1236), unless disabled via
-* `PROMPTFOO_DISABLE_CSV_FORMULA_ESCAPING`. Numbers and booleans pass through
-* untouched; only string cells are inspected. Applied at the `csvStringify`
-* boundary so `buildCsvHeaders`/`tableRowToCsvValues` stay pure and re-importable
-* CSVs are never produced from un-escaped data.
-*/
-function escapeCsvRowsForFormulaInjection(rows, env) {
-	const configuredValue = env?.PROMPTFOO_DISABLE_CSV_FORMULA_ESCAPING ?? process.env.PROMPTFOO_DISABLE_CSV_FORMULA_ESCAPING;
-	if ([
-		"1",
-		"true",
-		"yes",
-		"yup",
-		"yeppers"
-	].includes(configuredValue?.toLowerCase() ?? "")) return rows;
-	return rows.map((row) => row.map((cell) => typeof cell === "string" ? escapeCsvFormula(cell) : cell));
-}
-function isNumericCell(value) {
-	return value.trim() !== "" && Number.isFinite(Number(value));
-}
-/**
-* Neutralize spreadsheet formula (CSV) injection at eval export time (CWE-1236).
-*
-* Spreadsheet applications execute cells beginning with `=`, `+`, `-`, or `@`
-* as formulas. Exported eval data can contain attacker-controlled model output,
-* variables, and grader comments, and CSV quoting alone does not neutralize
-* those formulas. Prefix dangerous values with the spreadsheet-native text
-* marker while preserving finite signed numbers.
-*
-* Leading whitespace and zero-width characters are ignored when identifying a
-* trigger because spreadsheet applications can strip them before evaluation.
-*/
-function escapeCsvFormula(value) {
-	if (value.length === 0) return value;
-	const unpadded = value.replace(/^[\s\u200B\u200C\u200D]+/, "");
-	const firstChar = unpadded[0];
-	if (firstChar === void 0) return value;
-	return firstChar === "=" || firstChar === "@" || (firstChar === "-" || firstChar === "+") && !isNumericCell(unpadded) ? `'${value}` : value;
-}
-/**
-* Generates CSV data from evaluation table data.
-*
-* Column structure per prompt:
-* - Output: Pure LLM output text (no pass/fail prefix)
-* - Status: PASS | FAIL | ERROR
-* - Score: Numeric score (e.g., "1.00")
-* - Named Scores: JSON object with per-assertion scores (e.g., {"clarity": 0.90, "accuracy": 0.85})
-* - Metric: <name>: One dedicated column per distinct per-row named score,
-*   sorted alphabetically by name. Empty when a row has no value for that
-*   metric. Derived metrics are intentionally omitted (they live on the
-*   aggregate prompt metrics, not on individual rows).
-* - Grader Reason: Explanation from the grader
-* - Comment: Additional grader comment
-*
-* This function is the single source of truth for CSV generation,
-* used by both the WebUI export and CLI export.
-*
-* @param table - The evaluation table data
-* @param options - Export options
-* @returns CSV formatted string
-*/
-function evalTableToCsv(table, options = {}) {
-	const { env, isRedteam = false } = options;
-	const hasDescriptions = table.body.some((row) => row.test.description);
-	const namedScoreNamesByPrompt = collectNamedScoreNamesByPrompt(table);
-	const csvRows = [buildCsvHeaders(table.head.vars, table.head.prompts, {
-		hasDescriptions,
-		isRedteam,
-		namedScoreNamesByPrompt
-	}), ...table.body.map((row) => tableRowToCsvValues(row, {
-		hasDescriptions,
-		isRedteam,
-		namedScoreNamesByPrompt
-	}))];
-	return stringify(escapeCsvRowsForFormulaInjection(csvRows, env));
-}
-/**
-* Generate JSON data from evaluation table
-* @param table Evaluation table data
-* @returns JSON object
-*/
-function evalTableToJson(table) {
-	return table;
-}
-function getEvalTableOutputPromptLocationsBySize(payload) {
-	return payload.table.body.flatMap((row, rowIndex) => row.outputs.flatMap((output, outputIndex) => output?.prompt ? [{
-		rowIndex,
-		outputIndex,
-		length: output.prompt.length
-	}] : [])).sort((a, b) => b.length - a.length);
-}
-function stripEvalTableOutputPrompts(payload, locationsToStrip) {
-	return {
-		...payload,
-		table: {
-			...payload.table,
-			body: payload.table.body.map((row, rowIndex) => ({
-				...row,
-				outputs: row.outputs.map((output, outputIndex) => {
-					if (!output || !locationsToStrip.has(`${rowIndex}:${outputIndex}`)) return output;
-					return {
-						...output,
-						prompt: ""
-					};
-				})
-			}))
-		}
-	};
-}
-function getEvalTablePromptStrippedPayload(payload, promptLocations, promptCountToStrip) {
-	return stripEvalTableOutputPrompts(payload, new Set(promptLocations.slice(0, promptCountToStrip).map(({ rowIndex, outputIndex }) => `${rowIndex}:${outputIndex}`)));
-}
-/**
-* Merges comparison tables with the main table for side-by-side CSV export.
-*
-* @param mainEvalId - The ID of the main evaluation
-* @param mainTable - The main evaluation table
-* @param comparisonData - Array of comparison eval data (eval ID and table)
-* @returns Merged table with all prompts and outputs combined
-*/
-function mergeComparisonTables(mainEvalId, mainTable, comparisonData) {
-	return {
-		head: {
-			prompts: [...mainTable.head.prompts.map((prompt) => ({
-				...prompt,
-				label: `[${mainEvalId}] ${prompt.label || ""}`
-			})), ...comparisonData.flatMap(({ evalId, table }) => table.head.prompts.map((prompt) => ({
-				...prompt,
-				label: `[${evalId}] ${prompt.label || ""}`
-			})))],
-			vars: mainTable.head.vars
-		},
-		body: mainTable.body.map((row) => {
-			const testIdx = row.testIdx;
-			const matchingRows = comparisonData.map(({ table }) => table.body.find((compRow) => compRow.testIdx === testIdx)).filter((r) => r !== void 0);
-			return {
-				...row,
-				outputs: [...row.outputs, ...matchingRows.flatMap((r) => r.outputs)]
-			};
-		})
-	};
-}
-/**
-* High-level function to generate CSV from an evaluation.
-*
-* Used by WebUI for CSV downloads (with or without comparison evals).
-* For CLI exports, use `streamEvalCsv` which is more memory-efficient
-* for large datasets.
-*
-* Both functions use the same underlying formatting (`evalTableToCsv`,
-* `buildCsvHeaders`, `tableRowToCsvValues`) to ensure consistent output.
-*
-* @param eval_ - The evaluation to export
-* @param options - Export options including filters and comparison eval IDs
-* @returns CSV formatted string
-* @throws ComparisonEvalNotFoundError if a comparison eval ID is not found
-* @throws Error if comparison exports requested without findEvalById callback
-*/
-async function generateEvalCsv(eval_, options = {}) {
-	const UNLIMITED_RESULTS = Number.MAX_SAFE_INTEGER;
-	const mainTable = await eval_.getTablePage({
-		offset: 0,
-		limit: UNLIMITED_RESULTS,
-		filterMode: options.filterMode,
-		searchQuery: options.searchQuery,
-		filters: options.filters
-	});
-	let finalTable = mainTable;
-	if (options.comparisonEvalIds && options.comparisonEvalIds.length > 0) {
-		if (!options.findEvalById) throw new Error("findEvalById callback is required for comparison exports. Pass Eval.findById when calling from server routes.");
-		const indices = mainTable.body.map((row) => row.testIdx);
-		const comparisonData = await Promise.all(options.comparisonEvalIds.map(async (comparisonEvalId) => {
-			const comparisonEval = await options.findEvalById(comparisonEvalId);
-			if (!comparisonEval) throw new ComparisonEvalNotFoundError(comparisonEvalId);
-			const table = await comparisonEval.getTablePage({
-				offset: 0,
-				limit: indices.length,
-				filterMode: "all",
-				testIndices: indices,
-				searchQuery: options.searchQuery,
-				filters: options.filters
-			});
-			return {
-				evalId: comparisonEval.id,
-				table
-			};
-		}));
-		finalTable = mergeComparisonTables(eval_.id, mainTable, comparisonData);
-	}
-	return evalTableToCsv(finalTable, {
-		env: eval_.config.env,
-		isRedteam: Boolean(eval_.config.redteam)
-	});
-}
-/**
-* Stream CSV data from an evaluation in batches.
-*
-* This is more memory-efficient for large evaluations as it processes
-* results in batches rather than loading everything into memory.
-*
-* Used by the CLI export (`promptfoo eval -o output.csv`) to maintain
-* consistent CSV format with WebUI exports while handling large datasets.
-*
-* @param eval_ - The evaluation to export
-* @param options - Streaming options including the write callback
-*/
-async function streamEvalCsv(eval_, options) {
-	const { isRedteam = false, write } = options;
-	const env = eval_.config?.env;
-	const varNames = eval_.vars;
-	const prompts = eval_.prompts;
-	const numPrompts = prompts.length;
-	const namedScoreNamesByPrompt = collectNamedScoreNamesByPromptFromAggregate(prompts);
-	const fallbackPromptIndices = prompts.flatMap((prompt, promptIndex) => promptNeedsDiscoveryFallback(prompt) ? [promptIndex] : []);
-	const fallbackPromptIndexSet = new Set(fallbackPromptIndices);
-	const accumulator = {
-		metricNamesByPrompt: /* @__PURE__ */ new Map(),
-		hasDescriptions: false
-	};
-	for await (const batchResults of eval_.fetchResultsBatched()) scanBatchForDiscovery(batchResults, accumulator, fallbackPromptIndexSet);
-	const hasDescriptions = accumulator.hasDescriptions;
-	for (const promptIndex of fallbackPromptIndices) {
-		const names = accumulator.metricNamesByPrompt.get(promptIndex);
-		namedScoreNamesByPrompt[promptIndex] = names ? [...names].sort((a, b) => a.localeCompare(b)) : [];
-	}
-	const headers = buildCsvHeaders(varNames, prompts, {
-		hasDescriptions,
-		isRedteam,
-		namedScoreNamesByPrompt
-	});
-	await write(stringify(escapeCsvRowsForFormulaInjection([headers], env)));
-	for await (const batchResults of eval_.fetchResultsBatched()) {
-		const csvRows = batchToStreamRows(batchResults, varNames, numPrompts).map((row) => tableRowToCsvValues(row, {
-			hasDescriptions,
-			isRedteam,
-			namedScoreNamesByPrompt
-		}));
-		if (csvRows.length > 0) await write(stringify(escapeCsvRowsForFormulaInjection(csvRows, env)));
-	}
-}
-//#endregion
-//#region src/util/junit.ts
-const MAX_JUNIT_NAME_LENGTH = 512;
-const MAX_JUNIT_DETAIL_LENGTH = 8192;
-const JUNIT_ASSERTION_FAILURE_MESSAGE = "Assertion failed";
-const JUNIT_EVALUATION_ERROR_MESSAGE = "Evaluation error";
-const INVALID_XML_CHARACTERS = /[^\t\n\r\u0020-\ud7ff\ue000-\ufffd\u{10000}-\u{10ffff}]/gu;
-function truncateText(value, maxLength) {
-	if (value.length <= maxLength) return value;
-	const cutoff = maxLength - 3;
-	const end = (value.codePointAt(cutoff - 1) ?? 0) > 65535 ? cutoff + 1 : cutoff;
-	return `${value.slice(0, end)}...`;
-}
-function normalizeInlineText(value, fallback, maxLength = MAX_JUNIT_NAME_LENGTH) {
-	return truncateText((value ?? "").replace(/\s+/g, " ").replace(INVALID_XML_CHARACTERS, "").replace(/\s+/g, " ").trim() || fallback, maxLength);
-}
-function formatDurationSeconds(durationMs) {
-	return Number(((typeof durationMs === "number" && Number.isFinite(durationMs) && durationMs > 0 ? durationMs : 0) / 1e3).toFixed(3)).toString();
-}
-function getEvaluationTimestamp(evalRecord) {
-	const date = new Date(evalRecord.createdAt);
-	return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
-}
-function getTestCaseName(result) {
-	const prefix = `test ${result.testIdx + 1}`;
-	const description = normalizeInlineText(result.description || result.testCase.description, "");
-	return description ? `${prefix}: ${description}` : prefix;
-}
-function getFailedComponentResults(gradingResult) {
-	return gradingResult?.componentResults?.filter((component) => !component.pass) ?? [];
-}
-function getAssertionLabel(gradingResult) {
-	return gradingResult.assertion?.type ?? "assertion";
-}
-function getFailedAssertionLabels(gradingResult) {
-	const failedComponents = getFailedComponentResults(gradingResult);
-	if (failedComponents.length > 0) return failedComponents.map(getAssertionLabel);
-	return gradingResult ? [getAssertionLabel(gradingResult)] : [];
-}
-function getFailureDetails(result) {
-	const lines = [`Score: ${result.score}`, `Reason: ${JUNIT_ASSERTION_FAILURE_MESSAGE}`];
-	const failedAssertionLabels = getFailedAssertionLabels(result.gradingResult);
-	if (failedAssertionLabels.length > 0) {
-		lines.push("Failed assertions:");
-		for (const label of failedAssertionLabels) lines.push(`- ${label}`);
-	}
-	return truncateText(lines.join("\n").replace(INVALID_XML_CHARACTERS, ""), MAX_JUNIT_DETAIL_LENGTH);
-}
-function projectEvalResult(result) {
-	const projected = "toEvaluateResult" in result ? result.toEvaluateResult() : result;
-	return {
-		description: projected.description,
-		error: projected.error,
-		failureReason: projected.failureReason,
-		gradingResult: projected.gradingResult,
-		latencyMs: projected.latencyMs,
-		prompt: projected.prompt,
-		promptId: projected.promptId,
-		promptIdx: projected.promptIdx,
-		provider: projected.provider,
-		score: projected.score,
-		success: projected.success,
-		testCase: projected.testCase,
-		testIdx: projected.testIdx
-	};
-}
-async function* iterateJunitProjectedResults(evalRecord) {
-	if (evalRecord.useOldResults()) {
-		const results = await evalRecord.getResults();
-		for (const result of results) yield projectEvalResult(result);
-		return;
-	}
-	if (!evalRecord.persisted) {
-		for (const result of evalRecord.results) yield projectEvalResult(result);
-		return;
-	}
-	for await (const batchResults of evalRecord.fetchResultsBatched()) for (const result of batchResults) yield projectEvalResult(result);
-}
-async function buildJunitSuites(evalRecord) {
-	const suites = /* @__PURE__ */ new Map();
-	const providersByDisplayName = /* @__PURE__ */ new Map();
-	for await (const result of iterateJunitProjectedResults(evalRecord)) {
-		const { provider } = result;
-		const providerKey = JSON.stringify([provider.id ?? "", provider.label ?? ""]);
-		const promptKey = result.promptId || `prompt-index:${result.promptIdx}`;
-		const key = JSON.stringify([providerKey, promptKey]);
-		let suite = suites.get(key);
-		if (!suite) {
-			const rawName = provider.label || provider.id || "";
-			const displayName = normalizeInlineText(rawName, "unknown provider");
-			const providers = providersByDisplayName.get(displayName) ?? /* @__PURE__ */ new Set();
-			providers.add(providerKey);
-			providersByDisplayName.set(displayName, providers);
-			suite = {
-				providerKey,
-				rawName,
-				promptKey,
-				promptIdx: result.promptIdx,
-				displayName: "",
-				errors: 0,
-				failures: 0,
-				testcases: [],
-				timeMs: 0
-			};
-			suites.set(key, suite);
-		}
-		suite.promptIdx = Math.min(suite.promptIdx, result.promptIdx);
-		suite.testcases.push({
-			testcase: buildJunitTestCase(result),
-			testIdx: result.testIdx
-		});
-		suite.timeMs += result.latencyMs;
-		if (!result.success) {
-			if (result.failureReason === ResultFailureReason.ASSERT) suite.failures += 1;
-			else suite.errors += 1;
-		}
-	}
-	const promptCountsByProvider = /* @__PURE__ */ new Map();
-	const orderedSuites = [...suites.values()].sort((a, b) => a.promptIdx - b.promptIdx || a.promptKey.localeCompare(b.promptKey));
-	for (const suite of orderedSuites) {
-		const baseName = normalizeInlineText(suite.rawName, "unknown provider");
-		const suffix = (providersByDisplayName.get(baseName)?.size ?? 0) > 1 || suite.rawName.search(INVALID_XML_CHARACTERS) !== -1 ? ` (${sha256(suite.providerKey).slice(0, 16)})` : "";
-		const providerName = normalizeInlineText(suite.rawName, "unknown provider", MAX_JUNIT_NAME_LENGTH - suffix.length);
-		const ordinal = (promptCountsByProvider.get(suite.providerKey) ?? 0) + 1;
-		promptCountsByProvider.set(suite.providerKey, ordinal);
-		suite.displayName = `[${providerName}] prompt ${ordinal}${suffix}`;
-		for (const { testcase } of suite.testcases) testcase["@_classname"] = suite.displayName;
-	}
-	return [...suites.values()];
-}
-function buildJunitTestCase(result) {
-	const testcase = {
-		"@_name": getTestCaseName(result),
-		"@_time": formatDurationSeconds(result.latencyMs)
-	};
-	if (!result.success) {
-		if (result.failureReason === ResultFailureReason.ASSERT) testcase.failure = {
-			"#text": getFailureDetails(result),
-			"@_message": JUNIT_ASSERTION_FAILURE_MESSAGE,
-			"@_type": "assertion"
-		};
-		else testcase.error = {
-			"#text": `Reason: ${JUNIT_EVALUATION_ERROR_MESSAGE}`,
-			"@_message": JUNIT_EVALUATION_ERROR_MESSAGE,
-			"@_type": "error"
-		};
-	}
-	return testcase;
-}
-async function createJunitXml(evalRecord) {
-	const suites = await buildJunitSuites(evalRecord);
-	const tests = suites.reduce((sum, suite) => sum + suite.testcases.length, 0);
-	const failures = suites.reduce((sum, suite) => sum + suite.failures, 0);
-	const errors = suites.reduce((sum, suite) => sum + suite.errors, 0);
-	const totalTimeMs = suites.reduce((sum, suite) => sum + suite.timeMs, 0);
-	const timestamp = getEvaluationTimestamp(evalRecord);
-	return new XMLBuilder({
-		format: true,
-		ignoreAttributes: false,
-		indentBy: "  "
-	}).build({
-		"?xml": {
-			"@_version": "1.0",
-			"@_encoding": "UTF-8"
-		},
-		testsuites: {
-			"@_errors": errors,
-			"@_failures": failures,
-			"@_name": "promptfoo",
-			"@_skipped": 0,
-			"@_tests": tests,
-			"@_time": formatDurationSeconds(totalTimeMs),
-			testsuite: suites.map((suite) => ({
-				"@_errors": suite.errors,
-				"@_failures": suite.failures,
-				"@_name": suite.displayName,
-				"@_skipped": 0,
-				"@_tests": suite.testcases.length,
-				"@_time": formatDurationSeconds(suite.timeMs),
-				...timestamp ? { "@_timestamp": timestamp } : {},
-				testcase: suite.testcases.sort((a, b) => a.testIdx - b.testIdx).map(({ testcase }) => testcase)
-			}))
-		}
-	}).replace(INVALID_XML_CHARACTERS, "");
-}
-async function writeJunitXmlOutput(outputPath, evalRecord) {
-	await fsPromises.writeFile(outputPath, await createJunitXml(evalRecord));
-}
-const SUPPORTED_OUTPUT_FILE_FORMATS = [...OutputFileExtension.options, "junit.xml"];
-function getOutputFileFormat(outputPath) {
-	if (outputPath.toLowerCase().endsWith(".junit.xml")) return "junit.xml";
-	return OutputFileExtension.safeParse(path$1.extname(outputPath).slice(1).toLowerCase()).data;
-}
-//#endregion
-//#region src/util/output.ts
-function warnOnDegradedJsonlRecovery(evalRecord, outputPaths) {
-	if (!evalRecord.resultPersistenceFailed) return;
-	if (outputPaths.some((outputPath) => getOutputFileFormat(outputPath) === "jsonl")) logger.warn("[Output] Reconciling JSONL from streamed rows and the eval record because one or more rows failed to persist");
-}
-function isFileNotFoundError(error) {
-	return error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
-}
-function isPermissionDeniedError(error) {
-	return error !== null && typeof error === "object" && "code" in error && (error.code === "EACCES" || error.code === "EPERM");
-}
-async function resolveJsonlOutputPath(outputPath) {
-	try {
-		if (!(await fsPromises.lstat(outputPath)).isSymbolicLink()) return outputPath;
-		try {
-			return await fsPromises.realpath(outputPath);
-		} catch (error) {
-			if (isFileNotFoundError(error)) return path$1.resolve(path$1.dirname(outputPath), await fsPromises.readlink(outputPath));
-			throw error;
-		}
-	} catch (error) {
-		if (isFileNotFoundError(error)) return outputPath;
-		throw error;
-	}
-}
-async function appendJsonlResultBatch(outputPath, results, stripFlags) {
-	if (results.length === 0) return;
-	const text = results.map((result) => JSON.stringify(sanitizeResultForJsonlArtifact(result, stripFlags))).join(os$1.EOL) + os$1.EOL;
-	await fsPromises.appendFile(outputPath, text);
-}
-async function readStreamedJsonlResults(outputPath) {
-	let contents;
-	try {
-		contents = await fsPromises.readFile(outputPath, "utf8");
-	} catch (error) {
-		if (error.code === "ENOENT") return [];
-		throw error;
-	}
-	const results = [];
-	const lines = contents.split(/\r?\n/).filter(Boolean);
-	for (const [index, line] of lines.entries()) try {
-		results.push(JSON.parse(line));
-	} catch (error) {
-		logger.warn(`[Output] Skipping malformed streamed JSONL row at ${outputPath}:${index + 1} during recovery: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	return results;
-}
-async function collectJsonlResultsAfterPersistenceFailure(outputPath, evalRecord) {
-	const stripFlags = getStripFlags(evalRecord.config.env);
-	const finalResults = /* @__PURE__ */ new Map();
-	const put = (result) => finalResults.set(getResultIndexKey(result), result);
-	for (const result of await readStreamedJsonlResults(outputPath)) put(result);
-	for await (const batchResults of evalRecord.fetchResultsBatched()) for (const result of batchResults) {
-		const evaluateResult = asEvaluateResult(result, stripFlags);
-		if (!evalRecord.hasResultPersistenceFailure(evaluateResult)) put(evaluateResult);
-	}
-	for (const result of evalRecord.getFinalJsonlResults()) put(result);
-	return Array.from(finalResults.values());
-}
-async function getExistingFileMode(outputPath) {
-	try {
-		return (await fsPromises.stat(outputPath)).mode & 4095;
-	} catch (error) {
-		if (isFileNotFoundError(error)) return;
-		throw error;
-	}
-}
-async function appendJsonlResults(outputPath, evalRecord, recoveredResults) {
-	const stripFlags = getStripFlags(evalRecord.config.env);
-	if (recoveredResults) {
-		await appendJsonlResultBatch(outputPath, recoveredResults, stripFlags);
-		return;
-	}
-	for await (const batchResults of evalRecord.fetchResultsBatched()) await appendJsonlResultBatch(outputPath, batchResults.map((result) => asEvaluateResult(result, stripFlags)), stripFlags);
-}
-async function rewriteJsonlWithExternalBackup(outputPath, outputMode, evalRecord, preparedReplacementPath, recoveredResults) {
-	const tempDirectory = await fsPromises.mkdtemp(path$1.join(os$1.tmpdir(), "promptfoo-jsonl-"));
-	const backupPath = path$1.join(tempDirectory, "backup.jsonl");
-	const replacementPath = path$1.join(tempDirectory, "replacement.jsonl");
-	let overwriteAttempted = false;
-	let preserveTempDirectory = false;
-	let hasBackup = false;
-	try {
-		try {
-			await fsPromises.copyFile(outputPath, backupPath);
-			hasBackup = true;
-		} catch (error) {
-			if (!isFileNotFoundError(error)) throw error;
-		}
-		if (preparedReplacementPath) await fsPromises.copyFile(preparedReplacementPath, replacementPath);
-		else {
-			if (outputMode === void 0) await fsPromises.writeFile(replacementPath, "");
-			else await fsPromises.writeFile(replacementPath, "", { mode: outputMode });
-			await appendJsonlResults(replacementPath, evalRecord, recoveredResults);
-		}
-		overwriteAttempted = true;
-		await fsPromises.copyFile(replacementPath, outputPath);
-		if (outputMode !== void 0) await fsPromises.chmod(outputPath, outputMode);
-	} catch (error) {
-		if (overwriteAttempted && hasBackup) try {
-			await fsPromises.copyFile(backupPath, outputPath);
-		} catch (restoreError) {
-			preserveTempDirectory = true;
-			logger.error("[Output] Failed to restore JSONL output after rewrite failure", {
-				backupPath,
-				error: restoreError
-			});
-			throw new Error(`Failed to rewrite JSONL output (${error instanceof Error ? error.message : String(error)}) and restore backup (${restoreError instanceof Error ? restoreError.message : String(restoreError)}). Backup retained at ${backupPath}`);
-		}
-		throw error;
-	} finally {
-		if (!preserveTempDirectory) await fsPromises.rm(tempDirectory, {
-			recursive: true,
-			force: true
-		}).catch((error) => {
-			logger.warn("[Output] Failed to remove temporary JSONL backup directory", {
-				error,
-				tempDirectory
-			});
-		});
-	}
-}
-async function removeTemporaryJsonlOutput(tempOutputPath) {
-	await fsPromises.rm(tempOutputPath, { force: true }).catch((error) => {
-		logger.warn("[Output] Failed to remove temporary JSONL output", {
-			error,
-			tempOutputPath
-		});
-	});
-}
-const outputToSimpleString = (output) => {
-	const passFailText = output.pass ? "[PASS]" : output.failureReason === ResultFailureReason.ASSERT ? "[FAIL]" : "[ERROR]";
-	const namedScoresText = Object.entries(output.namedScores).map(([name, value]) => `${name}: ${value?.toFixed(2)}`).join(", ");
-	const scoreText = namedScoresText.length > 0 ? `(${output.score?.toFixed(2)}, ${namedScoresText})` : `(${output.score?.toFixed(2)})`;
-	const gradingResultText = output.gradingResult ? `${output.pass ? "Pass" : "Fail"} Reason: ${output.gradingResult.reason}` : "";
-	return dedent`
-      ${passFailText} ${scoreText}
-
-      ${output.text}
-
-      ${gradingResultText}
-    `.trim();
-};
-const outputToHtmlReportCell = (output) => {
-	const status = output.pass ? "pass" : output.failureReason === ResultFailureReason.ERROR ? "error" : "fail";
-	const namedScores = Object.entries(output.namedScores).map(([name, value]) => ({
-		name,
-		value: value?.toFixed(2)
-	}));
-	return {
-		status,
-		statusLabel: status.toUpperCase(),
-		score: output.score?.toFixed(2),
-		namedScores,
-		text: output.text,
-		reason: output.gradingResult?.reason || "",
-		prompt: output.prompt,
-		provider: output.provider || "",
-		error: output.error || "",
-		failureReason: output.failureReason,
-		latencyDisplay: Number.isFinite(output.latencyMs) ? `${output.latencyMs.toFixed(0)} ms` : "",
-		costDisplay: Number.isFinite(output.cost) && output.cost > 0 ? `$${output.cost.toFixed(6)}` : "",
-		totalTokensDisplay: typeof output.tokenUsage?.total === "number" ? output.tokenUsage.total.toLocaleString("en-US") : "",
-		promptTokensDisplay: typeof output.tokenUsage?.prompt === "number" ? output.tokenUsage.prompt.toLocaleString("en-US") : "",
-		completionTokensDisplay: typeof output.tokenUsage?.completion === "number" ? output.tokenUsage.completion.toLocaleString("en-US") : ""
-	};
-};
-async function createOutputSummary(evalRecord, stripFlags) {
-	const summary = await evalRecord.toEvaluateSummary();
-	const prompts = ("prompts" in summary ? summary.prompts : summary.table.head.prompts).map((prompt) => prompt.config ? {
-		...prompt,
-		config: sanitizeConfigForOutput(prompt.config, stripFlags)
-	} : prompt);
-	return "prompts" in summary ? {
-		...summary,
-		prompts
-	} : {
-		...summary,
-		table: {
-			...summary.table,
-			head: {
-				...summary.table.head,
-				prompts
-			}
-		}
-	};
-}
-function resultsForMediaExportScan(results, shouldStripResponseOutput) {
-	if (!shouldStripResponseOutput) return results;
-	return {
-		...results,
-		results: results.results.map((result) => {
-			const response = result.response;
-			if (!response?.metadata || !("blobUris" in response.metadata)) return result;
-			const { metadata: responseMetadata, ...projectedResponse } = response;
-			const { blobUris: _blobUris, ...metadata } = responseMetadata;
-			return {
-				...result,
-				response: {
-					...projectedResponse,
-					...Object.keys(metadata).length > 0 && { metadata }
-				}
-			};
-		})
-	};
-}
-function createOutputMetadata(evalRecord) {
-	let evaluationCreatedAt;
-	if (evalRecord.createdAt) try {
-		const date = new Date(evalRecord.createdAt);
-		evaluationCreatedAt = Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
-	} catch {
-		evaluationCreatedAt = void 0;
-	}
-	return {
-		promptfooVersion: VERSION,
-		nodeVersion: process.version,
-		platform: os$1.platform(),
-		arch: os$1.arch(),
-		exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		evaluationCreatedAt,
-		author: evalRecord.author ?? void 0
-	};
-}
-async function createOutputData(evalRecord, shareableUrl, options = {}) {
-	const stripFlags = getStripFlags(evalRecord.config.env);
-	const summary = await createOutputSummary(evalRecord, stripFlags);
-	const redactedConfig = sanitizeConfigForOutput(evalRecord.config, stripFlags);
-	let traces;
-	try {
-		const { getTraceStore } = await import("./store-D2b7vhhQ.js");
-		traces = await getTraceStore().getTracesByEvaluation(evalRecord.id);
-	} catch (error) {
-		logger.warn(`Failed to fetch traces for output ${evalRecord.id}; traces omitted from export: ${error}`);
-	}
-	const output = {
-		evalId: evalRecord.id,
-		results: summary,
-		config: redactedConfig,
-		shareableUrl,
-		metadata: createOutputMetadata(evalRecord),
-		...evalRecord.vars?.length > 0 && { vars: [...evalRecord.vars] },
-		...evalRecord.runtimeOptions && { runtimeOptions: sanitizeRuntimeOptions(evalRecord.runtimeOptions) },
-		...traces && traces.length > 0 && { traces: projectTracesForOutput(traces, stripFlags) }
-	};
-	if (options.includeMedia) {
-		const blobAssets = await exportBlobAssets(evalRecord.id, summary, stripFlags.shouldStripResponseOutput, output.traces);
-		if (blobAssets.length > 0) output.blobAssets = blobAssets;
-	}
-	return output;
-}
-async function exportBlobAssets(evalId, results, shouldStripResponseOutput, traces) {
-	const { getShareAuthorizedBlob } = await import("./blobs-DQI39YOh.js");
-	const assets = [];
-	for (const hash of collectBlobHashes({
-		results: resultsForMediaExportScan(results, shouldStripResponseOutput),
-		traces
-	})) try {
-		const blob = await getShareAuthorizedBlob(hash, evalId);
-		if (!blob) continue;
-		if (blob.data.length > 52428800) {
-			logger.warn("[Output] Skipping oversized blob in eval export", {
-				hash,
-				sizeBytes: blob.data.length
-			});
-			continue;
-		}
-		assets.push({
-			hash,
-			mimeType: blob.metadata.mimeType,
-			sizeBytes: blob.data.length,
-			data: blob.data.toString("base64")
-		});
-	} catch (error) {
-		logger.warn("[Output] Skipping missing blob in eval export", {
-			error,
-			hash
-		});
-	}
-	return assets;
-}
-/**
-* JSON writer with improved error handling for large datasets.
-* Provides helpful error messages when memory limits are exceeded.
-*/
-async function writeJsonOutputSafely(outputPath, evalRecord, shareableUrl, options) {
-	try {
-		const outputData = await createOutputData(evalRecord, shareableUrl, options);
-		const jsonString = JSON.stringify(outputData, null, 2);
-		await fsPromises.writeFile(outputPath, jsonString);
-	} catch (error) {
-		const msg = error?.message ?? "";
-		const isStringLen = error instanceof RangeError && msg.includes("Invalid string length");
-		const isHeapOOM = /heap out of memory|Array buffer allocation failed|ERR_STRING_TOO_LONG/i.test(msg);
-		if (isStringLen || isHeapOOM) {
-			const resultCount = await evalRecord.getResultsCount();
-			logger.error(`Dataset too large for JSON export (${resultCount} results).`);
-			throw new Error(`Dataset too large for JSON export. The evaluation has ${resultCount} results which exceeds memory limits. Consider using JSONL format instead: --output output.jsonl`);
-		} else throw error;
-	}
-}
-async function writeOutput(outputPath, evalRecord, shareableUrl, options = {}) {
-	if (outputPath.match(/^https:\/\/docs\.google\.com\/spreadsheets\//)) {
-		const table = await evalRecord.getTable();
-		const rows = table.body.map((row) => {
-			const csvRow = {};
-			table.head.vars.forEach((varName, index) => {
-				csvRow[varName] = row.vars[index];
-			});
-			table.head.prompts.forEach((prompt, index) => {
-				csvRow[`[${prompt.provider}] ${prompt.label}`] = outputToSimpleString(row.outputs[index]);
-			});
-			return csvRow;
-		});
-		logger.info(`Writing ${rows.length} rows to Google Sheets...`);
-		await writeCsvToGoogleSheet(rows, outputPath);
-		return;
-	}
-	const outputExtension = getOutputFileFormat(outputPath);
-	invariant(outputExtension, `Unsupported output file format ${path$1.extname(outputPath).slice(1).toLowerCase()}. Please use one of: ${SUPPORTED_OUTPUT_FILE_FORMATS.join(", ")}.`);
-	const outputDir = path$1.dirname(outputPath);
-	await fsPromises.mkdir(outputDir, { recursive: true });
-	if (outputExtension === "junit.xml") await writeJunitXmlOutput(outputPath, evalRecord);
-	else if (outputExtension === "csv") {
-		const fileHandle = await fsPromises.open(outputPath, "w");
-		try {
-			await streamEvalCsv(evalRecord, {
-				isRedteam: Boolean(evalRecord.config.redteam),
-				write: async (data) => {
-					await fileHandle.write(data);
-				}
-			});
-		} finally {
-			await fileHandle.close();
-		}
-	} else if (outputExtension === "json") await writeJsonOutputSafely(outputPath, evalRecord, shareableUrl, options);
-	else if (outputExtension === "yaml" || outputExtension === "yml" || outputExtension === "txt") await fsPromises.writeFile(outputPath, yaml.dump(await createOutputData(evalRecord, shareableUrl, options)));
-	else if (outputExtension === "html") {
-		const table = await evalRecord.getTable();
-		const stripFlags = getStripFlags(evalRecord.config.env);
-		const summary = await createOutputSummary(evalRecord, stripFlags);
-		const redactedConfig = sanitizeConfigForOutput(evalRecord.config, stripFlags);
-		const metadata = createOutputMetadata(evalRecord);
-		const template = await fsPromises.readFile(path$1.join(getDirectory(), "tableOutput.html"), "utf-8");
-		const htmlTable = [[...table.head.vars, ...table.head.prompts.map((prompt) => `[${prompt.provider}] ${prompt.label}`)], ...table.body.map((row, rowIndex) => [...row.vars.map((value, variableIndex) => ({
-			kind: "variable",
-			name: table.head.vars[variableIndex],
-			text: value
-		})), ...row.outputs.map((output, outputIndex) => ({
-			kind: "output",
-			detailId: `result-detail-${rowIndex}-${outputIndex}`,
-			detailTitle: `Result detail - row ${rowIndex + 1}, prompt ${outputIndex + 1}`,
-			description: row.description || row.test?.description || "",
-			...outputToHtmlReportCell(output)
-		}))])];
-		const reportOutputs = table.body.flatMap((row) => row.outputs);
-		const totalResults = reportOutputs.length;
-		const successes = reportOutputs.filter((output) => output.pass).length;
-		const errors = reportOutputs.filter((output) => !output.pass && output.failureReason === ResultFailureReason.ERROR).length;
-		const failures = totalResults - successes - errors;
-		const passRate = totalResults > 0 ? successes / totalResults * 100 : 0;
-		const htmlOutput = getNunjucksEngine().renderString(template, {
-			config: redactedConfig,
-			table: htmlTable,
-			results: summary,
-			metadata,
-			report: {
-				totalResults,
-				totalRows: table.body.length,
-				promptCount: table.head.prompts.length,
-				variableCount: table.head.vars.length,
-				successes,
-				failures,
-				errors,
-				passRateDisplay: `${passRate.toFixed(1)}%`
-			}
-		});
-		await fsPromises.writeFile(outputPath, htmlOutput);
-	} else if (outputExtension === "jsonl") {
-		const jsonlOutputPath = await resolveJsonlOutputPath(outputPath);
-		if (jsonlOutputPath !== outputPath) await fsPromises.mkdir(path$1.dirname(jsonlOutputPath), { recursive: true });
-		const outputMode = await getExistingFileMode(jsonlOutputPath);
-		const recoveredResults = evalRecord.resultPersistenceFailed ? await collectJsonlResultsAfterPersistenceFailure(jsonlOutputPath, evalRecord) : void 0;
-		const tempOutputPath = path$1.join(path$1.dirname(jsonlOutputPath), `.promptfoo-${randomUUID()}.tmp`);
-		try {
-			try {
-				await fsPromises.writeFile(tempOutputPath, "");
-			} catch (error) {
-				if (isPermissionDeniedError(error)) {
-					logger.warn("[Output] Falling back to JSONL rewrite with external backup because the output directory is not writable");
-					await rewriteJsonlWithExternalBackup(jsonlOutputPath, outputMode, evalRecord, void 0, recoveredResults);
-					return;
-				}
-				throw error;
-			}
-			await appendJsonlResults(tempOutputPath, evalRecord, recoveredResults);
-			if (outputMode !== void 0) await fsPromises.chmod(tempOutputPath, outputMode);
-			try {
-				await fsPromises.rename(tempOutputPath, jsonlOutputPath);
-			} catch (error) {
-				if (isPermissionDeniedError(error)) {
-					logger.warn("[Output] Falling back to JSONL rewrite with external backup because replacing the output file is not permitted");
-					await rewriteJsonlWithExternalBackup(jsonlOutputPath, outputMode, evalRecord, tempOutputPath);
-					await removeTemporaryJsonlOutput(tempOutputPath);
-					return;
-				}
-				throw error;
-			}
-		} catch (error) {
-			await removeTemporaryJsonlOutput(tempOutputPath);
-			throw error;
-		}
-	} else if (outputExtension === "xml") {
-		const stripFlags = getStripFlags(evalRecord.config.env);
-		const summary = await createOutputSummary(evalRecord, stripFlags);
-		const redactedConfig = sanitizeConfigForOutput(evalRecord.config, stripFlags);
-		const sanitizeForXml = (obj) => {
-			if (obj === null || obj === void 0) return "";
-			if (Array.isArray(obj)) return obj.map(sanitizeForXml);
-			if (typeof obj === "object") {
-				const sanitized = {};
-				for (const [key, value] of Object.entries(obj)) sanitized[key] = sanitizeForXml(value);
-				return sanitized;
-			}
-			return String(obj);
-		};
-		const xmlData = new XMLBuilder({
-			ignoreAttributes: false,
-			format: true,
-			indentBy: "  "
-		}).build({ promptfoo: {
-			evalId: evalRecord.id,
-			results: sanitizeForXml(summary),
-			config: sanitizeForXml(redactedConfig),
-			shareableUrl: shareableUrl || ""
-		} });
-		await fsPromises.writeFile(outputPath, xmlData);
-	}
-}
-async function writeMultipleOutputs(outputPaths, evalRecord, shareableUrl) {
-	const errors = (await Promise.allSettled(outputPaths.map((outputPath) => writeOutput(outputPath, evalRecord, shareableUrl)))).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
-	if (errors.length > 0) throw Object.assign(/* @__PURE__ */ new Error("One or more output writes failed"), { errors });
-}
-//#endregion
-//#region src/util/runtime.ts
-function printBorder() {
-	const border = "=".repeat(TERMINAL_MAX_WIDTH);
-	logger.info(border);
-}
-//#endregion
-export { isProviderConfigFileReference as A, getProviderIdentifier as C, isProviderAllowed as D, isOpenAiProvider as E, normalizeProviderRef as M, readProviderConfigFile as N, providerToIdentifier as O, getProviderDescription as S, isGoogleProvider as T, extractRuntimeVars as _, writeOutput as a, checkProviderApiKeys as b, ComparisonEvalNotFoundError as c, getEvalTableOutputPromptLocationsBySize as d, getEvalTablePromptStrippedPayload as f, deduplicateTestCases as g, setupEnv as h, writeMultipleOutputs as i, loadProviderConfigsFromFile as j, sanitizeProviderIdForLog as k, evalTableToJson as l, fetchCsvFromGoogleSheet as m, createOutputData as n, SUPPORTED_OUTPUT_FILE_FORMATS as o, mergeComparisonTables as p, warnOnDegradedJsonlRecovery as r, getOutputFileFormat as s, printBorder as t, generateEvalCsv as u, filterRuntimeVars as v, isAnthropicProvider as w, doesProviderRefMatch as x, resultIsForTestCase as y };
-
-//# sourceMappingURL=util-BD1R_PsR.js.map