vieval 0.0.1

package/dist/cli/index.mjs

@@ -0,0 +1,1434 @@
+#!/usr/bin/env node
+import { n as consumeModuleRegistrations, r as endModuleRegistration, s as loadVievalCliConfig, t as beginModuleRegistration } from "../registry-ChOjjdEC.mjs";
+import { a as runScheduledTasks, i as RunnerExecutionError, n as createRunnerSchedule, r as createRunnerRuntimeContext, s as collectEvalEntries, t as createTaskExecutionContext } from "../runner-4ZsOveoY.mjs";
+import process from "node:process";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { errorMessageFrom } from "@moeru/std";
+import c from "tinyrainbow";
+import meow from "meow";
+import { uniq } from "es-toolkit";
+import { glob } from "tinyglobby";
+import { stripVTControlCharacters } from "node:util";
+import stringWidth from "fast-string-width";
+//#region package.json
+var name = "vieval";
+//#endregion
+//#region src/cli/discovery.ts
+/**
+* Discovers eval files using include/exclude globs relative to project root.
+*
+* Before:
+* - Absolute path file list from recursive filesystem walk
+*
+* After:
+* - Filtered absolute path list matching include/exclude rules
+*/
+async function discoverEvalFiles(options) {
+	return uniq(await glob([...options.include], {
+		absolute: true,
+		cwd: options.root,
+		ignore: [...options.exclude],
+		onlyFiles: true
+	})).sort((left, right) => left.localeCompare(right));
+}
+//#endregion
+//#region src/cli/reporters/noop-reporter.ts
+/**
+* Creates a reporter that intentionally does nothing.
+*
+* Use when:
+* - terminal output should stay silent
+* - reporter wiring needs a safe default for tests or non-interactive runs
+*
+* Expects:
+* - callers may invoke any lifecycle method in any order that matches the run
+*
+* Returns:
+* - a stable reporter implementation with no observable side effects
+*/
+function createNoopReporter() {
+	return {
+		onRunStart(_payload) {},
+		onTaskQueued(_payload) {},
+		onTaskStart(_payload) {},
+		onCaseStart(_payload) {},
+		onCaseEnd(_payload) {},
+		onTaskEnd(_payload) {},
+		onRunEnd(_payload) {},
+		dispose() {}
+	};
+}
+//#endregion
+//#region src/cli/reporters/summary-reporter.ts
+const POINTER = "❯";
+const TREE_NODE_END = "└";
+const TREE_NODE_MIDDLE = "├";
+var SummaryReporterStateMachine = class {
+	options;
+	taskCounters = createCounterState();
+	caseCounters = createCounterState();
+	tasks = /* @__PURE__ */ new Map();
+	queueOrderCounter = 0;
+	startedAtMs = 0;
+	startTime = "";
+	constructor(options) {
+		this.options = options;
+	}
+	/**
+	* Handles run startup.
+	*
+	* Use when:
+	* - a new CLI run is starting and the summary state must reset
+	*
+	* Expects:
+	* - `totalTasks` matches the scheduled task count for the run
+	*
+	* Returns:
+	* - no direct value
+	*/
+	onRunStart(payload) {
+		this.tasks.clear();
+		this.queueOrderCounter = 0;
+		resetCounterState(this.taskCounters, payload.totalTasks);
+		resetCounterState(this.caseCounters, 0);
+		this.startedAtMs = this.options.getNow();
+		this.startTime = formatTimeString(new Date(this.options.getWallClockNow()));
+	}
+	/**
+	* Handles task queue events.
+	*
+	* Use when:
+	* - a scheduled task becomes visible in the live summary before it starts
+	*
+	* Expects:
+	* - `taskId` is stable across later lifecycle events
+	*
+	* Returns:
+	* - no direct value
+	*/
+	onTaskQueued(payload) {
+		const task = this.getOrCreateTaskState(payload.taskId);
+		if (task.state === "finished") return;
+		task.displayName = payload.displayName ?? task.displayName;
+		task.projectName = payload.projectName ?? task.projectName;
+		this.syncTaskTotalCases(task, payload.totalCases);
+	}
+	/**
+	* Handles task start events.
+	*
+	* Use when:
+	* - a queued task begins executing
+	*
+	* Expects:
+	* - the task was previously queued or can be synthesized from its identifier
+	*
+	* Returns:
+	* - no direct value
+	*/
+	onTaskStart(payload) {
+		const task = this.getOrCreateTaskState(payload.taskId);
+		if (task.state === "finished") return;
+		task.state = "running";
+		task.startedAt ??= this.options.getNow();
+	}
+	/**
+	* Handles case start events.
+	*
+	* Use when:
+	* - a running task starts one case and slow-case tracking may begin
+	*
+	* Expects:
+	* - `caseId` is stable for the lifetime of the running case
+	*
+	* Returns:
+	* - no direct value
+	*/
+	onCaseStart(payload) {
+		const task = this.getOrCreateTaskState(payload.taskId);
+		if (task.state === "finished") return;
+		task.state = "running";
+		task.startedAt ??= this.options.getNow();
+		if (task.settledCaseIds.has(payload.caseId) || task.runningCases.has(payload.caseId)) return;
+		task.caseOrderCounter += 1;
+		task.runningCases.set(payload.caseId, {
+			caseId: payload.caseId,
+			caseName: payload.caseName ?? payload.caseId,
+			order: task.caseOrderCounter,
+			startedAt: this.options.getNow()
+		});
+		this.syncTaskTotalCases(task);
+	}
+	/**
+	* Handles case completion.
+	*
+	* Use when:
+	* - a running case settles and counters must advance
+	*
+	* Expects:
+	* - duplicate completion for the same `caseId` is ignored
+	*
+	* Returns:
+	* - no direct value
+	*/
+	onCaseEnd(payload) {
+		const task = this.getOrCreateTaskState(payload.taskId);
+		if (task.state === "finished") return;
+		if (task.settledCaseIds.has(payload.caseId)) {
+			task.runningCases.delete(payload.caseId);
+			return;
+		}
+		task.settledCaseIds.add(payload.caseId);
+		task.runningCases.delete(payload.caseId);
+		task.completedCases += 1;
+		this.syncTaskTotalCases(task);
+		this.caseCounters.completed += 1;
+		if (payload.state === "passed") {
+			this.caseCounters.passed += 1;
+			return;
+		}
+		if (payload.state === "failed") {
+			this.caseCounters.failed += 1;
+			return;
+		}
+		this.caseCounters.skipped += 1;
+	}
+	/**
+	* Handles task completion.
+	*
+	* Use when:
+	* - a task leaves the active window and contributes to terminal totals
+	*
+	* Expects:
+	* - duplicate task completion for the same task is ignored
+	*
+	* Returns:
+	* - no direct value
+	*/
+	onTaskEnd(payload) {
+		const task = this.getOrCreateTaskState(payload.taskId);
+		if (task.state === "finished") return;
+		this.syncTaskTotalCases(task);
+		task.state = "finished";
+		task.taskResult = payload.state;
+		task.runningCases.clear();
+		this.taskCounters.completed += 1;
+		if (payload.state === "passed") {
+			this.taskCounters.passed += 1;
+			return;
+		}
+		if (payload.state === "failed") {
+			this.taskCounters.failed += 1;
+			return;
+		}
+		this.taskCounters.skipped += 1;
+	}
+	/**
+	* Handles run completion.
+	*
+	* Use when:
+	* - the caller has final task totals and wants the footer normalized
+	*
+	* Expects:
+	* - payload counters are final terminal task totals
+	*
+	* Returns:
+	* - no direct value
+	*/
+	onRunEnd(payload) {
+		this.taskCounters.total = payload.totalTasks;
+		this.taskCounters.passed = payload.passedTasks;
+		this.taskCounters.failed = payload.failedTasks;
+		this.taskCounters.skipped = payload.skippedTasks;
+		this.taskCounters.completed = payload.passedTasks + payload.failedTasks + payload.skippedTasks;
+	}
+	/**
+	* Releases reporter resources.
+	*
+	* Use when:
+	* - CLI cleanup runs from a `finally` block
+	*
+	* Expects:
+	* - repeated calls are safe
+	*
+	* Returns:
+	* - no direct value
+	*/
+	dispose() {}
+	/**
+	* Builds the current live summary window rows.
+	*
+	* Use when:
+	* - the live reporter or tests need a snapshot of the active window
+	*
+	* Expects:
+	* - `maxRows`, when present, keeps footer rows visible
+	*
+	* Returns:
+	* - terminal rows in display order
+	*/
+	getWindowRows(options) {
+		const activeRows = this.createActiveRows();
+		const footerRows = this.createFooterRows();
+		const maxRows = options?.maxRows;
+		const activeBlock = [
+			"",
+			...activeRows,
+			...activeRows.length > 0 ? [""] : []
+		];
+		const footerBlock = [...footerRows, ""];
+		if (maxRows == null || maxRows <= 0) return [...activeBlock, ...footerBlock];
+		if (maxRows <= footerBlock.length) return footerBlock.slice(-maxRows);
+		const availableActiveRows = Math.max(0, maxRows - footerBlock.length);
+		return [...activeBlock.slice(0, availableActiveRows), ...footerBlock];
+	}
+	createActiveRows() {
+		const activeTasks = Array.from(this.tasks.values()).filter((task) => task.state !== "finished").sort(compareActiveTasks);
+		const rows = [];
+		for (const task of activeTasks) {
+			const suffix = task.state === "queued" ? c.dim(" [queued]") : ` ${task.completedCases}/${task.totalCases}`;
+			const badge = formatProjectBadge(task.projectName, this.options.isTTY);
+			rows.push(c.bold(c.yellow(` ${POINTER} `)) + badge + task.displayName + c.dim(suffix));
+			const slowCases = Array.from(task.runningCases.values()).filter((activeCase) => this.options.getNow() - activeCase.startedAt >= this.options.slowThresholdMs).sort((left, right) => left.order - right.order);
+			for (const [index, activeCase] of slowCases.entries()) {
+				const icon = index === slowCases.length - 1 ? TREE_NODE_END : TREE_NODE_MIDDLE;
+				const elapsed = Math.max(0, this.options.getNow() - activeCase.startedAt);
+				rows.push(c.bold(c.yellow(`   ${icon} `)) + activeCase.caseName + c.bold(c.yellow(` ${formatDuration$1(elapsed)}`)));
+			}
+		}
+		return rows;
+	}
+	createFooterRows() {
+		return [
+			padSummaryTitle("Tasks") + formatCounterState(this.taskCounters),
+			padSummaryTitle("Cases") + formatCounterState(this.caseCounters),
+			padSummaryTitle("Start at") + this.startTime,
+			padSummaryTitle("Duration") + formatDuration$1(Math.max(0, this.options.getNow() - this.startedAtMs))
+		];
+	}
+	getOrCreateTaskState(taskId) {
+		const existing = this.tasks.get(taskId);
+		if (existing != null) return existing;
+		const created = {
+			caseOrderCounter: 0,
+			completedCases: 0,
+			displayName: taskId,
+			projectName: void 0,
+			queueOrder: this.queueOrderCounter,
+			runningCases: /* @__PURE__ */ new Map(),
+			settledCaseIds: /* @__PURE__ */ new Set(),
+			startedAt: void 0,
+			state: "queued",
+			taskId,
+			taskResult: void 0,
+			totalCases: 0
+		};
+		this.queueOrderCounter += 1;
+		this.tasks.set(taskId, created);
+		return created;
+	}
+	syncTaskTotalCases(task, reportedTotalCases) {
+		const observedTotalCases = task.completedCases + task.runningCases.size;
+		task.totalCases = Math.max(task.totalCases, reportedTotalCases ?? 0, observedTotalCases);
+		this.caseCounters.total = sumTaskCaseTotals(this.tasks.values());
+	}
+};
+/**
+* Creates the live summary reporter state machine for `vieval` CLI runs.
+*
+* Use when:
+* - the CLI wants Vitest-style active rows and live counters
+* - tests need a deterministic reporter surface without touching the terminal
+*
+* Expects:
+* - queue/start/end events describe task lifecycle in order
+* - `getNow()` remains monotonic within one run
+* - `getWallClockNow()` returns the wall-clock run start timestamp
+*
+* Returns:
+* - a reporter compatible with the base CLI lifecycle plus `getWindowRows()`
+*
+* Call stack:
+*
+* {@link createSummaryReporter}
+*   -> {@link SummaryReporterStateMachine.onTaskQueued}
+*   -> {@link SummaryReporterStateMachine.onCaseStart}
+*   -> {@link SummaryReporterStateMachine.getWindowRows}
+*/
+function createSummaryReporter(options) {
+	return new SummaryReporterStateMachine(options);
+}
+function createCounterState() {
+	return {
+		completed: 0,
+		failed: 0,
+		passed: 0,
+		skipped: 0,
+		total: 0
+	};
+}
+function resetCounterState(counter, total) {
+	counter.completed = 0;
+	counter.failed = 0;
+	counter.passed = 0;
+	counter.skipped = 0;
+	counter.total = total;
+}
+function sumTaskCaseTotals(tasks) {
+	let total = 0;
+	for (const task of tasks) total += task.totalCases;
+	return total;
+}
+function compareActiveTasks(left, right) {
+	const leftProject = left.projectName ?? "";
+	const rightProject = right.projectName ?? "";
+	if (leftProject !== rightProject) return leftProject.localeCompare(rightProject);
+	const displayNameOrder = left.displayName.localeCompare(right.displayName);
+	if (displayNameOrder !== 0) return displayNameOrder;
+	return left.queueOrder - right.queueOrder;
+}
+function padSummaryTitle(label) {
+	return `${c.dim(label.padEnd(8))} `;
+}
+function formatCounterState(counter) {
+	return [
+		c.bold(c.green(`${counter.passed} passed`)),
+		counter.failed > 0 ? c.bold(c.red(`${counter.failed} failed`)) : c.dim(`${counter.failed} failed`),
+		counter.skipped > 0 ? c.yellow(`${counter.skipped} skipped`) : c.dim(`${counter.skipped} skipped`)
+	].join(c.dim(" | ")) + c.gray(` (${counter.total})`);
+}
+function formatTimeString(date) {
+	return date.toTimeString().split(" ")[0] ?? "";
+}
+function formatDuration$1(durationMs) {
+	if (durationMs >= 1e3) return `${(durationMs / 1e3).toFixed(2)}s`;
+	return `${Math.round(durationMs)}ms`;
+}
+function formatProjectBadge(projectName, isTTY) {
+	if (projectName == null || projectName.length === 0) return "";
+	if (!isTTY || !c.isColorSupported) return `|${projectName}| `;
+	const backgroundPool = [
+		c.bgYellow,
+		c.bgCyan,
+		c.bgGreen,
+		c.bgMagenta
+	];
+	const background = backgroundPool[projectName.split("").reduce((accumulator, character, index) => accumulator + character.charCodeAt(0) + index, 0) % backgroundPool.length];
+	return `${c.black(background(` ${projectName} `))} `;
+}
+//#endregion
+//#region src/cli/reporters/index.ts
+/**
+* Creates the default CLI reporter for the current output mode.
+*
+* Use when:
+* - interactive terminals should use the live summary reporter
+* - non-interactive environments should stay silent with the noop reporter
+*
+* Expects:
+* - `isTTY` decides whether the live summary reporter can be used
+*
+* Returns:
+* - a summary reporter for TTY runs, otherwise a noop reporter
+*/
+function createCliReporter(options) {
+	if (!options.isTTY) return createNoopReporter();
+	return createSummaryReporter(options);
+}
+//#endregion
+//#region src/cli/reporters/renderers/windowed-renderer.ts
+const DEFAULT_RENDER_INTERVAL_MS = 1e3;
+const ESC = "\x1B[";
+const CARRIAGE_RETURN = "\r";
+const CLEAR_LINE = `${ESC}K`;
+const MOVE_CURSOR_ONE_ROW_UP = `${ESC}1A`;
+const SYNC_START = `${ESC}?2026h`;
+const SYNC_END = `${ESC}?2026l`;
+/**
+* Renders a dynamic window at the bottom of the terminal.
+*
+* Use when:
+* - a reporter needs in-place TTY updates without leaking terminal control codes into tests
+* - callers want Vitest-style redraw behavior with injected output/timer dependencies
+*
+* Expects:
+* - `start()` runs before `schedule()`
+* - `finish()` or `dispose()` may be called multiple times safely
+*
+* Returns:
+* - no direct value; all effects are emitted through the injected callbacks
+*
+* Call stack:
+*
+* {@link WindowRenderer.start}
+*   -> periodic schedule callback
+*     -> {@link WindowRenderer.schedule}
+*       -> {@link WindowRenderer.renderWindow}
+*/
+var WindowRenderer = class {
+	options;
+	renderInterval;
+	renderScheduled = false;
+	renderScheduleVersion = 0;
+	windowHeight = 0;
+	started = false;
+	finished = false;
+	bufferedOutput = "";
+	constructor(options) {
+		if (options.createInterval && options.clearInterval) {
+			this.options = {
+				createInterval: (callback, intervalMs) => {
+					const timer = options.createInterval(callback, intervalMs);
+					return {
+						clear: () => options.clearInterval(timer),
+						unref: timer.unref?.bind(timer)
+					};
+				},
+				getColumns: options.getColumns,
+				getWindow: options.getWindow,
+				intervalMs: options.intervalMs ?? DEFAULT_RENDER_INTERVAL_MS,
+				queueRenderReset: options.queueRenderReset ?? defaultQueueRenderReset,
+				supportsAnsiWindowing: options.supportsAnsiWindowing ?? true,
+				writeOutput: options.writeOutput
+			};
+			return;
+		}
+		this.options = {
+			createInterval: defaultCreateInterval,
+			getColumns: options.getColumns,
+			getWindow: options.getWindow,
+			intervalMs: options.intervalMs ?? DEFAULT_RENDER_INTERVAL_MS,
+			queueRenderReset: options.queueRenderReset ?? defaultQueueRenderReset,
+			supportsAnsiWindowing: options.supportsAnsiWindowing ?? true,
+			writeOutput: options.writeOutput
+		};
+	}
+	/**
+	* Starts the periodic refresh loop.
+	*
+	* Use when:
+	* - the live reporter is about to emit in-place updates
+	*
+	* Expects:
+	* - repeated calls are harmless and keep the existing timer
+	*
+	* Returns:
+	* - no direct value
+	*/
+	start() {
+		if (this.started && !this.finished) return;
+		this.started = true;
+		this.finished = false;
+		this.renderScheduleVersion += 1;
+		if (!this.renderInterval) {
+			this.renderInterval = this.options.createInterval(() => this.schedule(), this.options.intervalMs);
+			this.renderInterval.unref?.();
+		}
+	}
+	/**
+	* Queues a render if one is not already in flight.
+	*
+	* Use when:
+	* - reporter state changes and the bottom window should refresh
+	*
+	* Expects:
+	* - the renderer has been started
+	*
+	* Returns:
+	* - no direct value
+	*/
+	schedule() {
+		if (!this.started || this.finished || this.renderScheduled) return;
+		const renderScheduleVersion = this.renderScheduleVersion;
+		this.renderScheduled = true;
+		this.renderWindow();
+		this.options.queueRenderReset(() => {
+			if (this.renderScheduleVersion !== renderScheduleVersion) return;
+			this.renderScheduled = false;
+		});
+	}
+	/**
+	* Clears the rendered window and stops the refresh loop.
+	*
+	* Use when:
+	* - the live reporter is transitioning to final static output
+	*
+	* Expects:
+	* - repeated calls are safe
+	*
+	* Returns:
+	* - no direct value
+	*/
+	finish() {
+		if (this.finished) return;
+		this.finished = true;
+		this.started = false;
+		this.renderScheduleVersion += 1;
+		this.renderScheduled = false;
+		this.stopInterval();
+		this.clearWindow();
+		this.flushBufferedOutput();
+	}
+	/**
+	* Stops the renderer and clears any visible window state.
+	*
+	* Use when:
+	* - cleanup needs to happen from a `finally` block or interrupted run
+	*
+	* Expects:
+	* - callers may invoke it more than once
+	*
+	* Returns:
+	* - no direct value
+	*/
+	dispose() {
+		this.finish();
+	}
+	/**
+	* Alias for disposal to match Vitest's renderer lifecycle naming.
+	*
+	* Use when:
+	* - adapting code that expects `stop()`
+	*
+	* Expects:
+	* - callers want the same semantics as `dispose()`
+	*
+	* Returns:
+	* - no direct value
+	*/
+	stop() {
+		this.dispose();
+	}
+	/**
+	* Writes reporter output through the renderer lifecycle.
+	*
+	* Use when:
+	* - emitting log lines that must appear above the live ANSI window
+	* - callers need deterministic buffering behavior in tests
+	*
+	* Expects:
+	* - active ANSI window mode buffers until `schedule()` or `finish()`
+	* - inactive or non-windowed mode writes directly
+	*
+	* Returns:
+	* - no direct value
+	*/
+	write(message) {
+		if (!this.isActiveWindowMode()) {
+			this.writeOutput(message);
+			return;
+		}
+		this.bufferedOutput += message;
+	}
+	renderWindow() {
+		const windowContent = this.options.getWindow();
+		const rowCount = getRenderedRowCount(windowContent, this.options.getColumns());
+		if (this.options.supportsAnsiWindowing) {
+			this.writeOutput(SYNC_START);
+			this.clearWindow();
+		}
+		this.flushBufferedOutput();
+		this.writeOutput(windowContent.join("\n"));
+		if (this.options.supportsAnsiWindowing) {
+			this.writeOutput(SYNC_END);
+			this.windowHeight = rowCount;
+			return;
+		}
+		this.writeOutput("\n");
+		this.windowHeight = 0;
+	}
+	clearWindow() {
+		if (!this.options.supportsAnsiWindowing || this.windowHeight === 0) return;
+		this.writeOutput(`${CARRIAGE_RETURN}${CLEAR_LINE}`);
+		for (let rowIndex = 1; rowIndex < this.windowHeight; rowIndex += 1) this.writeOutput(`${CARRIAGE_RETURN}${MOVE_CURSOR_ONE_ROW_UP}${CLEAR_LINE}`);
+		this.windowHeight = 0;
+	}
+	stopInterval() {
+		if (!this.renderInterval) return;
+		this.renderInterval.clear();
+		this.renderInterval = void 0;
+	}
+	writeOutput(message) {
+		this.options.writeOutput(message);
+	}
+	flushBufferedOutput() {
+		if (this.bufferedOutput.length === 0) return;
+		this.writeOutput(this.bufferedOutput);
+		this.bufferedOutput = "";
+	}
+	isActiveWindowMode() {
+		return this.started && !this.finished && this.options.supportsAnsiWindowing;
+	}
+};
+function defaultCreateInterval(callback, intervalMs) {
+	const timer = globalThis.setInterval(callback, intervalMs);
+	return {
+		clear: () => globalThis.clearInterval(timer),
+		unref: timer.unref?.bind(timer)
+	};
+}
+function defaultQueueRenderReset(callback) {
+	setTimeout(callback, 100).unref();
+}
+/** Calculate the rendered row count for the supplied rows and terminal width. */
+function getRenderedRowCount(rows, columns) {
+	const safeColumns = Math.max(1, columns);
+	let count = 0;
+	for (const row of rows) {
+		const text = stripVTControlCharacters(row);
+		count += Math.max(1, Math.ceil(getTextDisplayWidth(text) / safeColumns));
+	}
+	return count;
+}
+function getTextDisplayWidth(text) {
+	return stringWidth(stripVTControlCharacters(text));
+}
+//#endregion
+//#region src/cli/run.ts
+function shouldUseColor() {
+	if (process.env.NO_COLOR != null) return false;
+	const forceColor = process.env.FORCE_COLOR;
+	if (forceColor != null) return forceColor !== "0";
+	return process.stdout.isTTY === true;
+}
+function createColorPalette(enabled) {
+	if (!enabled) return {
+		black: (value) => value,
+		bgCyan: (value) => value,
+		bgGreen: (value) => value,
+		bgMagenta: (value) => value,
+		bgYellow: (value) => value,
+		dim: (value) => value,
+		gray: (value) => value,
+		green: (value) => value,
+		red: (value) => value,
+		yellow: (value) => value
+	};
+	return {
+		black: (value) => c.black(value),
+		bgCyan: (value) => c.bgCyan(value),
+		bgGreen: (value) => c.bgGreen(value),
+		bgMagenta: (value) => c.bgMagenta(value),
+		bgYellow: (value) => c.bgYellow(value),
+		dim: (value) => c.dim(value),
+		gray: (value) => c.gray(value),
+		green: (value) => c.green(value),
+		red: (value) => c.red(value),
+		yellow: (value) => c.yellow(value)
+	};
+}
+function createProjectBadge(name, colors, colorEnabled) {
+	if (!colorEnabled || !c.isColorSupported) return `|${name}| `;
+	const labelColorPool = [
+		colors.bgYellow,
+		colors.bgCyan,
+		colors.bgGreen,
+		colors.bgMagenta
+	];
+	const background = labelColorPool[name.split("").reduce((accumulator, char, index) => accumulator + char.charCodeAt(0) + index, 0) % labelColorPool.length];
+	return `${colors.black(background(` ${name} `))} `;
+}
+function formatDuration(durationMs, colors) {
+	if (durationMs == null) return "";
+	const rounded = Math.round(durationMs);
+	return (rounded > 1e3 ? colors.yellow : colors.green)(` ${rounded}${colors.dim("ms")}`);
+}
+async function loadEvalModules(evalFilePaths) {
+	const loadedModules = {};
+	for (const [moduleIndex, evalFilePath] of evalFilePaths.entries()) {
+		const moduleHref = pathToFileURL(evalFilePath).href;
+		const importHref = `${moduleHref}?vieval_load=${Date.now()}_${moduleIndex}`;
+		beginModuleRegistration(importHref);
+		try {
+			const moduleValue = await import(importHref);
+			const registeredDefinitions = consumeModuleRegistrations(importHref);
+			const defaultDefinition = moduleValue.default;
+			const definitions = [...registeredDefinitions, ...defaultDefinition == null ? [] : [defaultDefinition]];
+			const deduplicatedDefinitions = definitions.filter((definition, index) => {
+				const key = `${definition.name}::${definition.description}::${definition.task?.id ?? ""}`;
+				return definitions.findIndex((candidate) => `${candidate.name}::${candidate.description}::${candidate.task?.id ?? ""}` === key) === index;
+			});
+			if (deduplicatedDefinitions.length === 0) continue;
+			for (const [definitionIndex, definition] of deduplicatedDefinitions.entries()) {
+				const moduleKey = definitionIndex === 0 ? moduleHref : `${moduleHref}#registration-${definitionIndex + 1}`;
+				loadedModules[moduleKey] = { default: definition };
+			}
+		} finally {
+			endModuleRegistration();
+		}
+	}
+	return loadedModules;
+}
+function filterProjectsByName(projects, names) {
+	if (names.length === 0) return [...projects];
+	const nameSet = new Set(names);
+	return projects.filter((project) => nameSet.has(project.name));
+}
+function applyRunEnvironment(env) {
+	const envEntries = Object.entries(env);
+	if (envEntries.length === 0) return () => {};
+	const snapshot = /* @__PURE__ */ new Map();
+	for (const [key, value] of envEntries) {
+		snapshot.set(key, {
+			existed: Object.hasOwn(process.env, key),
+			value: process.env[key]
+		});
+		if (value == null) {
+			delete process.env[key];
+			continue;
+		}
+		process.env[key] = value;
+	}
+	return () => {
+		for (const [key, previous] of snapshot.entries()) {
+			if (previous.existed) {
+				if (previous.value == null) {
+					delete process.env[key];
+					continue;
+				}
+				process.env[key] = previous.value;
+				continue;
+			}
+			delete process.env[key];
+		}
+	};
+}
+function isSummaryReporter(reporter) {
+	return "getWindowRows" in reporter;
+}
+function createRunReporter(options) {
+	const reporter = createCliReporter({
+		getColumns: options?.getColumns ?? (() => process.stdout.columns ?? 80),
+		getNow: options?.getNow ?? (() => Date.now()),
+		getWallClockNow: options?.getWallClockNow ?? (() => Date.now()),
+		isTTY: options?.isTTY ?? process.stdout.isTTY === true,
+		slowThresholdMs: options?.slowThresholdMs ?? 300,
+		writeError: options?.writeError ?? ((value) => process.stderr.write(value)),
+		writeOutput: options?.writeOutput ?? ((value) => process.stdout.write(value))
+	});
+	if (!isSummaryReporter(reporter)) return {
+		...reporter,
+		onCaseStart(payload) {
+			reporter.onCaseStart(payload);
+		},
+		onTaskQueued(payload) {
+			reporter.onTaskQueued(payload);
+		}
+	};
+	const rendererBaseOptions = {
+		getColumns: options?.getColumns ?? (() => process.stdout.columns ?? 80),
+		getWindow: () => reporter.getWindowRows(),
+		queueRenderReset: options?.queueRenderReset,
+		supportsAnsiWindowing: options?.supportsAnsiWindowing,
+		writeOutput: options?.writeOutput ?? ((value) => process.stdout.write(value))
+	};
+	const renderer = options?.clearInterval != null && options.createInterval != null ? new WindowRenderer({
+		...rendererBaseOptions,
+		clearInterval: options.clearInterval,
+		createInterval: options.createInterval
+	}) : new WindowRenderer(rendererBaseOptions);
+	renderer.start();
+	function scheduleRender() {
+		renderer.schedule();
+	}
+	return {
+		dispose() {
+			reporter.dispose();
+			renderer.dispose();
+		},
+		onCaseEnd(payload) {
+			reporter.onCaseEnd(payload);
+			scheduleRender();
+		},
+		onCaseStart(payload) {
+			reporter.onCaseStart(payload);
+			scheduleRender();
+		},
+		onRunEnd(payload) {
+			reporter.onRunEnd(payload);
+			scheduleRender();
+		},
+		onRunStart(payload) {
+			reporter.onRunStart(payload);
+			scheduleRender();
+		},
+		onTaskEnd(payload) {
+			reporter.onTaskEnd(payload);
+			scheduleRender();
+		},
+		onTaskQueued(payload) {
+			reporter.onTaskQueued(payload);
+			scheduleRender();
+		},
+		onTaskStart(payload) {
+			reporter.onTaskStart(payload);
+			scheduleRender();
+		}
+	};
+}
+function createTaskQueuePayload(task, projectName) {
+	return {
+		displayName: task.entry.name,
+		projectName,
+		taskId: task.id
+	};
+}
+function createTaskCaseReporterId(payload) {
+	return `${payload.index}:${encodeURIComponent(payload.name)}`;
+}
+function createTaskReporterHooks(task, reporter, projectCaseCounters) {
+	function syncCaseTotal(total) {
+		reporter.onTaskQueued({
+			taskId: task.id,
+			totalCases: total
+		});
+	}
+	return {
+		onCaseEnd(payload) {
+			const caseId = createTaskCaseReporterId(payload);
+			if (projectCaseCounters != null) {
+				const projectCaseId = `${task.id}:${caseId}`;
+				if (!projectCaseCounters.seenCaseIds.has(projectCaseId)) {
+					projectCaseCounters.seenCaseIds.add(projectCaseId);
+					if (payload.state === "passed") projectCaseCounters.passed += 1;
+					else if (payload.state === "failed") projectCaseCounters.failed += 1;
+					else projectCaseCounters.skipped += 1;
+				}
+			}
+			syncCaseTotal(payload.total);
+			reporter.onCaseEnd({
+				caseId,
+				state: payload.state,
+				taskId: task.id
+			});
+		},
+		onCaseStart(payload) {
+			const caseId = createTaskCaseReporterId(payload);
+			syncCaseTotal(payload.total);
+			reporter.onCaseStart({
+				caseId,
+				caseName: payload.name,
+				taskId: task.id
+			});
+		}
+	};
+}
+function createCliTaskExecutionContext(task, models, reporter, projectCaseCounters) {
+	return {
+		...createTaskExecutionContext({
+			models,
+			task
+		}),
+		reporterHooks: createTaskReporterHooks(task, reporter, projectCaseCounters)
+	};
+}
+function resolveTaskReporterHooks(task, context, reporter, projectCaseCounters) {
+	return context.reporterHooks ?? createTaskReporterHooks(task, reporter, projectCaseCounters);
+}
+function getFailedTaskId(error) {
+	if (error instanceof RunnerExecutionError) return error.taskId;
+	return null;
+}
+function createAutoTaskExecutor(reporter, projectCaseCounters) {
+	return async (task, context) => {
+		const taskDefinition = task.entry.task;
+		if (taskDefinition == null) throw new Error(`Missing eval task definition for entry "${task.entry.id}".`);
+		const output = await taskDefinition.run({
+			model: context.model,
+			reporterHooks: resolveTaskReporterHooks(task, context, reporter, projectCaseCounters),
+			task
+		});
+		return {
+			entryId: task.entry.id,
+			id: task.id,
+			matrix: task.matrix,
+			inferenceExecutorId: task.inferenceExecutor.id,
+			scores: [...output.scores]
+		};
+	};
+}
+function cloneScheduledTaskMatrix(task) {
+	return {
+		eval: { ...task.matrix.eval },
+		meta: { ...task.matrix.meta },
+		run: { ...task.matrix.run }
+	};
+}
+function createProjectMatrixSummary(tasks) {
+	if (tasks.length === 0) return null;
+	const runAxes = /* @__PURE__ */ new Set();
+	const evalAxes = /* @__PURE__ */ new Set();
+	const runRows = /* @__PURE__ */ new Set();
+	const evalRows = /* @__PURE__ */ new Set();
+	for (const task of tasks) {
+		Object.keys(task.matrix.run).forEach((axis) => runAxes.add(axis));
+		Object.keys(task.matrix.eval).forEach((axis) => evalAxes.add(axis));
+		runRows.add(task.matrix.meta.runRowId);
+		evalRows.add(task.matrix.meta.evalRowId);
+	}
+	return {
+		evalAxes: [...evalAxes].sort(),
+		evalRows: evalRows.size,
+		runAxes: [...runAxes].sort(),
+		runRows: runRows.size
+	};
+}
+async function prepareProject(project) {
+	const startedAt = Date.now();
+	try {
+		const runtimeContext = await createRunnerRuntimeContext({
+			cwd: project.root,
+			fallbackProjectRootDirectory: project.root
+		});
+		const evalFilePaths = await discoverEvalFiles({
+			exclude: project.exclude,
+			include: project.include,
+			root: project.root
+		});
+		const entries = collectEvalEntries(await loadEvalModules(evalFilePaths), runtimeContext);
+		const tasks = createRunnerSchedule({
+			evalMatrix: project.evalMatrix,
+			entries,
+			inferenceExecutors: project.inferenceExecutors,
+			runMatrix: project.runMatrix
+		});
+		const canAutoExecuteEntryTasks = entries.some((entry) => entry.task != null) && project.models.length > 0;
+		if (project.executor == null && !canAutoExecuteEntryTasks) return {
+			kind: "summary",
+			summary: {
+				caseSummary: null,
+				discoveredEvalFileCount: evalFilePaths.length,
+				durationMs: Date.now() - startedAt,
+				entryCount: entries.length,
+				errorMessage: null,
+				executed: false,
+				matrixSummary: createProjectMatrixSummary(tasks),
+				name: project.name,
+				result: null,
+				taskCount: tasks.length
+			}
+		};
+		return {
+			kind: "prepared",
+			prepared: {
+				discoveredEvalFileCount: evalFilePaths.length,
+				entryCount: entries.length,
+				name: project.name,
+				project,
+				startedAt,
+				tasks
+			}
+		};
+	} catch (error) {
+		return {
+			kind: "summary",
+			summary: {
+				caseSummary: null,
+				discoveredEvalFileCount: 0,
+				durationMs: Date.now() - startedAt,
+				entryCount: 0,
+				errorMessage: errorMessageFrom(error) ?? "Unknown project execution error.",
+				executed: false,
+				matrixSummary: null,
+				name: project.name,
+				result: null,
+				taskCount: 0
+			}
+		};
+	}
+}
+async function executePreparedProject(prepared, reporter, counters) {
+	const settledTaskIds = /* @__PURE__ */ new Set();
+	const projectCaseCounters = {
+		failed: 0,
+		passed: 0,
+		seenCaseIds: /* @__PURE__ */ new Set(),
+		skipped: 0
+	};
+	const rawTaskExecutor = prepared.project.executor ?? createAutoTaskExecutor(reporter, projectCaseCounters);
+	const taskExecutor = async (task, context) => {
+		return {
+			...await rawTaskExecutor(task, context),
+			matrix: cloneScheduledTaskMatrix(task)
+		};
+	};
+	try {
+		const aggregated = await runScheduledTasks(prepared.tasks, taskExecutor, {
+			createExecutionContext(task) {
+				return createCliTaskExecutionContext(task, prepared.project.models, reporter, projectCaseCounters);
+			},
+			onTaskEnd(task, state) {
+				settledTaskIds.add(task.id);
+				reporter.onTaskEnd({
+					state,
+					taskId: task.id
+				});
+				if (state === "passed") {
+					counters.passedTasks += 1;
+					return;
+				}
+				counters.failedTasks += 1;
+			},
+			onTaskStart(task) {
+				reporter.onTaskStart({ taskId: task.id });
+			}
+		});
+		return {
+			caseSummary: {
+				failed: projectCaseCounters.failed,
+				passed: projectCaseCounters.passed,
+				skipped: projectCaseCounters.skipped,
+				total: projectCaseCounters.seenCaseIds.size
+			},
+			discoveredEvalFileCount: prepared.discoveredEvalFileCount,
+			durationMs: Date.now() - prepared.startedAt,
+			entryCount: prepared.entryCount,
+			errorMessage: null,
+			executed: true,
+			matrixSummary: createProjectMatrixSummary(prepared.tasks),
+			name: prepared.name,
+			result: aggregated,
+			taskCount: prepared.tasks.length
+		};
+	} catch (error) {
+		const failedTaskId = getFailedTaskId(error);
+		if (failedTaskId != null && !settledTaskIds.has(failedTaskId)) {
+			counters.failedTasks += 1;
+			settledTaskIds.add(failedTaskId);
+			reporter.onTaskEnd({
+				state: "failed",
+				taskId: failedTaskId
+			});
+		}
+		for (const task of prepared.tasks) {
+			if (settledTaskIds.has(task.id)) continue;
+			counters.skippedTasks += 1;
+			settledTaskIds.add(task.id);
+			reporter.onTaskEnd({
+				state: "skipped",
+				taskId: task.id
+			});
+		}
+		return {
+			caseSummary: {
+				failed: projectCaseCounters.failed,
+				passed: projectCaseCounters.passed,
+				skipped: projectCaseCounters.skipped,
+				total: projectCaseCounters.seenCaseIds.size
+			},
+			discoveredEvalFileCount: prepared.discoveredEvalFileCount,
+			durationMs: Date.now() - prepared.startedAt,
+			entryCount: prepared.entryCount,
+			errorMessage: errorMessageFrom(error) ?? "Unknown project execution error.",
+			executed: false,
+			matrixSummary: createProjectMatrixSummary(prepared.tasks),
+			name: prepared.name,
+			result: null,
+			taskCount: prepared.tasks.length
+		};
+	}
+}
+/**
+* Runs vieval orchestration from config and returns project-level summaries.
+*
+* Call stack:
+*
+* {@link runVievalCli}
+*   -> {@link loadVievalCliConfig}
+*   -> {@link discoverEvalFiles}
+*   -> {@link collectEvalEntries}
+*   -> {@link createRunnerSchedule}
+*   -> {@link runScheduledTasks} (optional)
+*
+* Use when:
+* - running eval collection and scheduling from a single command
+* - keeping business-agent eval files near their implementation packages
+*/
+async function runVievalCli(options = {}) {
+	const loadedConfig = await loadVievalCliConfig({
+		configFilePath: options.configFilePath,
+		cwd: options.cwd
+	});
+	const restoreEnvironment = applyRunEnvironment(loadedConfig.env);
+	const reporter = createRunReporter(options.reporter);
+	try {
+		const selectedProjects = filterProjectsByName(loadedConfig.projects, options.project ?? []);
+		const preparedProjects = await Promise.all(selectedProjects.map(async (project) => prepareProject(project)));
+		const executableProjects = preparedProjects.filter((project) => project.kind === "prepared").map((project) => project.prepared);
+		const totalTasks = preparedProjects.reduce((sum, project) => {
+			if (project.kind === "prepared") return sum + project.prepared.tasks.length;
+			return sum + project.summary.taskCount;
+		}, 0);
+		const skippedSummaryTasks = preparedProjects.reduce((sum, project) => {
+			if (project.kind === "summary") return sum + project.summary.taskCount;
+			return sum;
+		}, 0);
+		const reporterCounters = {
+			failedTasks: 0,
+			passedTasks: 0,
+			skippedTasks: 0
+		};
+		reporter.onRunStart({ totalTasks });
+		for (const project of executableProjects) for (const task of project.tasks) reporter.onTaskQueued(createTaskQueuePayload(task, project.name));
+		const projectSummaries = [];
+		for (const preparedProject of preparedProjects) {
+			if (preparedProject.kind === "summary") {
+				projectSummaries.push(preparedProject.summary);
+				continue;
+			}
+			projectSummaries.push(await executePreparedProject(preparedProject.prepared, reporter, reporterCounters));
+		}
+		reporter.onRunEnd({
+			failedTasks: reporterCounters.failedTasks,
+			passedTasks: reporterCounters.passedTasks,
+			skippedTasks: reporterCounters.skippedTasks + skippedSummaryTasks,
+			totalTasks
+		});
+		return {
+			configFilePath: loadedConfig.configFilePath,
+			projects: projectSummaries
+		};
+	} finally {
+		reporter.dispose();
+		restoreEnvironment();
+	}
+}
+/**
+* Formats CLI run output as human-readable lines.
+*/
+function formatVievalCliRunOutput(output) {
+	const colorEnabled = shouldUseColor();
+	const colors = createColorPalette(colorEnabled);
+	const lines = [];
+	lines.push(` ${colors.dim("RUN")}  ${colors.yellow("vieval")}`);
+	lines.push(` ${colors.dim("Config")}  ${output.configFilePath ?? "(not found, using defaults)"}`);
+	lines.push("");
+	let passedProjects = 0;
+	let skippedProjects = 0;
+	let failedProjects = 0;
+	let totalTasks = 0;
+	let executedTasks = 0;
+	function formatMatrixSummary(summary) {
+		if (summary == null) return null;
+		const runAxesLabel = summary.runAxes.length === 0 ? "-" : summary.runAxes.join("|");
+		const evalAxesLabel = summary.evalAxes.length === 0 ? "-" : summary.evalAxes.join("|");
+		return `matrix run ${summary.runRows} [${runAxesLabel}] / eval ${summary.evalRows} [${evalAxesLabel}]`;
+	}
+	function formatScheduleBreakdown(project) {
+		const summary = project.matrixSummary;
+		if (summary == null) return null;
+		if (project.taskCount <= 0 || project.entryCount <= 0 || summary.runRows <= 0 || summary.evalRows <= 0) return null;
+		const denominator = project.entryCount * summary.runRows * summary.evalRows;
+		if (denominator <= 0 || project.taskCount % denominator !== 0) return null;
+		const providerCount = project.taskCount / denominator;
+		return [
+			colors.dim("schedule "),
+			colors.yellow(String(project.entryCount)),
+			colors.dim(" entries × "),
+			colors.yellow(String(providerCount)),
+			colors.dim(" inferenceExecutors × "),
+			colors.yellow(String(summary.runRows)),
+			colors.dim(" run rows × "),
+			colors.yellow(String(summary.evalRows)),
+			colors.dim(" eval rows = "),
+			colors.green(String(project.taskCount)),
+			colors.dim(" tasks")
+		].join("");
+	}
+	for (const project of output.projects) {
+		totalTasks += project.taskCount;
+		executedTasks += project.result?.overall.runCount ?? 0;
+		const badge = createProjectBadge(project.name, colors, colorEnabled);
+		if (project.errorMessage != null) {
+			failedProjects += 1;
+			lines.push(` ${colors.red("❯")} ${badge}${formatDuration(project.durationMs, colors)}`);
+			lines.push(`   ${project.errorMessage}`);
+			continue;
+		}
+		if (!project.executed) {
+			skippedProjects += 1;
+			const countLabel = colors.dim(`(${project.taskCount} tasks)`);
+			const detailsLabel = colors.dim(` ${project.discoveredEvalFileCount} files, ${project.entryCount} entries, 0 runs, hybrid n/a`);
+			const matrixSummary = formatMatrixSummary(project.matrixSummary);
+			lines.push(` ${colors.dim("○")} ${badge}${countLabel}${detailsLabel}${formatDuration(project.durationMs, colors)}`);
+			if (matrixSummary != null) lines.push(`   ${colors.dim(matrixSummary)}`);
+			const scheduleBreakdown = formatScheduleBreakdown(project);
+			if (scheduleBreakdown != null) lines.push(`   ${scheduleBreakdown}`);
+			continue;
+		}
+		passedProjects += 1;
+		const hybridAverage = project.result?.overall.hybridAverage;
+		const hybridAverageLabel = hybridAverage == null ? "n/a" : String(hybridAverage);
+		const runCount = project.result?.overall.runCount ?? 0;
+		const countLabel = colors.dim(`(${project.taskCount} tasks)`);
+		const caseSummaryLabel = project.caseSummary == null ? "" : `, cases ${project.caseSummary.passed} passed | ${project.caseSummary.failed} failed`;
+		const detailsLabel = colors.dim(` ${project.discoveredEvalFileCount} files, ${project.entryCount} entries, ${runCount} runs${caseSummaryLabel}, hybrid ${hybridAverageLabel}`);
+		const matrixSummary = formatMatrixSummary(project.matrixSummary);
+		lines.push(` ${colors.green("✓")} ${badge}${countLabel}${detailsLabel}${formatDuration(project.durationMs, colors)}`);
+		if (matrixSummary != null) lines.push(`   ${colors.dim(matrixSummary)}`);
+		const scheduleBreakdown = formatScheduleBreakdown(project);
+		if (scheduleBreakdown != null) lines.push(`   ${scheduleBreakdown}`);
+	}
+	lines.push("");
+	if (failedProjects > 0 || skippedProjects > 0) {
+		const summarySegments = [`${colors.green(String(passedProjects))} passed`];
+		if (skippedProjects > 0) summarySegments.push(`${colors.dim(String(skippedProjects))} skipped`);
+		if (failedProjects > 0) summarySegments.push(`${colors.red(String(failedProjects))} failed`);
+		lines.push(` ${colors.dim("Projects")}  ${summarySegments.join(" | ")} (${output.projects.length})`);
+	} else lines.push(` ${colors.dim("Projects")}  ${colors.green(String(passedProjects))} passed (${output.projects.length})`);
+	lines.push(` ${colors.dim("Tasks")}     ${executedTasks} executed / ${totalTasks} scheduled`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/cli/eval-run.ts
+const evalRunHelpText = `
+  Execute vieval projects from discovered or explicit config.
+
+  Usage
+    $ vieval run [--config <path>] [--project <name>] [--json]
+
+  Options
+    --config     Config file path
+    --project    Project name to execute; may be repeated
+    --json       Print machine-readable JSON output
+`;
+function normalizeCliArgv$1(argv) {
+	const normalizedArgv = argv[0] === "--" ? argv.slice(1) : [...argv];
+	return normalizedArgv[0] === "run" ? normalizedArgv.slice(1) : normalizedArgv;
+}
+function normalizeProjectNames(projectNames) {
+	if (typeof projectNames === "string") return [projectNames];
+	return projectNames ?? [];
+}
+function parseCliArguments(argv) {
+	const cli = meow(evalRunHelpText, {
+		argv: normalizeCliArgv$1(argv),
+		importMeta: import.meta,
+		flags: {
+			config: { type: "string" },
+			json: {
+				default: false,
+				type: "boolean"
+			},
+			project: {
+				isMultiple: true,
+				type: "string"
+			}
+		}
+	});
+	return {
+		configFilePath: cli.flags.config,
+		json: cli.flags.json === true,
+		project: normalizeProjectNames(cli.flags.project)
+	};
+}
+function isDirectExecution$1() {
+	if (!process.argv[1]) return false;
+	return path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+}
+/**
+* CLI entrypoint for `vieval run`.
+*
+* Call stack:
+*
+* {@link main}
+*   -> {@link parseCliArguments}(`process.argv`)
+*   -> {@link runVievalCli}
+*   -> `process.stdout.write(...)` / `process.stderr.write(...)`
+*   -> `process.exitCode`
+*
+* Use when:
+* - developers want project-style eval discovery and execution from one command
+* - manual `import.meta.glob` and runner wiring should stay internal
+*/
+async function main$1() {
+	const parsed = parseCliArguments(process.argv.slice(2));
+	try {
+		const output = await runVievalCli({
+			configFilePath: parsed.configFilePath,
+			project: parsed.project
+		});
+		if (parsed.json) {
+			process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+			return;
+		}
+		process.stdout.write(`${formatVievalCliRunOutput(output)}\n`);
+	} catch (error) {
+		const errorMessage = errorMessageFrom(error) ?? "Unknown CLI failure.";
+		process.stderr.write(`[${name}] ${errorMessage}\n`);
+		process.exitCode = 1;
+	}
+}
+if (isDirectExecution$1()) await main$1();
+//#endregion
+//#region src/cli/index.ts
+const topLevelHelpText = `
+  Execute and report evaluation projects.
+
+  Usage
+    $ vieval <command> [options]
+
+  Commands
+    run            Discover and execute eval projects
+
+  Examples
+    $ vieval run
+    $ vieval run --config vieval.config.ts --project chess --json
+`;
+function normalizeCliArgv(argv) {
+	return argv[0] === "--" ? argv.slice(1) : [...argv];
+}
+function parseTopLevelCliArguments(argv) {
+	const normalizedArgv = normalizeCliArgv(argv);
+	const command = normalizedArgv[0];
+	meow(topLevelHelpText, {
+		autoHelp: false,
+		autoVersion: false,
+		argv: normalizedArgv,
+		importMeta: import.meta
+	});
+	if (command == null || command === "help" || command === "--help" || command === "-h") return {
+		command: "help",
+		commandArgv: []
+	};
+	if (command !== "run") throw new Error(`Unsupported vieval command "${command ?? "(none)"}". Expected "run".`);
+	return {
+		command,
+		commandArgv: normalizedArgv.slice(1)
+	};
+}
+async function runTopLevelCli(argv) {
+	const parsed = parseTopLevelCliArguments(argv);
+	if (parsed.command === "help") {
+		process.stdout.write(`${topLevelHelpText.trim()}\n`);
+		return;
+	}
+	const runArguments = parseCliArguments(parsed.commandArgv);
+	const output = await runVievalCli({
+		configFilePath: runArguments.configFilePath,
+		project: runArguments.project
+	});
+	if (runArguments.json) {
+		process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+		return;
+	}
+	process.stdout.write(`${formatVievalCliRunOutput(output)}\n`);
+}
+function isDirectExecution() {
+	if (!process.argv[1]) return false;
+	return path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+}
+async function main() {
+	try {
+		await runTopLevelCli(process.argv.slice(2));
+	} catch (error) {
+		const errorMessage = errorMessageFrom(error) ?? "Unknown CLI failure.";
+		process.stderr.write(`[vieval] ${errorMessage}\n`);
+		process.exitCode = 1;
+	}
+}
+if (isDirectExecution()) await main();
+//#endregion
+export { parseTopLevelCliArguments, runTopLevelCli };
+
+//# sourceMappingURL=index.mjs.map