vieval 0.0.10 → 0.0.12

package/dist/core/runner/index.mjs

@@ -9,17 +9,28 @@ 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";
+/**
+* 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);
+	} };
 }
 /**
 * Normalizes cache file options into deterministic relative path segments.
@@ -39,16 +50,8 @@ function normalizeCacheFilePathSegments(options) {
 	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);
@@ -57,6 +60,12 @@ function createCacheFileHandle(path) {
 				return false;
 			}
 		},
+		async loadAsCasesInput() {
+			return await this.readJson();
+		},
+		async loadAsExpectFixture() {
+			return await this.readJson();
+		},
 		openReadStream() {
 			return createReadStream(path);
 		},
@@ -64,29 +73,24 @@ function createCacheFileHandle(path) {
 			await mkdir(dirname(path), { recursive: true });
 			return createWriteStream(path);
 		},
+		path,
 		async readBuffer() {
 			return await readFile(path);
 		},
-		async writeBuffer(value) {
-			await writeAtomically(path, value);
+		async readJson() {
+			return JSON.parse(await readFile(path, "utf-8"));
 		},
 		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 writeBuffer(value) {
+			await writeAtomically(path, value);
 		},
 		async writeJson(value) {
 			await writeAtomically(path, `${JSON.stringify(value, null, 2)}\n`);
 		},
-		async loadAsCasesInput() {
-			return await this.readJson();
-		},
-		async loadAsExpectFixture() {
-			return await this.readJson();
+		async writeText(value, encoding = "utf-8") {
+			await writeAtomically(path, Buffer.from(value, encoding));
 		}
 	};
 }
@@ -96,36 +100,61 @@ function createCacheNamespace(baseDirectory, namespace) {
 		return createCacheFileHandle(join(baseDirectory, sanitizePathSegment(namespace), ...relativePathSegments));
 	} };
 }
+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";
+}
+function sanitizePathSegment(value) {
+	const normalized = value.trim();
+	if (normalized.length === 0) return "default";
+	return normalized.replace(/[^\w.-]+/g, "-");
+}
+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);
+}
+//#endregion
+//#region src/core/runner/aggregate.ts
 /**
-* Creates a deterministic filesystem-backed task cache runtime.
+* 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:
-* - 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
+* - a runner batch mixes deterministic exact checks with judge-based grading
+* - inferenceExecutor comparison should preserve both score families and one hybrid view
 *
 * 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>/...`
+* - each score to be normalized to the `0..1` range before aggregation
+* - `scores.kind` to use only `'exact'` or `'judge'`
 */
-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) {
+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 {
-		eval: { ...matrix.eval },
-		meta: { ...matrix.meta },
-		run: { ...matrix.run }
+		inferenceExecutors,
+		overall: {
+			exactAverage: overall.exactAverage,
+			hybridAverage: overall.hybridAverage,
+			judgeAverage: overall.judgeAverage,
+			runCount: overall.runCount
+		},
+		runs
 	};
 }
 function assertKnownScoreKind(kind) {
@@ -136,11 +165,12 @@ 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 cloneScheduledTaskMatrix(matrix) {
+	return {
+		eval: { ...matrix.eval },
+		meta: { ...matrix.meta },
+		run: { ...matrix.run }
+	};
 }
 function collectScoreBuckets(scores) {
 	const buckets = {
@@ -156,19 +186,11 @@ function collectScoreBuckets(scores) {
 	}
 	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 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 createProviderSummary(inferenceExecutorId, results) {
 	const exactScores = [];
@@ -183,54 +205,29 @@ function createProviderSummary(inferenceExecutorId, results) {
 	return {
 		exactAverage,
 		hybridAverage: createHybridAverage(exactAverage, judgeAverage),
-		judgeAverage,
 		inferenceExecutorId,
+		judgeAverage,
 		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);
+function createRunSummary(result) {
+	const buckets = collectScoreBuckets(result.scores);
+	const exactAverage = average(buckets.exact);
+	const judgeAverage = average(buckets.judge);
 	return {
-		overall: {
-			exactAverage: overall.exactAverage,
-			hybridAverage: overall.hybridAverage,
-			judgeAverage: overall.judgeAverage,
-			runCount: overall.runCount
-		},
-		inferenceExecutors,
-		runs
+		entryId: result.entryId,
+		exactAverage,
+		hybridAverage: createHybridAverage(exactAverage, judgeAverage),
+		id: result.id,
+		inferenceExecutorId: result.inferenceExecutorId,
+		judgeAverage,
+		matrix: cloneScheduledTaskMatrix(result.matrix)
 	};
 }
 //#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.
 *
@@ -255,31 +252,6 @@ function asProjectRelativePath(filePath, context) {
 	}
 	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.
 *
@@ -301,19 +273,36 @@ function collectEvalEntries(modules, context) {
 		return [entry];
 	}).sort((left, right) => left.id.localeCompare(right.id));
 }
-//#endregion
-//#region src/core/runner/run.ts
-function createDefaultExecutionContext() {
+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 {
-		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}".`);
-			} };
-		} },
-		models: []
+		...moduleDefinition.default,
+		directory,
+		filePath,
+		id: directory.length === 0 ? entryName : `${directory}/${entryName}`,
+		name: entryName
 	};
 }
+function normalizePath(value) {
+	return value.replaceAll("\\", "/");
+}
+function resolveModuleFilePath(moduleHref) {
+	if (!moduleHref.startsWith("file:")) return null;
+	try {
+		return fileURLToPath(moduleHref);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/core/runner/run.ts
 /**
 * Error thrown when a scheduled run fails before producing a normalized result.
 */
@@ -330,10 +319,6 @@ var RunnerExecutionError = class extends Error {
 		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.
 *
@@ -400,6 +385,21 @@ async function runScheduledTasks(tasks, executor, options = {}) {
 		};
 	}))).sort((left, right) => left.index - right.index).map((item) => item.result));
 }
+function createDefaultExecutionContext() {
+	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}".`);
+			} };
+		} },
+		models: []
+	};
+}
+function createRunnerExecutionError(taskId, cause) {
+	if (cause instanceof RunnerExecutionError && cause.taskId === taskId) return cause;
+	return new RunnerExecutionError(taskId, cause);
+}
 //#endregion
 //#region src/core/runner/runtime-context.ts
 const require = createRequire(import.meta.url);
@@ -425,21 +425,96 @@ async function createRunnerRuntimeContext(options = {}) {
 }
 //#endregion
 //#region src/core/runner/schedule.ts
-const matrixLayerKeys = new Set([
+const matrixLayerKeys = /* @__PURE__ */ 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);
+/**
+* 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),
+				inferenceExecutor,
+				matrix: isolatedMatrix
+			});
+		}
+	}
+	return tasks;
 }
-function stringifyMatrixValue(value) {
-	return String(value);
+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(/* @__PURE__ */ 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 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 cloneMatrixSelection(matrix) {
 	return { ...matrix };
 }
+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;
+}
+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 createScheduledTaskMatrix(runMatrix, evalMatrix) {
 	return {
 		eval: cloneMatrixSelection(evalMatrix),
@@ -450,43 +525,24 @@ function createScheduledTaskMatrix(runMatrix, evalMatrix) {
 		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 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 normalizeLayerInputToAxes(matrix) {
-	if (matrix == null) return;
-	assertNonAmbiguousMatrixDefinition(matrix);
-	if (isMatrixLayer(matrix)) return matrix;
-	return { extend: matrix };
+function createTaskId(entryId, inferenceExecutorId, runRowId, evalRowId) {
+	return [
+		encodeTaskIdSegment(entryId),
+		encodeTaskIdSegment(inferenceExecutorId),
+		`run=${encodeTaskIdSegment(runRowId)}`,
+		`eval=${encodeTaskIdSegment(evalRowId)}`
+	].join("::");
 }
 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 encodeTaskIdSegment(value) {
+	return encodeURIComponent(value);
 }
 function expandAxesToRows(axes) {
 	if (axes.size === 0) return [{}];
@@ -503,85 +559,21 @@ function expandAxesToRows(axes) {
 	}
 	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 isMatrixLayer(matrix) {
+	const matrixKeys = Object.keys(matrix);
+	return matrixKeys.length > 0 && matrixKeys.every((key) => matrixLayerKeys.has(key));
 }
-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;
+function normalizeLayerInputToAxes(matrix) {
+	if (matrix == null) return;
+	assertNonAmbiguousMatrixDefinition(matrix);
+	if (isMatrixLayer(matrix)) return matrix;
+	return { extend: matrix };
 }
-/**
-* 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;
+function stringifyMatrixValue(value) {
+	return String(value);
 }
 //#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}".`);
-		} };
-	} };
-}
 /**
 * Creates task-scoped context data for runner execution.
 *
@@ -597,6 +589,14 @@ function createTaskExecutionContext(options) {
 		models: options.models
 	};
 }
+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}".`);
+		} };
+	} };
+}
 //#endregion
 export { RunnerExecutionError, aggregateRunResults, asProjectRelativePath, collectEvalEntries, createFilesystemTaskCacheRuntime, createRunnerRuntimeContext, createRunnerSchedule, createSchedulerRuntime, createTaskExecutionContext, getActiveScopes, normalizeCacheFilePathSegments, runScheduledTasks };