vieval 0.0.3 → 0.0.5

package/dist/runner-Dpy-eivM.mjs

@@ -1,636 +0,0 @@
-import { t as resolveModelByName } from "./models-DIGdOUpJ.mjs";
-import { createRequire } from "node:module";
-import process from "node:process";
-import { access, mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { basename, dirname, join, relative } from "node:path";
-import { fileURLToPath } from "node:url";
-import { errorMessageFrom } from "@moeru/std";
-import { createReadStream, createWriteStream } from "node:fs";
-import { Buffer } from "node:buffer";
-import { limitConcurrency } from "@vitest/runner/utils";
-//#region src/core/cache/filesystem.ts
-function sanitizePathSegment(value) {
-	const normalized = value.trim();
-	if (normalized.length === 0) return "default";
-	return normalized.replace(/[^\w.-]+/g, "-");
-}
-function normalizeExtension(extension, mediaType) {
-	if (extension != null && extension.length > 0) return extension.startsWith(".") ? extension.slice(1) : extension;
-	if (mediaType == null || mediaType.length === 0) return;
-	if (mediaType === "application/json") return "json";
-	if (mediaType === "text/plain") return "txt";
-	if (mediaType === "audio/wav") return "wav";
-}
-/**
-* Normalizes cache file options into deterministic relative path segments.
-*
-* Before:
-* - `{ key: ['cases', 'dataset hash', 'v1'], ext: 'json' }`
-*
-* After:
-* - `['cases', 'dataset-hash', 'v1.json']`
-*/
-function normalizeCacheFilePathSegments(options) {
-	const sanitizedKey = options.key.map((segment) => sanitizePathSegment(segment));
-	const extension = normalizeExtension(options.ext, options.mediaType);
-	if (sanitizedKey.length === 0) return extension == null ? ["artifact"] : [`artifact.${extension}`];
-	if (extension == null) return sanitizedKey;
-	const withoutTail = sanitizedKey.slice(0, Math.max(0, sanitizedKey.length - 1));
-	const tail = sanitizedKey[sanitizedKey.length - 1] ?? "artifact";
-	return [...withoutTail, `${tail}.${extension}`];
-}
-async function writeAtomically(path, content) {
-	const directory = dirname(path);
-	const temporaryPath = `${path}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
-	await mkdir(directory, { recursive: true });
-	await writeFile(temporaryPath, content);
-	await rename(temporaryPath, path);
-}
-function createCacheFileHandle(path) {
-	return {
-		path,
-		async exists() {
-			try {
-				await access(path);
-				return true;
-			} catch {
-				return false;
-			}
-		},
-		openReadStream() {
-			return createReadStream(path);
-		},
-		async openWriteStream() {
-			await mkdir(dirname(path), { recursive: true });
-			return createWriteStream(path);
-		},
-		async readBuffer() {
-			return await readFile(path);
-		},
-		async writeBuffer(value) {
-			await writeAtomically(path, value);
-		},
-		async readText(encoding = "utf-8") {
-			return await readFile(path, encoding);
-		},
-		async writeText(value, encoding = "utf-8") {
-			await writeAtomically(path, Buffer.from(value, encoding));
-		},
-		async readJson() {
-			return JSON.parse(await readFile(path, "utf-8"));
-		},
-		async writeJson(value) {
-			await writeAtomically(path, `${JSON.stringify(value, null, 2)}\n`);
-		},
-		async loadAsCasesInput() {
-			return await this.readJson();
-		},
-		async loadAsExpectFixture() {
-			return await this.readJson();
-		}
-	};
-}
-function createCacheNamespace(baseDirectory, namespace) {
-	return { file(options) {
-		const relativePathSegments = normalizeCacheFilePathSegments(options);
-		return createCacheFileHandle(join(baseDirectory, sanitizePathSegment(namespace), ...relativePathSegments));
-	} };
-}
-/**
-* Creates a deterministic filesystem-backed task cache runtime.
-*
-* Use when:
-* - eval tasks need reproducible cache paths for expensive pre-processing outputs
-* - benchmark adapters need one artifact-oriented API for text/json/binary reads and writes
-*
-* Expects:
-* - `cacheRootDirectory` to be writable by the running process
-* - `workspaceId` + `projectName` to stay stable for reproducible paths
-*
-* Returns:
-* - task cache runtime that resolves namespaced file handles under:
-*   `<cacheRootDirectory>/<workspaceId>/<projectName>/<namespace>/...`
-*/
-function createFilesystemTaskCacheRuntime(options) {
-	const workspaceDirectory = sanitizePathSegment(options.workspaceId);
-	const projectDirectory = sanitizePathSegment(options.projectName);
-	const baseDirectory = join(options.cacheRootDirectory, workspaceDirectory, projectDirectory);
-	return { namespace(name) {
-		return createCacheNamespace(baseDirectory, name);
-	} };
-}
-//#endregion
-//#region src/core/runner/aggregate.ts
-function cloneScheduledTaskMatrix(matrix) {
-	return {
-		eval: { ...matrix.eval },
-		meta: { ...matrix.meta },
-		run: { ...matrix.run }
-	};
-}
-function assertKnownScoreKind(kind) {
-	if (kind === "exact" || kind === "judge") return kind;
-	throw new TypeError(`Unknown eval score kind "${kind}".`);
-}
-function average(scores) {
-	if (scores.length === 0) return null;
-	return scores.reduce((sum, score) => sum + score, 0) / scores.length;
-}
-function createHybridAverage(exactAverage, judgeAverage) {
-	if (exactAverage != null && judgeAverage != null) return (exactAverage + judgeAverage) / 2;
-	if (exactAverage != null) return exactAverage;
-	if (judgeAverage != null) return judgeAverage;
-	return null;
-}
-function collectScoreBuckets(scores) {
-	const buckets = {
-		exact: [],
-		judge: []
-	};
-	for (const score of scores) {
-		if (assertKnownScoreKind(score.kind) === "exact") {
-			buckets.exact.push(score.score);
-			continue;
-		}
-		buckets.judge.push(score.score);
-	}
-	return buckets;
-}
-function createRunSummary(result) {
-	const buckets = collectScoreBuckets(result.scores);
-	const exactAverage = average(buckets.exact);
-	const judgeAverage = average(buckets.judge);
-	return {
-		entryId: result.entryId,
-		exactAverage,
-		hybridAverage: createHybridAverage(exactAverage, judgeAverage),
-		id: result.id,
-		judgeAverage,
-		matrix: cloneScheduledTaskMatrix(result.matrix),
-		inferenceExecutorId: result.inferenceExecutorId
-	};
-}
-function createProviderSummary(inferenceExecutorId, results) {
-	const exactScores = [];
-	const judgeScores = [];
-	for (const result of results) {
-		const buckets = collectScoreBuckets(result.scores);
-		exactScores.push(...buckets.exact);
-		judgeScores.push(...buckets.judge);
-	}
-	const exactAverage = average(exactScores);
-	const judgeAverage = average(judgeScores);
-	return {
-		exactAverage,
-		hybridAverage: createHybridAverage(exactAverage, judgeAverage),
-		judgeAverage,
-		inferenceExecutorId,
-		runCount: results.length
-	};
-}
-/**
-* Aggregates exact-match and judge-based scores into hybrid runner summaries.
-*
-* Call stack:
-*
-* {@link runScheduledTasks}
-*   -> {@link aggregateRunResults}
-*     -> {@link createRunSummary}
-*     -> {@link createProviderSummary}
-*       -> `report output`
-*
-* Use when:
-* - a runner batch mixes deterministic exact checks with judge-based grading
-* - inferenceExecutor comparison should preserve both score families and one hybrid view
-*
-* Expects:
-* - each score to be normalized to the `0..1` range before aggregation
-* - `scores.kind` to use only `'exact'` or `'judge'`
-*/
-function aggregateRunResults(results) {
-	const runs = results.map(createRunSummary);
-	const inferenceExecutors = Array.from(new Set(results.map((result) => result.inferenceExecutorId))).map((inferenceExecutorId) => {
-		return createProviderSummary(inferenceExecutorId, results.filter((result) => result.inferenceExecutorId === inferenceExecutorId));
-	}).sort((left, right) => left.inferenceExecutorId.localeCompare(right.inferenceExecutorId));
-	const overall = createProviderSummary("overall", results);
-	return {
-		overall: {
-			exactAverage: overall.exactAverage,
-			hybridAverage: overall.hybridAverage,
-			judgeAverage: overall.judgeAverage,
-			runCount: overall.runCount
-		},
-		inferenceExecutors,
-		runs
-	};
-}
-//#endregion
-//#region src/core/runner/collect.ts
-const evalFileSuffix = ".eval.ts";
-const absolutePathPattern = /^(?:[A-Z]:\/|\/|\\\\)/i;
-function normalizePath(value) {
-	return value.replaceAll("\\", "/");
-}
-/**
-* Converts a file path into a project-relative path when possible.
-*
-* Before: `/repo/plugins/airi-plugin-game-chess/src/agent/evals/chess-commentary.eval.ts`
-* After: `plugins/airi-plugin-game-chess/src/agent/evals/chess-commentary.eval.ts`
-*
-* Before: `D:/repo/plugins/airi-plugin-game-chess/src/agent/evals/chess-commentary.eval.ts`
-* After: `D:/repo/plugins/airi-plugin-game-chess/src/agent/evals/chess-commentary.eval.ts`
-*/
-function asProjectRelativePath(filePath, context) {
-	const normalizedFilePath = normalizePath(filePath);
-	const normalizedProjectRootDirectory = normalizePath(context.projectRootDirectory);
-	const filePathWindowsDrive = normalizedFilePath.match(/^[A-Z]:\//i)?.[0];
-	const projectRootWindowsDrive = normalizedProjectRootDirectory.match(/^[A-Z]:\//i)?.[0];
-	if (filePathWindowsDrive != null && projectRootWindowsDrive == null) return normalizedFilePath;
-	if (filePathWindowsDrive != null && projectRootWindowsDrive != null && filePathWindowsDrive.toLowerCase() !== projectRootWindowsDrive.toLowerCase()) return normalizedFilePath;
-	const projectRootDirectory = context.projectRootDirectory;
-	const relativeFilePath = normalizePath(relative(projectRootDirectory, filePath));
-	if (!absolutePathPattern.test(relativeFilePath)) {
-		if (relativeFilePath === "..") return normalizePath(filePath);
-		if (!relativeFilePath.startsWith("../")) return relativeFilePath;
-	}
-	return normalizePath(filePath);
-}
-function resolveModuleFilePath(moduleHref) {
-	if (!moduleHref.startsWith("file:")) return null;
-	try {
-		return fileURLToPath(moduleHref);
-	} catch {
-		return null;
-	}
-}
-function createCollectedEvalEntry(moduleHref, moduleDefinition, context) {
-	const filePath = resolveModuleFilePath(moduleHref);
-	if (!filePath) return null;
-	const relativeFilePath = asProjectRelativePath(filePath, context);
-	if (!relativeFilePath.endsWith(evalFileSuffix)) return null;
-	const entryName = basename(relativeFilePath, evalFileSuffix);
-	if (entryName.length === 0) return null;
-	const relativeDirectory = dirname(relativeFilePath);
-	const directory = relativeDirectory === "." ? "" : relativeDirectory;
-	return {
-		...moduleDefinition.default,
-		directory,
-		filePath,
-		id: directory.length === 0 ? entryName : `${directory}/${entryName}`,
-		name: entryName
-	};
-}
-/**
-* Collects loaded vieval modules into sorted runner entries with stable ids.
-*
-* Call stack:
-*
-* `import.meta.glob(...)`
-*   -> {@link collectEvalEntries}
-*     -> {@link createCollectedEvalEntry}
-*       -> {@link CollectedEvalEntry}[]
-*
-* Use when:
-* - the runner has already loaded candidate eval modules
-* - downstream scheduling needs stable entry ids and directory metadata
-*/
-function collectEvalEntries(modules, context) {
-	return Object.entries(modules).flatMap(([moduleHref, moduleDefinition]) => {
-		const entry = createCollectedEvalEntry(moduleHref, moduleDefinition, context);
-		if (!entry) return [];
-		return [entry];
-	}).sort((left, right) => left.id.localeCompare(right.id));
-}
-//#endregion
-//#region src/core/runner/run.ts
-function createDefaultExecutionContext(task) {
-	return {
-		cache: { namespace(name) {
-			return { file(options) {
-				const key = options.key.join("/");
-				throw new Error(`Task cache runtime is not configured. Requested namespace "${name}" and key "${key}".`);
-			} };
-		} },
-		model(options) {
-			const requestedModelName = typeof options === "string" ? options : options?.name;
-			if (requestedModelName != null) throw new Error(`No model registry configured. Requested model: ${requestedModelName}`);
-			throw new Error(`No model registry configured for task inferenceExecutor id "${task.inferenceExecutor.id}".`);
-		}
-	};
-}
-/**
-* Error thrown when a scheduled run fails before producing a normalized result.
-*/
-var RunnerExecutionError = class extends Error {
-	/**
-	* Stable task id that failed.
-	*/
-	taskId;
-	constructor(taskId, cause) {
-		const message = errorMessageFrom(cause) ?? "Unknown runner execution failure.";
-		super(`Runner task "${taskId}" failed: ${message}`);
-		this.name = "RunnerExecutionError";
-		this.taskId = taskId;
-		this.cause = cause;
-	}
-};
-function createRunnerExecutionError(taskId, cause) {
-	if (cause instanceof RunnerExecutionError && cause.taskId === taskId) return cause;
-	return new RunnerExecutionError(taskId, cause);
-}
-/**
-* Executes runner tasks sequentially and aggregates the normalized results.
-*
-* Call stack:
-*
-* {@link createRunnerSchedule}
-*   -> {@link runScheduledTasks}
-*     -> `executor(task)`
-*       -> {@link aggregateRunResults}
-*
-* Use when:
-* - the caller already expanded the runner matrix
-* - task execution should stay deterministic and easy to debug
-*
-* Expects:
-* - `executor` to return normalized `0..1` scores
-* - callers to handle concurrency outside this helper when needed
-* - `onTaskStart` / `onTaskEnd` hooks to be synchronous lifecycle observers
-*
-* Throws:
-* - `RunnerExecutionError` when task setup, hooks, or the executor throws
-*/
-async function runScheduledTasks(tasks, executor, options = {}) {
-	if (tasks.length === 0) return aggregateRunResults([]);
-	async function executeScheduledTask(task) {
-		let executionContext;
-		try {
-			executionContext = options.createExecutionContext?.(task) ?? createDefaultExecutionContext(task);
-		} catch (error) {
-			throw createRunnerExecutionError(task.id, error);
-		}
-		try {
-			options.onTaskStart?.(task);
-		} catch (error) {
-			throw createRunnerExecutionError(task.id, error);
-		}
-		let runResult;
-		try {
-			runResult = await executor(task, executionContext);
-		} catch (error) {
-			try {
-				options.onTaskEnd?.(task, "failed");
-			} catch {}
-			throw createRunnerExecutionError(task.id, error);
-		}
-		try {
-			options.onTaskEnd?.(task, "passed");
-		} catch (error) {
-			throw createRunnerExecutionError(task.id, error);
-		}
-		return runResult;
-	}
-	const maxConcurrency = options.maxConcurrency ?? 1;
-	if (maxConcurrency <= 1) {
-		const results = [];
-		for (const task of tasks) results.push(await executeScheduledTask(task));
-		return aggregateRunResults(results);
-	}
-	const runWithLimit = limitConcurrency(maxConcurrency);
-	return aggregateRunResults((await Promise.all(tasks.map(async (task, index) => {
-		return {
-			index,
-			result: await runWithLimit(async () => executeScheduledTask(task))
-		};
-	}))).sort((left, right) => left.index - right.index).map((item) => item.result));
-}
-//#endregion
-//#region src/core/runner/runtime-context.ts
-const require = createRequire(import.meta.url);
-/**
-* Creates a side-effect-free runtime context for runner path normalization.
-*
-* Call stack:
-*
-* {@link createRunnerRuntimeContext}
-*   -> `findWorkspaceDir(cwd)`
-*     -> `resolve projectRootDirectory`
-*       -> `{ projectRootDirectory }`
-*
-* Use when:
-* - initializing runner infrastructure before collecting eval modules
-* - tests need deterministic root resolution behavior
-*/
-async function createRunnerRuntimeContext(options = {}) {
-	const cwd = options.cwd ?? dirname(fileURLToPath(import.meta.url));
-	const fallbackProjectRootDirectory = options.fallbackProjectRootDirectory ?? fileURLToPath(new URL("../../../", import.meta.url));
-	const { findWorkspaceDir } = require("@pnpm/find-workspace-dir");
-	return { projectRootDirectory: await findWorkspaceDir(cwd) ?? fallbackProjectRootDirectory };
-}
-//#endregion
-//#region src/core/runner/schedule.ts
-const matrixLayerKeys = new Set([
-	"disable",
-	"extend",
-	"override"
-]);
-const ambiguousMatrixDefinitionErrorMessage = "Ambiguous matrix definition: cannot mix reserved layer keys (disable, extend, override) with matrix axis keys.";
-function encodeTaskIdSegment(value) {
-	return encodeURIComponent(value);
-}
-function stringifyMatrixValue(value) {
-	return String(value);
-}
-function cloneMatrixSelection(matrix) {
-	return { ...matrix };
-}
-function createScheduledTaskMatrix(runMatrix, evalMatrix) {
-	return {
-		eval: cloneMatrixSelection(evalMatrix),
-		meta: {
-			evalRowId: createStableRowId(evalMatrix),
-			runRowId: createStableRowId(runMatrix)
-		},
-		run: cloneMatrixSelection(runMatrix)
-	};
-}
-function isMatrixLayer(matrix) {
-	const matrixKeys = Object.keys(matrix);
-	return matrixKeys.length > 0 && matrixKeys.every((key) => matrixLayerKeys.has(key));
-}
-function assertNonAmbiguousMatrixDefinition(matrix) {
-	const matrixKeys = Object.keys(matrix);
-	const hasReservedKeys = matrixKeys.some((key) => matrixLayerKeys.has(key));
-	const hasAxisKeys = matrixKeys.some((key) => !matrixLayerKeys.has(key));
-	if (hasReservedKeys && hasAxisKeys) throw new TypeError(ambiguousMatrixDefinitionErrorMessage);
-}
-function normalizeLayerInputToAxes(matrix) {
-	if (matrix == null) return;
-	assertNonAmbiguousMatrixDefinition(matrix);
-	if (isMatrixLayer(matrix)) return matrix;
-	return { extend: matrix };
-}
-function dedupeAxisValues(values) {
-	return Array.from(new Set(values.map(stringifyMatrixValue)));
-}
-function applyAxisValues(axes, definition, mode) {
-	if (definition == null) return;
-	for (const [axis, values] of Object.entries(definition)) {
-		const nextValues = dedupeAxisValues(values);
-		if (mode === "extend") {
-			const existingValues = axes.get(axis) ?? [];
-			axes.set(axis, Array.from(new Set([...existingValues, ...nextValues])));
-			continue;
-		}
-		axes.set(axis, nextValues);
-	}
-}
-function applyLayer(baseAxes, layer) {
-	const nextAxes = new Map(Array.from(baseAxes.entries()).map(([axis, values]) => [axis, [...values]]));
-	for (const axis of layer?.disable ?? []) nextAxes.delete(axis);
-	applyAxisValues(nextAxes, layer?.extend, "extend");
-	applyAxisValues(nextAxes, layer?.override, "override");
-	return nextAxes;
-}
-function expandAxesToRows(axes) {
-	if (axes.size === 0) return [{}];
-	const dimensions = Array.from(axes.entries());
-	let selections = [{}];
-	for (const [axis, values] of dimensions) {
-		if (values.length === 0) return [];
-		const nextSelections = [];
-		for (const selection of selections) for (const value of values) nextSelections.push({
-			...selection,
-			[axis]: value
-		});
-		selections = nextSelections;
-	}
-	return selections;
-}
-function createStableRowId(matrix) {
-	const segments = Object.entries(matrix).sort(([leftAxis], [rightAxis]) => leftAxis.localeCompare(rightAxis)).map(([axis, value]) => `${encodeTaskIdSegment(axis)}=${encodeTaskIdSegment(value)}`);
-	if (segments.length === 0) return "default";
-	return segments.join("&");
-}
-function createTaskId(entryId, inferenceExecutorId, runRowId, evalRowId) {
-	return [
-		encodeTaskIdSegment(entryId),
-		encodeTaskIdSegment(inferenceExecutorId),
-		`run=${encodeTaskIdSegment(runRowId)}`,
-		`eval=${encodeTaskIdSegment(evalRowId)}`
-	].join("::");
-}
-function createResolvedRunAxes(entry, runMatrix) {
-	let resolvedAxes = /* @__PURE__ */ new Map();
-	for (const layerInput of [
-		runMatrix,
-		entry.matrix?.runMatrix,
-		entry.task?.matrix?.runMatrix
-	]) resolvedAxes = applyLayer(resolvedAxes, normalizeLayerInputToAxes(layerInput));
-	return resolvedAxes;
-}
-function createResolvedEvalAxes(entry, evalMatrix) {
-	let resolvedAxes = /* @__PURE__ */ new Map();
-	for (const layerInput of [
-		evalMatrix,
-		entry.matrix?.evalMatrix,
-		entry.task?.matrix?.evalMatrix
-	]) resolvedAxes = applyLayer(resolvedAxes, normalizeLayerInputToAxes(layerInput));
-	return resolvedAxes;
-}
-/**
-* Expands collected entries into a stable runner schedule.
-*
-* Call stack:
-*
-* {@link collectEvalEntries} (`../runner`)
-*   -> {@link createRunnerSchedule}
-*     -> {@link expandAxesToRows}
-*       -> {@link ScheduledTask}[]
-*
-* Use when:
-* - the runner already knows which eval entries are available
-* - each entry must run against multiple inferenceExecutors or matrix variants
-*
-* Expects:
-* - `entries` and `inferenceExecutors` to be provided in the desired execution order
-* - matrix axes to use insertion order when generating combinations
-*/
-function createRunnerSchedule(options) {
-	if (options.entries.length === 0) return [];
-	if (options.inferenceExecutors.length === 0) return [];
-	const tasks = [];
-	for (const entry of options.entries) {
-		const runSelections = expandAxesToRows(createResolvedRunAxes(entry, options.runMatrix));
-		const evalSelections = expandAxesToRows(createResolvedEvalAxes(entry, options.evalMatrix));
-		if (runSelections.length === 0 || evalSelections.length === 0) continue;
-		for (const inferenceExecutor of options.inferenceExecutors) for (const runMatrix of runSelections) for (const evalMatrix of evalSelections) {
-			const isolatedMatrix = createScheduledTaskMatrix(runMatrix, evalMatrix);
-			tasks.push({
-				entry,
-				id: createTaskId(entry.id, inferenceExecutor.id, isolatedMatrix.meta.runRowId, isolatedMatrix.meta.evalRowId),
-				matrix: isolatedMatrix,
-				inferenceExecutor
-			});
-		}
-	}
-	return tasks;
-}
-//#endregion
-//#region src/core/runner/task-context.ts
-function createNoopTaskCacheRuntime() {
-	return { namespace(name) {
-		return { file(options) {
-			const key = options.key.join("/");
-			throw new Error(`Task cache runtime is not configured. Requested namespace "${name}" and key "${key}".`);
-		} };
-	} };
-}
-function resolveDefaultTaskModel(models, task) {
-	const runMatrixModelName = task.matrix.run.model;
-	if (runMatrixModelName != null) {
-		const matrixSelectedModel = resolveModelByName(models, runMatrixModelName);
-		if (matrixSelectedModel != null) return matrixSelectedModel;
-		throw new Error(`Unknown configured model "${runMatrixModelName}" from task.matrix.run.model.`);
-	}
-	const matched = resolveModelByName(models, task.inferenceExecutor.id);
-	if (matched != null) return matched;
-	if (models.length > 1) throw new Error([
-		`Multiple configured models are available, but no default model is selected for inferenceExecutor "${task.inferenceExecutor.id}".`,
-		"Select one model explicitly by either:",
-		"- setting runMatrix.override.model (or task matrix run.model)",
-		"- setting project.inferenceExecutors to a matching model id",
-		"- calling context.model({ name: \"your-model-id-or-alias\" })"
-	].join("\n"));
-	if (models.length === 1) {
-		const firstModel = models[0];
-		if (firstModel != null) return firstModel;
-	}
-	throw new Error(`No configured model found for inferenceExecutor id "${task.inferenceExecutor.id}".`);
-}
-/**
-* Creates task-scoped model resolver context for runner execution.
-*
-* Call stack:
-*
-* {@link runScheduledTasks}
-*   -> {@link createTaskExecutionContext}
-*     -> {@link resolveModelByName}
-*       -> `task.model()` / `task.model({ name })`
-*/
-function createTaskExecutionContext(options) {
-	return {
-		cache: options.cache ?? createNoopTaskCacheRuntime(),
-		model(selection) {
-			if (selection == null) return resolveDefaultTaskModel(options.models, options.task);
-			const name = typeof selection === "string" ? selection : selection.name;
-			const namedModel = resolveModelByName(options.models, name);
-			if (namedModel == null) throw new Error(`Unknown configured model "${name}".`);
-			return namedModel;
-		}
-	};
-}
-//#endregion
-export { runScheduledTasks as a, aggregateRunResults as c, RunnerExecutionError as i, createFilesystemTaskCacheRuntime as l, createRunnerSchedule as n, asProjectRelativePath as o, createRunnerRuntimeContext as r, collectEvalEntries as s, createTaskExecutionContext as t, normalizeCacheFilePathSegments as u };
-
-//# sourceMappingURL=runner-Dpy-eivM.mjs.map