@alint-js/core 0.0.29 → 0.0.30

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { r as withAgentRetry } from "./retry-C4sGjSE5.mjs";
+import { o as withAgentRetry, t as combineAbortSignals } from "./agent-weXkvGkc.mjs";
 import { a as sliceRange, i as sliceLines, n as createSourceFile, r as createSourceRuntime, t as extractJsSourceTargets } from "./extract-CIWssxNK.mjs";
 import { minimatch } from "minimatch";
 import { isAbsolute, relative, resolve } from "pathe";
@@ -6,10 +6,10 @@ import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname, extname, isAbsolute as isAbsolute$1, join, relative as relative$1, resolve as resolve$1, sep } from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 import process, { cwd } from "node:process";
-import { errorCauseFrom, errorMessageFrom } from "@moeru/std/error";
 import { createHash, randomUUID } from "node:crypto";
 import { statSync } from "node:fs";
 import { array, check, description, is, literal, number, object, optional, pipe, record, string, union, unknown } from "valibot";
+import { errorMessageFrom } from "@moeru/std/error";
 //#region src/config/config-array.ts
 const effectiveBasePathSymbol = Symbol("effectiveBasePath");
 const inheritedMatcherScopesSymbol = Symbol("inheritedMatcherScopes");
@@ -580,99 +580,177 @@ function statSyncIsDirectory(path) {
 	return statSync(path).isDirectory();
 }
 //#endregion
-//#region src/core/targets/directory.ts
-function createDirectoryExecutionPlans(directories, fileOffset) {
-	return directories.map((directory, directoryOffset) => {
-		const executions = directory.ruleRuntimes.map((runtime) => {
-			if (runtime.handlers.onTargetWith) return {
-				run: () => runtime.handlers.onTargetWith?.(directory.target),
-				runtime
-			};
-			if (runtime.handlers.onTargetDirectory) return {
-				run: () => runtime.handlers.onTargetDirectory?.(directory.target),
-				runtime
-			};
-		}).filter((execution) => execution !== void 0);
-		const targets = executions.length === 0 ? [] : [{
-			activeFilePath: directory.target.path,
-			cacheFilePaths: [],
-			configHash: directory.configHash,
-			executions,
-			identity: directory.target.path,
-			kind: "directory",
-			language: "directory",
-			text: directory.target.path
-		}];
-		return {
-			emitFileProgress: true,
-			fileIndex: fileOffset + directoryOffset + 1,
-			path: directory.target.path,
-			planned: executions.length,
-			targets
-		};
-	});
-}
-//#endregion
 //#region package.json
-var version = "0.0.29";
+var version = "0.0.30";
 //#endregion
-//#region src/core/targets/execution.ts
-var AlintRuleExecutionError = class extends Error {
-	failure;
-	constructor(error, path) {
-		const message = errorMessageFrom(error) ?? String(error);
-		super(message, { cause: error });
-		this.name = "AlintRuleExecutionError";
-		this.failure = {
-			filePath: path.file.path,
-			message,
-			ruleId: path.rule.id,
-			target: {
-				kind: path.target.kind,
-				name: path.target.name
-			}
-		};
+//#region src/core/execution/job.ts
+var CacheReplayProcessingError = class {
+	cause;
+	constructor(cause) {
+		this.cause = cause;
 	}
 };
-async function executeTargetPlans(options) {
-	for (const plan of options.plans) await executeTargetPlan(plan, options);
+function createRuleJobs(plans) {
+	const jobs = [];
+	const total = plans.reduce((sum, plan) => sum + plan.planned, 0);
+	for (const plan of plans) for (const target of plan.targets) for (const execution of target.executions) {
+		const ruleId = execution.runtime.enabledRule.id;
+		const index = jobs.length + 1;
+		jobs.push({
+			execution,
+			job: {
+				id: stableHash({
+					index,
+					planId: plan.id,
+					ruleId,
+					targetIdentity: target.identity
+				}),
+				index,
+				inputPath: plan.path,
+				ruleId,
+				target: {
+					identity: target.identity,
+					kind: target.kind,
+					name: target.name
+				},
+				total
+			},
+			target
+		});
+	}
+	return jobs;
 }
-function createExecutionCacheKey(runtime, target, path, cache) {
-	if (!cache.enabled || !runtime.cacheable || target.cacheFilePaths.length === 0) return;
-	return createCacheKey({
-		alintVersion: version,
-		configHash: target.configHash,
-		filePath: normalizeCachePath(cache.cwd, path.file.path),
-		modelHash: cache.modelHash,
-		ruleHash: runtime.ruleHash,
-		schemaVersion: 1,
-		targetHash: createTargetHash(target),
-		targetIdentity: target.identity,
-		targetKind: target.kind
+async function executeRuleJob(job, options) {
+	const bucket = {
+		diagnostics: [],
+		usage: []
+	};
+	if (options.runSignal?.aborted) return finish(job, options, bucket, {
+		cache: "miss",
+		state: "cancelled"
+	});
+	const cacheKey = createExecutionCacheKey(job, options.cache);
+	const cachedEntry = cacheKey ? options.cache.store.get(cacheKey) : void 0;
+	if (cacheKey && cachedEntry) {
+		rememberCacheEntry(options.cache, job.target.cacheFilePaths, cacheKey);
+		try {
+			replayCachedEntry(cachedEntry, bucket, job.job, options.progress);
+		} catch (error) {
+			if (!(error instanceof CacheReplayProcessingError)) throw error;
+			return finish(job, options, bucket, {
+				cache: "hit",
+				cause: error.cause,
+				failure: failure(error.cause, job, "cache-replay"),
+				state: "failed"
+			});
+		}
+		return finish(job, options, bucket, {
+			cache: "hit",
+			state: "cached"
+		});
+	}
+	if (options.cacheOnly) return finish(job, options, bucket, {
+		cache: "miss",
+		state: "skipped"
+	});
+	const controller = new AbortController();
+	let timedOut = false;
+	let deadlineError;
+	const forwardRunAbort = () => controller.abort(options.runSignal?.reason);
+	if (options.runSignal?.aborted) forwardRunAbort();
+	else options.runSignal?.addEventListener("abort", forwardRunAbort, { once: true });
+	const timer = options.timeoutMs == null ? void 0 : setTimeout(() => {
+		timedOut = true;
+		deadlineError = /* @__PURE__ */ new Error(`Rule execution timed out after ${options.timeoutMs}ms.`);
+		controller.abort(deadlineError);
+	}, options.timeoutMs);
+	const state = {
+		activeFilePath: job.target.activeFilePath,
+		bucket,
+		job: job.job,
+		reporterFailed: false,
+		signal: controller.signal
+	};
+	let handlerCause;
+	let handlerFailed = false;
+	try {
+		await job.execution.runtime.executionState.run(state, job.execution.run);
+	} catch (cause) {
+		if (state.reporterFailed) throw state.reporterCause;
+		handlerCause = cause;
+		handlerFailed = true;
+	} finally {
+		if (timer != null) clearTimeout(timer);
+		options.runSignal?.removeEventListener("abort", forwardRunAbort);
+	}
+	if (state.reporterFailed) throw state.reporterCause;
+	if (!timedOut && !handlerFailed && cacheKey) try {
+		options.cache.store.set(cacheKey, createCacheEntry(job, options.cache, bucket));
+		rememberCacheEntry(options.cache, job.target.cacheFilePaths, cacheKey);
+	} catch {}
+	if (options.runSignal?.aborted) return finish(job, options, bucket, {
+		cache: "miss",
+		state: "cancelled"
+	});
+	if (timedOut) return finish(job, options, bucket, {
+		cache: "miss",
+		cause: deadlineError,
+		failure: failure(deadlineError, job, "timeout"),
+		state: "failed"
+	});
+	if (handlerFailed) return finish(job, options, bucket, {
+		cache: "miss",
+		cause: handlerCause,
+		failure: failure(handlerCause, job, "handler"),
+		state: "failed"
+	});
+	return finish(job, options, bucket, {
+		cache: "miss",
+		state: "completed"
 	});
 }
-function createProgressPath(filePath, ruleId, entry) {
+function resolveRuleExecutionTimeout(timeoutMs) {
+	if (timeoutMs === void 0) return void 0;
+	if (!Number.isFinite(timeoutMs) || !Number.isInteger(timeoutMs) || timeoutMs <= 0) throw new TypeError("Rule execution timeout must be a finite positive integer.");
+	return timeoutMs;
+}
+function createCacheEntry(job, cache, bucket) {
 	return {
-		file: {
-			index: entry.fileIndex,
-			path: filePath,
-			planned: entry.filePlanned,
-			total: entry.fileTotal
-		},
-		rule: {
-			id: ruleId,
-			index: entry.ruleIndex,
-			total: entry.ruleTotal
+		diagnostics: bucket.diagnostics,
+		filePath: normalizeCachePath(cache.cwd, job.job.inputPath),
+		fingerprint: {
+			alintVersion: version,
+			configHash: job.target.configHash,
+			modelHash: cache.modelHash,
+			ruleHash: job.execution.runtime.ruleHash
 		},
 		target: {
-			index: entry.targetIndex,
-			kind: entry.targetKind,
-			name: entry.targetName,
-			total: entry.targetTotal
-		}
+			hash: createTargetHash(job),
+			identity: job.target.identity,
+			kind: job.target.kind,
+			loc: job.target.loc,
+			name: job.target.name,
+			range: job.target.range
+		},
+		usage: bucket.usage
 	};
 }
-function createTargetHash(target) {
+function createExecutionCacheKey(job, cache) {
+	if (!cache.enabled || !job.execution.runtime.cacheable || job.target.cacheFilePaths.length === 0) return void 0;
+	return createCacheKey({
+		alintVersion: version,
+		configHash: job.target.configHash,
+		filePath: normalizeCachePath(cache.cwd, job.job.inputPath),
+		modelHash: cache.modelHash,
+		ruleHash: job.execution.runtime.ruleHash,
+		schemaVersion: 1,
+		targetHash: createTargetHash(job),
+		targetIdentity: job.target.identity,
+		targetKind: job.target.kind
+	});
+}
+function createTargetHash(job) {
+	const target = job.target;
 	return stableHash({
 		language: target.language,
 		loc: target.loc,
@@ -683,191 +761,28 @@ function createTargetHash(target) {
 		text: target.text
 	});
 }
-function emitErroredRuleEnd(progress, clock, path, startedAt, cache) {
-	try {
-		progress?.onRuleEnd?.({
-			cache,
-			endedAt: clock(),
-			path,
-			startedAt,
-			state: "errored"
-		});
-	} catch {}
-}
-async function executeRule(execution, path, target, options) {
-	const { cache, clock, counters, diagnostics, progress, signal, usage } = options;
-	signal?.throwIfAborted();
-	const startedAt = clock();
-	const cacheKey = createExecutionCacheKey(execution.runtime, target, path, cache);
-	const cachedEntry = cacheKey ? cache.store.get(cacheKey) : void 0;
-	progress?.onRuleStart?.({
-		path,
-		startedAt
-	});
-	if (cacheKey && cachedEntry) {
-		rememberCacheEntry(cache, target.cacheFilePaths, cacheKey);
-		try {
-			replayCachedEntry(cachedEntry, path, diagnostics, usage, progress);
-		} catch (error) {
-			counters.error();
-			emitErroredRuleEnd(progress, clock, path, startedAt, "hit");
-			throw new AlintRuleExecutionError(error, path);
-		}
-		counters.cache();
-		progress?.onRuleEnd?.({
-			cache: "hit",
-			endedAt: clock(),
-			path,
-			startedAt,
-			state: "completed"
-		});
-		return;
-	}
-	if (options.cacheOnly) {
-		counters.skip();
-		progress?.onRuleEnd?.({
-			cache: "miss",
-			endedAt: clock(),
-			path,
-			startedAt,
-			state: "skipped"
-		});
-		return;
-	}
-	let handlerError;
-	let handlerFailed = false;
-	const cacheDiagnostics = cacheKey ? [] : void 0;
-	const cacheUsage = cacheKey ? [] : void 0;
-	try {
-		await execution.runtime.executionState.run({
-			activeFilePath: target.activeFilePath,
-			cacheDiagnostics,
-			cacheUsage,
-			progressPath: path
-		}, execution.run);
-	} catch (error) {
-		handlerError = error;
-		handlerFailed = true;
-	}
-	if (handlerFailed) {
-		signal?.throwIfAborted();
-		counters.error();
-		emitErroredRuleEnd(progress, clock, path, startedAt, "miss");
-		throw new AlintRuleExecutionError(handlerError, path);
-	}
-	if (cacheKey) {
-		cache.store.set(cacheKey, {
-			diagnostics: cacheDiagnostics ?? [],
-			filePath: normalizeCachePath(cache.cwd, path.file.path),
-			fingerprint: {
-				alintVersion: version,
-				configHash: target.configHash,
-				modelHash: cache.modelHash,
-				ruleHash: execution.runtime.ruleHash
-			},
-			target: {
-				hash: createTargetHash(target),
-				identity: target.identity,
-				kind: target.kind,
-				loc: target.loc,
-				name: target.name,
-				range: target.range
-			},
-			usage: cacheUsage ?? []
-		});
-		rememberCacheEntry(cache, target.cacheFilePaths, cacheKey);
-	}
-	counters.complete();
-	progress?.onRuleEnd?.({
-		cache: "miss",
-		endedAt: clock(),
-		path,
-		startedAt,
-		state: "completed"
-	});
+function failure(cause, job, kind) {
+	return {
+		job: job.job,
+		kind,
+		message: errorMessageFrom(cause) ?? String(cause)
+	};
 }
-async function executeTargetPlan(plan, options) {
-	const { clock, filesTotal, progress } = options;
-	const fileStartedAt = clock();
-	const fileProgress = {
-		index: plan.fileIndex,
-		path: plan.path,
-		planned: plan.planned,
-		total: filesTotal
+function finish(job, options, bucket, terminal) {
+	const outcome = {
+		bucket,
+		job,
+		...terminal
 	};
-	if (plan.emitFileProgress) progress?.onFileStart?.({
-		file: fileProgress,
-		startedAt: fileStartedAt
+	options.progress?.onJobEnd?.({
+		cache: outcome.cache,
+		endedAt: options.clock(),
+		failure: outcome.failure,
+		job: job.job,
+		startedAt: options.startedAt,
+		state: outcome.state
 	});
-	let planError;
-	let planFailed = false;
-	try {
-		for (const [targetOffset, target] of plan.targets.entries()) {
-			const targetPath = createProgressPath(plan.path, target.executions[0]?.runtime.enabledRule.id ?? "", {
-				fileIndex: plan.fileIndex,
-				filePlanned: plan.planned,
-				fileTotal: filesTotal,
-				ruleIndex: 1,
-				ruleTotal: target.executions.length,
-				targetIndex: targetOffset + 1,
-				targetKind: target.kind,
-				targetName: target.name,
-				targetTotal: plan.targets.length
-			});
-			const targetStartedAt = clock();
-			progress?.onTargetStart?.({
-				path: targetPath,
-				startedAt: targetStartedAt
-			});
-			let targetError;
-			let targetFailed = false;
-			try {
-				for (const [executionOffset, execution] of target.executions.entries()) await executeRule(execution, createProgressPath(plan.path, execution.runtime.enabledRule.id, {
-					fileIndex: plan.fileIndex,
-					filePlanned: plan.planned,
-					fileTotal: filesTotal,
-					ruleIndex: executionOffset + 1,
-					ruleTotal: target.executions.length,
-					targetIndex: targetOffset + 1,
-					targetKind: target.kind,
-					targetName: target.name,
-					targetTotal: plan.targets.length
-				}), target, options);
-			} catch (error) {
-				targetError = error;
-				targetFailed = true;
-			}
-			try {
-				progress?.onTargetEnd?.({
-					endedAt: clock(),
-					path: targetPath,
-					startedAt: targetStartedAt
-				});
-			} catch (error) {
-				if (!targetFailed) {
-					targetError = error;
-					targetFailed = true;
-				}
-			}
-			if (targetFailed) throw targetError;
-		}
-	} catch (error) {
-		planError = error;
-		planFailed = true;
-	}
-	if (plan.emitFileProgress) try {
-		progress?.onFileEnd?.({
-			endedAt: clock(),
-			file: fileProgress,
-			startedAt: fileStartedAt
-		});
-	} catch (error) {
-		if (!planFailed) {
-			planError = error;
-			planFailed = true;
-		}
-	}
-	if (planFailed) throw planError;
+	return outcome;
 }
 function rememberCacheEntry(cache, filePaths, cacheKey) {
 	for (const filePath of filePaths) {
@@ -877,29 +792,69 @@ function rememberCacheEntry(cache, filePaths, cacheKey) {
 		cache.fileEntryKeys.set(normalizedPath, entries);
 	}
 }
-function replayCachedEntry(entry, path, diagnostics, usage, progress) {
-	for (const cachedDiagnostic of entry.diagnostics) {
+function replayCachedEntry(entry, bucket, job, progress) {
+	let diagnostics;
+	let usage;
+	try {
+		diagnostics = entry.diagnostics;
+		usage = entry.usage;
+	} catch (cause) {
+		throw new CacheReplayProcessingError(cause);
+	}
+	for (const cachedDiagnostic of diagnostics) {
 		const diagnostic = {
 			...cachedDiagnostic,
 			cached: true
 		};
-		diagnostics.push(diagnostic);
+		bucket.diagnostics.push(diagnostic);
 		progress?.onDiagnostic?.({
 			diagnostic,
-			diagnostics: [...diagnostics],
-			path
+			job
 		});
 	}
-	for (const cachedUsage of entry.usage) {
-		const record = usage.recordCached({ ...cachedUsage });
+	for (const record of usage) {
+		bucket.usage.push(record);
 		progress?.onUsage?.({
-			path,
-			record,
-			total: usage.toJSON()
+			job,
+			record
 		});
 	}
 }
 //#endregion
+//#region src/core/targets/directory.ts
+function createDirectoryExecutionPlans(directories, sourcePlanCount) {
+	return directories.map((directory, directoryOffset) => {
+		const executions = directory.ruleRuntimes.map((runtime) => {
+			if (runtime.handlers.onTargetWith) return {
+				run: () => runtime.handlers.onTargetWith?.(directory.target),
+				runtime
+			};
+			if (runtime.handlers.onTargetDirectory) return {
+				run: () => runtime.handlers.onTargetDirectory?.(directory.target),
+				runtime
+			};
+		}).filter((execution) => execution !== void 0);
+		const targets = executions.length === 0 ? [] : [{
+			activeFilePath: directory.target.path,
+			cacheFilePaths: [],
+			configHash: directory.configHash,
+			executions,
+			identity: directory.target.path,
+			kind: "directory",
+			language: "directory",
+			text: directory.target.path
+		}];
+		return {
+			id: `directory:${directory.target.path}`,
+			index: sourcePlanCount + directoryOffset + 1,
+			kind: "directory",
+			path: directory.target.path,
+			planned: executions.length,
+			targets
+		};
+	});
+}
+//#endregion
 //#region src/core/targets/project.ts
 function createProjectExecutionPlan(options) {
 	const project = createProjectTarget(options.root, options.files);
@@ -943,8 +898,9 @@ function createProjectExecutionPlan(options) {
 		})
 	};
 	return {
-		emitFileProgress: false,
-		fileIndex: 0,
+		id: `project:${options.root}`,
+		index: options.index,
+		kind: "project",
 		path: options.root,
 		planned: executions.length,
 		targets: [target]
@@ -979,8 +935,9 @@ function createSourceExecutionPlans(files, cwd) {
 		const resolveTargetIdentity = createTargetIdentityResolver(targets.map((target) => toTargetIdentityInput(cwd, preparedFile.file.path, target)));
 		for (const target of targets) target.identity = resolveTargetIdentity(toTargetIdentityInput(cwd, preparedFile.file.path, target));
 		const filePlan = {
-			emitFileProgress: true,
-			fileIndex: fileOffset + 1,
+			id: `source:${preparedFile.file.path}`,
+			index: fileOffset + 1,
+			kind: "source",
 			path: preparedFile.file.path,
 			planned: 0,
 			preparedFile,
@@ -1047,29 +1004,34 @@ function toTargetIdentityInput(cwd, filePath, target) {
 }
 //#endregion
 //#region src/core/run.ts
-var AlintRunError = class extends Error {
-	failure;
+var AlintRunCancelledError = class extends Error {
 	result;
-	constructor(message, result, options = {}) {
-		super(message, { cause: options.cause });
-		this.name = "AlintRunError";
-		this.failure = options.failure;
+	constructor(result, cause) {
+		super("Alint run cancelled.", { cause });
+		this.name = "AlintRunCancelledError";
 		this.result = result;
 	}
 };
-/**
-* Thrown when {@link RunOptions.signal} aborts a run.
-*
-* Extends {@link AlintRunError} so existing handlers still receive the partial `result`, while
-* callers that treat cancellation differently from failure can test for this type.
-*/
-var AlintAbortError = class extends AlintRunError {
+/** Cancellation error carrying the partial result gathered before the abort. */
+var AlintAbortError = class extends AlintRunCancelledError {
 	constructor(result, options = {}) {
-		super("alint run was aborted", result, { cause: options.cause });
+		super(result, options.cause);
 		this.name = "AlintAbortError";
 	}
 };
+var AlintRunError = class extends Error {
+	failures;
+	result;
+	constructor(message, result, options = {}) {
+		super(message, { cause: options.cause });
+		this.name = "AlintRunError";
+		this.failures = options.failures ?? [];
+		this.result = result;
+	}
+};
 async function runAlint(options = {}) {
+	const timeoutMs = resolveRuleExecutionTimeout(options.runner?.timeoutMs);
+	const concurrency = resolveRuleConcurrency(options.runner?.ruleConcurrency);
 	const cwd$1 = options.cwd ?? cwd();
 	const config = options.config ?? [];
 	const setupConfig = options.setupConfig ?? {
@@ -1077,8 +1039,6 @@ async function runAlint(options = {}) {
 		version: 1
 	};
 	const clock = Date.now;
-	const diagnostics = [];
-	const usage = createUsageAccumulator();
 	const src = createSourceRuntime();
 	const normalizedCacheConfig = normalizeRunnerCacheConfig(options.runner?.cache, cwd$1);
 	const cacheStore = await createCacheStore({
@@ -1115,14 +1075,13 @@ async function runAlint(options = {}) {
 		const registry = buildRuleRegistry(effectiveConfig);
 		const ruleRuntimes = createRuleRuntimes({
 			cwd: cwd$1,
-			diagnostics,
 			effectiveAgent: effectiveConfig.agent,
 			effectiveSettings: effectiveConfig.settings,
 			options,
+			progress: options.progress,
 			registry,
 			setupConfig,
-			src,
-			usage
+			src
 		});
 		return {
 			configHash: stableHash({
@@ -1150,14 +1109,13 @@ async function runAlint(options = {}) {
 			configHash: stableHash({ settings: effectiveConfig.settings }),
 			ruleRuntimes: createRuleRuntimes({
 				cwd: cwd$1,
-				diagnostics,
 				effectiveAgent: effectiveConfig.agent,
 				effectiveSettings: effectiveConfig.settings,
 				options,
+				progress: options.progress,
 				registry,
 				setupConfig,
-				src,
-				usage
+				src
 			}),
 			target
 		};
@@ -1166,181 +1124,146 @@ async function runAlint(options = {}) {
 	const projectConfig = resolvedProjectConfig.config;
 	const projectRuleRuntimes = resolvedProjectConfig.ignored ? [] : createRuleRuntimes({
 		cwd: cwd$1,
-		diagnostics,
 		effectiveAgent: projectConfig.agent,
 		effectiveSettings: projectConfig.settings,
 		options,
+		progress: options.progress,
 		registry: buildRuleRegistry(projectConfig),
 		setupConfig,
-		src,
-		usage
+		src
+	});
+	const filePlans = createSourceExecutionPlans(files, cwd$1);
+	const directoryPlans = createDirectoryExecutionPlans(directories, filePlans.length);
+	const projectPlan = resolvedProjectConfig.ignored ? void 0 : createProjectExecutionPlan({
+		configHash: stableHash({ settings: projectConfig.settings }),
+		files,
+		index: filePlans.length + directoryPlans.length + 1,
+		root: cwd$1,
+		ruleRuntimes: projectRuleRuntimes
+	});
+	const jobs = createRuleJobs([
+		...filePlans,
+		...directoryPlans,
+		...projectPlan ? [projectPlan] : []
+	]);
+	const runStartedAt = clock();
+	const settledOutcomes = new Array(jobs.length);
+	let infrastructureError;
+	let infrastructureFailed = false;
+	options.progress?.onRunStart?.({
+		jobsTotal: jobs.length,
+		startedAt: runStartedAt
 	});
-	let planned = 0;
-	const counters = createRuleEndCounters();
-	let filePlans = [];
-	let directoryPlans = [];
-	let projectPlan;
-	let runStartedAt;
-	let runError;
+	for (const job of jobs) options.progress?.onJobQueued?.({ job: job.job });
 	try {
-		options.signal?.throwIfAborted();
-		filePlans = createSourceExecutionPlans(files, cwd$1);
-		directoryPlans = createDirectoryExecutionPlans(directories, filePlans.length);
-		projectPlan = resolvedProjectConfig.ignored ? void 0 : createProjectExecutionPlan({
-			configHash: stableHash({ settings: projectConfig.settings }),
-			files,
-			root: cwd$1,
-			ruleRuntimes: projectRuleRuntimes
-		});
-		const activeDirectoryPlans = directoryPlans.filter((plan) => plan.targets.length > 0).map((plan, directoryOffset) => ({
-			...plan,
-			fileIndex: filePlans.length + directoryOffset + 1
-		}));
-		const inputsTotal = files.length + activeDirectoryPlans.length;
-		planned = calculatePlannedExecutions([...filePlans, ...directoryPlans]) + (projectPlan?.planned ?? 0);
-		runStartedAt = clock();
-		options.progress?.onRunStart?.({
-			files: [...filePlans, ...activeDirectoryPlans].map((plan) => toProgressFilePath(plan, inputsTotal)),
-			filesTotal: inputsTotal,
-			planned,
-			rulesTotal: countEnabledRuleIds(files, directories, projectRuleRuntimes),
-			startedAt: runStartedAt
-		});
-		await runConcurrently(filePlans.filter((filePlan) => filePlan.targets.length > 0), resolveFileConcurrency(options.runner?.fileConcurrency), (filePlan) => executeTargetPlans({
-			cache: cacheContext,
-			cacheOnly: options.cacheOnly,
-			clock,
-			counters,
-			diagnostics,
-			filesTotal: inputsTotal,
-			plans: [filePlan],
-			progress: options.progress,
-			signal: options.signal,
-			usage
-		}));
-		await runConcurrently(activeDirectoryPlans, resolveFileConcurrency(options.runner?.fileConcurrency), (directoryPlan) => executeTargetPlans({
-			cache: cacheContext,
-			cacheOnly: options.cacheOnly,
-			clock,
-			counters,
-			diagnostics,
-			filesTotal: inputsTotal,
-			plans: [directoryPlan],
-			progress: options.progress,
-			signal: options.signal,
-			usage
-		}));
-		if (projectPlan) await executeTargetPlans({
-			cache: cacheContext,
-			cacheOnly: options.cacheOnly,
-			clock,
-			counters,
-			diagnostics,
-			filesTotal: inputsTotal,
-			plans: [projectPlan],
-			progress: options.progress,
-			signal: options.signal,
-			usage
-		});
-	} catch (error) {
-		runError = error;
+		let cursor = 0;
+		const worker = async () => {
+			while (cursor < jobs.length) {
+				const index = cursor;
+				cursor += 1;
+				const job = jobs[index];
+				if (options.signal?.aborted) {
+					settledOutcomes[index] = {
+						bucket: {
+							diagnostics: [],
+							usage: []
+						},
+						cache: "miss",
+						job,
+						state: "cancelled"
+					};
+					continue;
+				}
+				try {
+					const startedAt = clock();
+					options.progress?.onJobStart?.({
+						job: job.job,
+						startedAt
+					});
+					settledOutcomes[index] = await executeRuleJob(job, {
+						cache: cacheContext,
+						cacheOnly: options.cacheOnly,
+						clock,
+						progress: options.progress,
+						runSignal: options.signal,
+						startedAt,
+						timeoutMs
+					});
+				} catch (error) {
+					if (!infrastructureFailed) {
+						infrastructureError = error;
+						infrastructureFailed = true;
+					}
+				}
+			}
+		};
+		await Promise.all(Array.from({ length: Math.min(concurrency, jobs.length) }, worker));
 	} finally {
 		if (!options.cacheOnly) await reconcileCache(filePlans, cacheContext);
-		try {
-			options.progress?.onRunEnd?.({
-				...counters.snapshot(planned),
-				diagnostics,
-				endedAt: clock(),
-				startedAt: runStartedAt ?? clock(),
-				usage: usage.toJSON()
-			});
-		} catch (error) {
-			runError ??= error;
-		}
 	}
+	const outcomes = Array.from({ length: jobs.length }, (_, index) => settledOutcomes[index] ?? {
+		bucket: {
+			diagnostics: [],
+			usage: []
+		},
+		cache: "miss",
+		job: jobs[index],
+		state: "cancelled"
+	});
+	const failedOutcomes = outcomes.filter((outcome) => outcome.state === "failed");
+	const failures = failedOutcomes.map((outcome) => outcome.failure);
 	const result = {
-		diagnostics,
-		execution: counters.snapshot(planned),
-		usage: usage.toJSON()
+		diagnostics: outcomes.flatMap((outcome) => outcome.bucket.diagnostics),
+		execution: executionCounts(outcomes),
+		usage: runUsage(outcomes)
 	};
-	if (runError) {
-		if (options.signal?.aborted) throw new AlintAbortError(result, { cause: runError });
-		throw createAlintRunError(runError, result);
-	}
-	return result;
-}
-function addTokenCount(base, value) {
-	return typeof value === "number" && Number.isFinite(value) ? base + value : base;
-}
-function calculatePlannedExecutions(filePlans) {
-	return filePlans.reduce((total, filePlan) => total + filePlan.planned, 0);
-}
-function countEnabledRuleIds(files, directories, projectRuleRuntimes) {
-	const ids = /* @__PURE__ */ new Set();
-	for (const file of files) for (const runtime of file.ruleRuntimes) ids.add(runtime.enabledRule.id);
-	for (const directory of directories) for (const runtime of directory.ruleRuntimes) ids.add(runtime.enabledRule.id);
-	for (const runtime of projectRuleRuntimes) ids.add(runtime.enabledRule.id);
-	return ids.size;
-}
-function createAlintRunError(error, result) {
-	if (error instanceof AlintRunError) return error;
-	if (error instanceof AlintRuleExecutionError) return new AlintRunError(error.message, result, {
-		cause: errorCauseFrom(error),
-		failure: error.failure
+	options.progress?.onRunEnd?.({
+		diagnostics: result.diagnostics,
+		endedAt: clock(),
+		execution: result.execution,
+		startedAt: runStartedAt,
+		usage: result.usage
 	});
-	return new AlintRunError(errorMessageFrom(error) ?? String(error), result, { cause: error });
-}
-function createRuleEndCounters() {
-	let cached = 0;
-	let completed = 0;
-	let errored = 0;
-	let skipped = 0;
-	return {
-		cache() {
-			cached += 1;
-		},
-		complete() {
-			completed += 1;
-		},
-		error() {
-			errored += 1;
-		},
-		skip() {
-			skipped += 1;
-		},
-		snapshot(planned) {
-			return {
-				cached,
-				completed,
-				errored,
-				planned,
-				skipped
-			};
-		}
-	};
+	if (infrastructureFailed) throw infrastructureError;
+	if (options.signal?.aborted) throw new AlintAbortError(result, { cause: options.signal.reason });
+	if (failures.length > 0) throw new AlintRunError(`${failures.length} rule execution${failures.length === 1 ? "" : "s"} failed.`, result, {
+		cause: new AggregateError(failedOutcomes.map((outcome) => outcome.cause), "Rule execution failures."),
+		failures
+	});
+	return result;
 }
 function createRuleRuntimes(options) {
-	const agent = options.effectiveAgent ? withAgentRetry(options.effectiveAgent, options.options.runner?.agentRetries) : void 0;
 	return options.registry.enabledRules.map((enabledRule) => {
 		const executionState = new AsyncLocalStorage();
 		const context = {
-			agent,
+			agent: options.effectiveAgent ? withAgentRetry((request) => options.effectiveAgent({
+				...request,
+				signal: combineAbortSignals(executionState.getStore()?.signal, request.signal)
+			}), options.options.runner?.agentRetries) : void 0,
 			cwd: options.cwd,
 			id: enabledRule.id,
 			localId: enabledRule.localId,
 			logger: { debug: () => {} },
 			metering: { recordUsage: (record) => {
-				const usageRecord = options.usage.record({
+				const state = executionState.getStore();
+				if (!state) throw new Error("Cannot record usage outside an active rule job.");
+				const usageRecord = {
 					...record,
 					ruleId: record.ruleId ?? enabledRule.id
-				});
-				const state = executionState.getStore();
-				state?.cacheUsage?.push(usageRecord);
-				options.options.progress?.onUsage?.({
-					path: state?.progressPath,
-					record: usageRecord,
-					total: options.usage.toJSON()
-				});
+				};
+				state.bucket.usage.push(usageRecord);
+				try {
+					options.progress?.onUsage?.({
+						job: state.job,
+						record: usageRecord
+					});
+				} catch (cause) {
+					if (!state.reporterFailed) {
+						state.reporterCause = cause;
+						state.reporterFailed = true;
+					}
+					throw cause;
+				}
 			} },
 			model: async (selector) => {
 				const request = options.options.modelOverride ?? (typeof selector === "string" ? selector : void 0);
@@ -1357,10 +1280,11 @@ function createRuleRuntimes(options) {
 			outputLanguage: options.options.outputLanguage,
 			report: (descriptor) => {
 				const state = executionState.getStore();
-				const filePath = descriptor.filePath ?? state?.activeFilePath;
+				if (!state) throw new Error("Cannot report a diagnostic outside an active rule job.");
+				const filePath = descriptor.filePath ?? state.activeFilePath;
 				if (!filePath) throw new Error(`Diagnostic for rule "${enabledRule.id}" is missing filePath.`);
-				const diagnosticModel = state?.currentModel ? { ...state.currentModel } : void 0;
-				if (state) state.currentModel = void 0;
+				const diagnosticModel = state.currentModel ? { ...state.currentModel } : void 0;
+				state.currentModel = void 0;
 				const diagnostic = {
 					evidence: descriptor.evidence,
 					filePath,
@@ -1370,16 +1294,24 @@ function createRuleRuntimes(options) {
 					ruleId: enabledRule.id,
 					severity: enabledRule.severity
 				};
-				options.diagnostics.push(diagnostic);
-				state?.cacheDiagnostics?.push(diagnostic);
-				options.options.progress?.onDiagnostic?.({
-					diagnostic,
-					diagnostics: [...options.diagnostics],
-					path: state?.progressPath
-				});
+				state.bucket.diagnostics.push(diagnostic);
+				try {
+					options.progress?.onDiagnostic?.({
+						diagnostic,
+						job: state.job
+					});
+				} catch (cause) {
+					if (!state.reporterFailed) {
+						state.reporterCause = cause;
+						state.reporterFailed = true;
+					}
+					throw cause;
+				}
 			},
 			settings: options.effectiveSettings,
-			signal: options.options.signal,
+			get signal() {
+				return executionState.getStore()?.signal;
+			},
 			src: options.src
 		};
 		return {
@@ -1399,47 +1331,19 @@ function createRuleRuntimes(options) {
 		};
 	});
 }
-function createUsageAccumulator() {
-	const live = createUsageTotals();
-	const cached = createUsageTotals();
-	return {
-		record(record) {
-			return live.record(record);
-		},
-		recordCached(record) {
-			return cached.record(record);
-		},
-		toJSON() {
-			const cachedUsage = cached.toJSON();
-			return {
-				...live.toJSON(),
-				...cachedUsage.records.length > 0 ? { cached: cachedUsage } : {}
-			};
-		}
-	};
-}
-function createUsageTotals() {
-	const records = [];
-	let inputTokens = 0;
-	let outputTokens = 0;
-	let totalTokens = 0;
-	return {
-		record(record) {
-			records.push(record);
-			inputTokens = addTokenCount(inputTokens, record.inputTokens);
-			outputTokens = addTokenCount(outputTokens, record.outputTokens);
-			totalTokens = addTokenCount(totalTokens, record.totalTokens);
-			return record;
-		},
-		toJSON() {
-			return {
-				inputTokens,
-				outputTokens,
-				records,
-				totalTokens
-			};
-		}
+function executionCounts(outcomes) {
+	const counts = {
+		cached: 0,
+		cancelled: 0,
+		completed: 0,
+		failed: 0,
+		planned: outcomes.length,
+		queued: 0,
+		running: 0,
+		skipped: 0
 	};
+	for (const outcome of outcomes) counts[outcome.state] += 1;
+	return counts;
 }
 function mergeCapabilities(base, extra) {
 	if (!base && !extra) return;
@@ -1475,28 +1379,19 @@ async function reconcileCache(filePlans, cacheContext) {
 		await cacheContext.store.reconcile();
 	} catch {}
 }
-function resolveFileConcurrency(fileConcurrency) {
-	return fileConcurrency ?? 1;
-}
-async function runConcurrently(items, concurrency, runItem) {
-	let firstError;
-	let nextIndex = 0;
-	const workerCount = Math.min(Math.max(concurrency, 1), items.length);
-	async function runWorker() {
-		while (firstError === void 0) {
-			const currentIndex = nextIndex;
-			nextIndex += 1;
-			if (currentIndex >= items.length) return;
-			try {
-				await runItem(items[currentIndex]);
-			} catch (error) {
-				firstError ??= error;
-				return;
-			}
-		}
-	}
-	await Promise.all(Array.from({ length: workerCount }, () => runWorker()));
-	if (firstError !== void 0) throw firstError;
+function resolveRuleConcurrency(ruleConcurrency) {
+	if (ruleConcurrency === void 0) return 4;
+	if (!Number.isFinite(ruleConcurrency) || !Number.isInteger(ruleConcurrency) || ruleConcurrency <= 0) throw new TypeError("Rule execution concurrency must be a finite positive integer.");
+	return ruleConcurrency;
+}
+function runUsage(outcomes) {
+	const live = [];
+	const cached = [];
+	for (const outcome of outcomes) (outcome.state === "cached" ? cached : live).push(...outcome.bucket.usage);
+	return {
+		...usageTotals(live),
+		...cached.length > 0 ? { cached: usageTotals(cached) } : {}
+	};
 }
 function toDiagnosticModel(model, request) {
 	return {
@@ -1505,12 +1400,20 @@ function toDiagnosticModel(model, request) {
 		resolvedId: model.id
 	};
 }
-function toProgressFilePath(filePlan, filesTotal) {
+function usageTotals(records) {
+	let inputTokens = 0;
+	let outputTokens = 0;
+	let totalTokens = 0;
+	for (const record of records) {
+		if (record.inputTokens != null && Number.isFinite(record.inputTokens)) inputTokens += record.inputTokens;
+		if (record.outputTokens != null && Number.isFinite(record.outputTokens)) outputTokens += record.outputTokens;
+		if (record.totalTokens != null && Number.isFinite(record.totalTokens)) totalTokens += record.totalTokens;
+	}
 	return {
-		index: filePlan.fileIndex,
-		path: filePlan.path,
-		planned: filePlan.planned,
-		total: filesTotal
+		inputTokens,
+		outputTokens,
+		records: [...records],
+		totalTokens
 	};
 }
 //#endregion
@@ -1525,4 +1428,4 @@ function defineRule(rule) {
 	return rule;
 }
 //#endregion
-export { AlintRunError, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange };
+export { AlintAbortError, AlintRunCancelledError, AlintRunError, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange };