@alint-js/core 0.1.4 → 0.2.0

package/dist/index.mjs

@@ -1,17 +1,18 @@
 import { o as withAgentRetry, t as combineAbortSignals } from "./agent-B6GG68NX.mjs";
 import { n as definePlugin, r as defineRule, t as defineConfig } from "./define-Da342Fcx.mjs";
-import { a as sliceRange, i as sliceLines, n as createSourceFile, r as createSourceRuntime, t as extractJsSourceTargets } from "./extract-CIWssxNK.mjs";
+import { a as createSourceFile, c as sliceRange, d as stableHash, i as SourceChangedError, l as withLanguage, n as targetIdentity, o as createSourceRuntime, r as withStableIdentities, s as sliceLines, t as extractJsSourceTargets, u as createStableHasher } from "./extract-BVbjWXMC.mjs";
 import { minimatch } from "minimatch";
-import { isAbsolute, relative, resolve } from "pathe";
+import { basename, extname, isAbsolute, relative, resolve } from "pathe";
 import { access, mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { basename, dirname, extname, isAbsolute as isAbsolute$1, join, relative as relative$1, resolve as resolve$1, sep } from "node:path";
+import { basename as basename$1, dirname, extname as extname$1, isAbsolute as isAbsolute$1, join, relative as relative$1, resolve as resolve$1, sep } from "node:path";
+import { randomUUID } from "node:crypto";
 import process, { cwd } from "node:process";
+import { array, boolean, check, custom, finite, getDotPath, literal, number, object, optional, parse, pipe, record, safeParse, string, union, unknown } from "valibot";
 import { Buffer } from "node:buffer";
-import { createHash, randomUUID } from "node:crypto";
 import { statSync } from "node:fs";
-import { array, boolean, check, custom, finite, getDotPath, literal, number, object, optional, parse, pipe, record, safeParse, string, union, unknown } from "valibot";
 import { errorMessageFrom } from "@moeru/std/error";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { streamText } from "@xsai/stream-text";
 //#region src/config/config-array.ts
 const effectiveBasePathSymbol = Symbol("effectiveBasePath");
 const inheritedMatcherScopesSymbol = Symbol("inheritedMatcherScopes");
@@ -242,16 +243,9 @@ const javascriptLanguage = {
 		".jsx",
 		".mjs"
 	],
-	extract: (file) => extractJsSourceTargets(withLanguage$1(file, "javascript")),
+	extract: (file) => extractJsSourceTargets(withLanguage(file, "javascript")),
 	name: "javascript"
 };
-function withLanguage$1(file, language) {
-	if (file.language === language) return file;
-	return {
-		...file,
-		language
-	};
-}
 //#endregion
 //#region src/core/languages/registry.ts
 function createLanguageRegistry$1() {
@@ -278,11 +272,11 @@ const textLanguage = {
 		file,
 		identity: "file",
 		kind: "file",
-		language: "text/plain",
+		language: "plaintext",
 		origin: { physicalPath: file.path },
 		text: file.text
 	}],
-	name: "text/plain"
+	name: "plaintext"
 };
 //#endregion
 //#region src/core/languages/ts/index.ts
@@ -296,20 +290,13 @@ const typescriptLanguage = {
 	extract: (file) => extractJsSourceTargets(withLanguage(file, "typescript")),
 	name: "typescript"
 };
-function withLanguage(file, language) {
-	if (file.language === language) return file;
-	return {
-		...file,
-		language
-	};
-}
 //#endregion
 //#region src/core/languages/resolve.ts
 function resolveLanguage(file, registry, options) {
 	return resolveLanguageForPath(file.path, registry, options);
 }
 function resolveLanguageForPath(filePath, registry, options) {
-	const languageName = options.language ?? options.processedLanguage ?? registry.byExtension.get(extname(filePath)) ?? "text/plain";
+	const languageName = options.language ?? options.processedLanguage ?? registry.byExtension.get(extname$1(filePath)) ?? "plaintext";
 	const language = registry.languages.get(languageName);
 	if (!language) throw new Error(`Unknown language "${languageName}".`);
 	return language;
@@ -324,41 +311,298 @@ function createBuiltInLanguageRegistry() {
 	return registry;
 }
 //#endregion
-//#region package.json
-var version = "0.1.4";
+//#region src/dsl/registry.ts
+function buildRuleRegistry(config) {
+	const rules = /* @__PURE__ */ new Map();
+	const localIds = /* @__PURE__ */ new Map();
+	const enabledRules = [];
+	for (const [alias, plugin] of Object.entries(config.plugins)) for (const [localId, rule] of Object.entries(plugin.rules ?? {})) {
+		const id = `${alias}/${localId}`;
+		if (rules.has(id)) throw new Error(`Duplicate rule id "${id}".`);
+		rules.set(id, rule);
+		localIds.set(id, localId);
+	}
+	for (const [id, entry] of Object.entries(config.rules)) {
+		const rule = rules.get(id);
+		if (!rule) throw new Error(`Unknown rule "${id}".`);
+		const normalizedEntry = normalizeRuleConfigEntry(entry);
+		const severity = normalizedEntry.severity;
+		if (severity === "off") continue;
+		enabledRules.push({
+			id,
+			localId: localIds.get(id) ?? id,
+			options: parseRuleOptions(id, rule.options, normalizedEntry.options),
+			rule,
+			severity
+		});
+	}
+	return {
+		enabledRules,
+		rules
+	};
+}
+function formatRuleOptionIssues(index, issues) {
+	return issues.map((issue) => {
+		const path = getDotPath(issue);
+		return path === null ? `"${index}": ${issue.message}` : `"${index}.${path}": ${issue.message}`;
+	}).join("; ");
+}
+function isRuleConfigTuple(entry) {
+	return Array.isArray(entry);
+}
+function normalizeRuleConfigEntry(entry) {
+	if (isRuleConfigTuple(entry)) {
+		const [severity = "warn", ...options] = entry;
+		return {
+			options,
+			severity
+		};
+	}
+	return {
+		options: [],
+		severity: entry ?? "warn"
+	};
+}
+function parseRuleOption(id, index, schema, value) {
+	const result = safeParse(schema, value);
+	if (result.success) return result.output;
+	if (value === void 0) {
+		const emptyObjectResult = safeParse(schema, {});
+		if (emptyObjectResult.success) return emptyObjectResult.output;
+	}
+	throw new TypeError(`Invalid options for rule "${id}": ${formatRuleOptionIssues(index, result.issues)}`);
+}
+function parseRuleOptions(id, schema, options) {
+	if (!schema) {
+		if (options.length > 0) throw new TypeError(`Rule "${id}" does not accept options.`);
+		return [];
+	}
+	if (options.length > schema.length) throw new TypeError(`Invalid options for rule "${id}": Unexpected option at index ${schema.length}.`);
+	return schema.map((optionSchema, index) => parseRuleOption(id, index, optionSchema, options[index]));
+}
 //#endregion
-//#region src/core/hash.ts
-function createStableHasher() {
-	const hash = createHash("sha256");
-	const api = {
-		digest: () => hash.digest("hex"),
-		update: (value) => {
-			const serialized = stableStringify(value);
-			hash.update(`${serialized.length}:`);
-			hash.update(serialized);
-			return api;
-		}
+//#region src/core/languages/diagnostics.ts
+/** A rule named a language and nothing registered it. This is a builtin rule. Not a real rule. */
+const MISSING_LANGUAGE_RULE = "alint/missing-language";
+/** A linted file's extension belongs to no registered language. This is a builtin rule. Not a real rule either. */
+const UNREGISTERED_LANGUAGE_RULE = "alint/unregistered-language";
+/**
+* One diagnostic per missing language, always an error: a rule scoped to a language nothing provides
+* matches no file, so leaving it at a warning would let a run pass having silently checked nothing.
+*/
+function missingLanguageDiagnostics(missing) {
+	return [...missing.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([languageId, entry]) => {
+		const ruleIds = [...entry.ruleIds].sort();
+		const subject = ruleIds.length === 1 ? `Rule "${ruleIds[0]}" needs` : `Rules ${ruleIds.map((id) => `"${id}"`).join(", ")} need`;
+		return {
+			filePath: entry.filePath,
+			message: `${subject} the "${languageId}" language, which no plugin registered. Add a plugin that provides "${languageId}", or turn the rule off.`,
+			ruleId: MISSING_LANGUAGE_RULE,
+			severity: "error"
+		};
+	});
+}
+/** Records one rule that named a language the config never registered, grouped by language id. */
+function recordMissingLanguage(into, languageId, ruleId, path) {
+	const existing = into.get(languageId);
+	if (existing === void 0) {
+		into.set(languageId, {
+			filePath: path,
+			ruleIds: /* @__PURE__ */ new Set([ruleId])
+		});
+		return;
+	}
+	existing.ruleIds.add(ruleId);
+	if (path < existing.filePath) existing.filePath = path;
+}
+/**
+* Records one linted file no language claimed, grouped by extension so a missing pack is one
+* diagnostic, not one per file. `'off'` records nothing.
+*/
+function recordUnregistered(into, path, severity) {
+	if (severity === "off") return;
+	const key = extname(path) || basename(path);
+	const existing = into.get(key);
+	into.set(key, {
+		count: (existing?.count ?? 0) + 1,
+		filePath: existing !== void 0 && existing.filePath < path ? existing.filePath : path,
+		severity: existing?.severity === "error" ? "error" : severity
+	});
+}
+/** One diagnostic per extension, sorted, for the run to prepend to its results. */
+function unregisteredLanguageDiagnostics(unregistered) {
+	return [...unregistered.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([extension, entry]) => ({
+		filePath: entry.filePath,
+		message: `No language is registered for "${extension}": ${entry.count} ${entry.count === 1 ? "file was" : "files were"} handled as plain text. Register one through a plugin's "languages", or pin \`language: 'plaintext'\` to accept plain text.`,
+		ruleId: UNREGISTERED_LANGUAGE_RULE,
+		severity: entry.severity
+	}));
+}
+function unregisteredLanguageSeverity(linterOptions) {
+	const value = linterOptions.reportUnregisteredLanguages;
+	return value === "error" || value === "off" ? value : "warn";
+}
+//#endregion
+//#region src/core/languages/rule-languages.ts
+/**
+* The language a file falls back to when no registered language claims its extension. Not a real
+* language, which is why `'any'` excludes it.
+*/
+const PLAIN_TEXT = "plaintext";
+/**
+* Whether a rule reads this target.
+*
+* A rule with language off still reads file targets, because reading raw text, or asking a model about a
+* whole file, needs no language. However, it never reads the function and class targets extraction produces.
+* `'file'` is the one kind every language yields, plain text included, so it is the dividing line.
+*
+* `'any'` means any real language, so a file that fell back to plain text because nothing claimed
+* its extension is withheld: the rule asked for structure and there is none to give. The run says so
+* once per extension through `alint/unregistered-language` rather than letting each rule report an
+* empty file.
+*/
+function isTargetLanguageAccepted(languages, targetKind, targetLanguage) {
+	if (languages.kind === "off") return targetKind === "file";
+	if (languages.kind === "any") return targetLanguage !== PLAIN_TEXT;
+	return languages.ids.includes(targetLanguage);
+}
+function resolveRuleLanguages(languages) {
+	if (languages === void 0) return { kind: "off" };
+	if (languages === "any") return { kind: "any" };
+	if ("ids" in languages) return {
+		ids: languages.ids,
+		kind: "list",
+		skipMissing: languages.skipMissing ?? false
+	};
+	return {
+		ids: languages,
+		kind: "list",
+		skipMissing: false
+	};
+}
+//#endregion
+//#region src/core/preparation.ts
+/**
+* The `ctx.src.extract` a run hands to rules, for parsing files it was never asked to lint, which
+* an index builder sweeping the workspace needs.
+*
+* It resolves each file's OWN config rather than a caller's, because the language a file resolves to
+* is a config decision and two config groups may register different plugins. It extracts on demand
+* and holds nothing: source planning releases rich extractor values after compact jobs are admitted,
+* and a run-wide parse memo here would put that retention back. A caller keeps only what it derives.
+*
+* `getSrc` defers reading the runtime because the runtime is built around this closure. It is assigned
+* before any rule runs, so by the first call it is present.
+*/
+function createSourceExtractor(cwd, config, getSrc) {
+	return async (filePath, options = {}) => {
+		const path = resolve(cwd, filePath);
+		const resolvedConfig = resolveConfigForFile(path, config, { cwd });
+		if (resolvedConfig.ignored) return [];
+		const effectiveConfig = resolvedConfig.config;
+		const language = resolveLanguageForPath(path, createLanguageRegistry(effectiveConfig), { language: options.language ?? effectiveConfig.language });
+		const src = getSrc();
+		const file = await src.readFile(path);
+		return language.extract(file, {
+			cwd,
+			languageOptions: effectiveConfig.languageOptions,
+			src
+		});
+	};
+}
+function prepareRun(options = {}) {
+	const cwd$2 = options.cwd ?? cwd();
+	const config = options.config ?? [];
+	const files = [];
+	const directories = [];
+	const missingLanguages = /* @__PURE__ */ new Map();
+	const unregisteredLanguages = /* @__PURE__ */ new Map();
+	for (const filePath of options.files ?? []) {
+		const path = resolve(cwd$2, filePath);
+		const resolvedConfig = resolveConfigForFile(path, config, { cwd: cwd$2 });
+		if (resolvedConfig.ignored) continue;
+		const effectiveConfig = resolvedConfig.config;
+		const languageRegistry = createLanguageRegistry(effectiveConfig);
+		const language = resolveLanguageForPath(path, languageRegistry, { language: effectiveConfig.language });
+		const rules = prepareRules(effectiveConfig);
+		recordMissingLanguages(missingLanguages, rules, languageRegistry, path);
+		if (effectiveConfig.language === void 0 && language.name === "plaintext" && rules.some(({ enabledRule }) => !isTargetLanguageAccepted(resolveRuleLanguages(enabledRule.rule.languages), "file", "plaintext"))) recordUnregistered(unregisteredLanguages, path, unregisteredLanguageSeverity(effectiveConfig.linterOptions));
+		files.push({
+			agent: effectiveConfig.agent,
+			configHash: stableHash({
+				language: effectiveConfig.language,
+				languageOptions: effectiveConfig.languageOptions,
+				processor: effectiveConfig.processor,
+				resolvedLanguage: language.name,
+				settings: effectiveConfig.settings
+			}),
+			fileIndex: files.length,
+			language,
+			languageOptions: effectiveConfig.languageOptions,
+			path,
+			rules,
+			settings: effectiveConfig.settings
+		});
+	}
+	for (const directoryPath of options.directories ?? []) {
+		const path = resolve(cwd$2, directoryPath);
+		const resolvedConfig = resolveConfigForDirectory(path, config, { cwd: cwd$2 });
+		if (resolvedConfig.ignored) continue;
+		const effectiveConfig = resolvedConfig.config;
+		directories.push({
+			agent: effectiveConfig.agent,
+			configHash: stableHash({ settings: effectiveConfig.settings }),
+			directoryIndex: directories.length,
+			rules: prepareRules(effectiveConfig),
+			settings: effectiveConfig.settings,
+			target: {
+				kind: "directory",
+				path
+			}
+		});
+	}
+	return {
+		directories,
+		files,
+		missingLanguages,
+		project: options.projectTargets === false ? void 0 : prepareProject(cwd$2, config),
+		unregisteredLanguages
 	};
-	return api;
 }
-function hashText(text) {
-	return createHash("sha256").update(text).digest("hex");
+function createLanguageRegistry(config) {
+	const registry = createBuiltInLanguageRegistry();
+	for (const plugin of Object.values(config.plugins)) for (const language of Object.values(plugin.languages ?? {})) registerLanguage(registry, language);
+	return registry;
+}
+function prepareProject(root, config) {
+	const resolvedConfig = resolveConfigForProject(root, config, { cwd: root });
+	if (resolvedConfig.ignored) return void 0;
+	const effectiveConfig = resolvedConfig.config;
+	return {
+		agent: effectiveConfig.agent,
+		configHash: stableHash({ settings: effectiveConfig.settings }),
+		root,
+		rules: prepareRules(effectiveConfig),
+		settings: effectiveConfig.settings
+	};
 }
-function stableHash(value) {
-	return hashText(stableStringify(value));
+function prepareRules(config) {
+	return buildRuleRegistry(config).enabledRules.map((enabledRule, ruleIndex) => ({
+		enabledRule,
+		ruleIndex
+	}));
 }
-function stableStringify(value) {
-	if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-	if (typeof value === "object" && value !== null) {
-		const record = value;
-		return `{${Object.keys(record).sort().flatMap((key) => {
-			const property = record[key];
-			return property === void 0 ? [] : [`${JSON.stringify(key)}:${stableStringify(property)}`];
-		}).join(",")}}`;
+function recordMissingLanguages(into, rules, registry, path) {
+	for (const { enabledRule } of rules) {
+		const languages = resolveRuleLanguages(enabledRule.rule.languages);
+		if (languages.kind !== "list" || languages.skipMissing) continue;
+		for (const languageId of languages.ids) if (!registry.languages.has(languageId)) recordMissingLanguage(into, languageId, enabledRule.id, path);
 	}
-	return JSON.stringify(value);
 }
 //#endregion
+//#region package.json
+var version = "0.2.0";
+//#endregion
 //#region src/core/cache/types.ts
 const CACHE_MAGIC = "ALINT_CACHE";
 //#endregion
@@ -704,7 +948,7 @@ function parseCacheBody(text) {
 async function persistCacheBody(location, header, body, writeFile) {
 	const validatedBody = parse(CacheFileBodySchema, body);
 	await mkdir(dirname(location), { recursive: true });
-	const tempPath = join(dirname(location), `.${basename(location)}.${process.pid}.${randomUUID()}.tmp`);
+	const tempPath = join(dirname(location), `.${basename$1(location)}.${process.pid}.${randomUUID()}.tmp`);
 	try {
 		await writeFile(tempPath, `${header}\n${JSON.stringify(validatedBody)}\n`);
 		await rename(tempPath, location);
@@ -836,7 +1080,7 @@ async function executeRuleJob(job, options) {
 	let handlerCause;
 	let handlerFailed = false;
 	try {
-		await job.execution.runtime.executionState.run(state, job.execution.run);
+		await job.execution.runtime.executionState.run(state, () => runHandler(job));
 	} catch (cause) {
 		if (state.reporterFailed) throw state.reporterCause;
 		handlerCause = cause;
@@ -858,7 +1102,7 @@ async function executeRuleJob(job, options) {
 	});
 	if (handlerFailed) return finish(job, bucket, {
 		cache: "miss",
-		failure: failure(handlerCause, job, "handler"),
+		failure: failure(handlerCause, job, handlerCause instanceof SourceChangedError ? "source-changed" : "handler"),
 		state: "failed"
 	});
 	if (slot && fingerprint) try {
@@ -910,16 +1154,7 @@ function createFingerprint(job, modelHash) {
 	};
 }
 function createTargetHash(job) {
-	const target = job.target;
-	return target.cacheTargetHash ?? stableHash({
-		language: target.language,
-		loc: target.loc,
-		metadata: target.metadata,
-		name: target.name,
-		origin: target.origin,
-		range: target.range,
-		text: target.text
-	});
+	return job.target.cacheTargetHash;
 }
 function failure(cause, job, kind) {
 	return {
@@ -979,6 +1214,44 @@ function replayCachedEntry(entry, bucket, job, progress, runProgress) {
 		});
 	}
 }
+/**
+* Dispatches one compact job descriptor to its registered rule handler.
+*
+* Triggering workflow:
+*
+* {@link executeRuleJob}
+*   -> {@link runHandler}
+*     -> `RuleHandlers.onTarget*`
+*
+* Upstream:
+* - {@link executeRuleJob}
+*
+* Downstream:
+* - `RuleRuntime.handlers`
+*/
+function runHandler(job) {
+	const { handlers } = job.execution.runtime;
+	const target = job.target.descriptor;
+	switch (job.execution.handler) {
+		case "class":
+			if (target.kind !== "class") throw new TypeError(`Expected class target, received "${target.kind}".`);
+			return handlers.onTargetClass?.(target);
+		case "directory":
+			if (target.kind !== "directory") throw new TypeError(`Expected directory target, received "${target.kind}".`);
+			return handlers.onTargetDirectory?.(target);
+		case "file":
+			if (target.kind !== "file") throw new TypeError(`Expected file target, received "${target.kind}".`);
+			return handlers.onTargetFile?.(target);
+		case "function":
+			if (target.kind !== "function") throw new TypeError(`Expected function target, received "${target.kind}".`);
+			return handlers.onTargetFunction?.(target);
+		case "language-declaration-error": throw new Error(`Rule "${job.execution.runtime.enabledRule.id}" handles function or class targets but declares no "languages", so it receives none. Declare \`languages: 'any'\`, or list the language ids it handles.`);
+		case "project":
+			if (target.kind !== "project") throw new TypeError(`Expected project target, received "${target.kind}".`);
+			return handlers.onTargetProject?.(target);
+		case "with": return handlers.onTargetWith?.(target);
+	}
+}
 function scopeRank(scope) {
 	if (scope === "source") return 0;
 	if (scope === "directory") return 1;
@@ -989,33 +1262,44 @@ function scopeRank(scope) {
 function createRunProgress(filesTotal) {
 	assertNonNegativeInteger(filesTotal, "File total");
 	const execution = createCounts();
-	let final = false;
+	let filesPlanned = 0;
+	let planningComplete = false;
 	const snapshot = () => {
 		const jobsCompleted = terminalCount(execution);
 		return {
 			execution: { ...execution },
+			filesPlanned,
 			filesTotal,
-			final,
 			jobsCompleted,
 			jobsStarted: jobsCompleted + execution.running,
-			jobsTotal: execution.planned
+			jobsTotal: execution.planned,
+			planningComplete
 		};
 	};
 	return {
+		completeFilePlanning: () => {
+			if (planningComplete) throw new Error("Cannot complete file planning after planning is complete.");
+			if (filesPlanned >= filesTotal) throw new Error("Cannot complete planning for more files than the file total.");
+			filesPlanned += 1;
+			return snapshot();
+		},
+		completePlanning: () => {
+			planningComplete = true;
+			return snapshot();
+		},
 		finalize: () => {
 			if (execution.queued !== 0 || execution.running !== 0) throw new Error("Cannot finalize progress while jobs are queued or running.");
-			final = true;
+			if (!planningComplete) throw new Error("Cannot finalize progress before planning is complete.");
 			return snapshot();
 		},
 		finish: (from, to) => {
-			assertMutable(final);
 			if (execution[from] <= 0) throw new Error(`Cannot finish a job without a ${from} job.`);
 			execution[from] -= 1;
 			execution[to] += 1;
 			return snapshot();
 		},
 		queue: (count = 1) => {
-			assertMutable(final);
+			if (planningComplete) throw new Error("Cannot queue work after planning is complete.");
 			assertNonNegativeInteger(count, "Queued job count");
 			assertSafeSum(execution.planned, count, "Planned job count");
 			assertSafeSum(execution.queued, count, "Queued job count");
@@ -1025,7 +1309,6 @@ function createRunProgress(filesTotal) {
 		},
 		snapshot,
 		start: () => {
-			assertMutable(final);
 			if (execution.queued <= 0) throw new Error("Cannot start a job without a queued job.");
 			execution.queued -= 1;
 			execution.running += 1;
@@ -1033,9 +1316,6 @@ function createRunProgress(filesTotal) {
 		}
 	};
 }
-function assertMutable(final) {
-	if (final) throw new Error("Cannot update finalized progress.");
-}
 function assertNonNegativeInteger(value, name) {
 	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError(`${name} must be a non-negative integer.`);
 }
@@ -1334,6 +1614,9 @@ var RuleScheduler = class {
 		this.settleClose();
 		return this.closePromise;
 	}
+	completeFilePlanning() {
+		return this.options.progress.completeFilePlanning();
+	}
 	schedule(jobs) {
 		if (!this.accepting || jobs.length === 0) return {
 			jobsAdded: 0,
@@ -1568,152 +1851,6 @@ function createLane() {
 	};
 }
 //#endregion
-//#region src/dsl/registry.ts
-function buildRuleRegistry(config) {
-	const rules = /* @__PURE__ */ new Map();
-	const localIds = /* @__PURE__ */ new Map();
-	const enabledRules = [];
-	for (const [alias, plugin] of Object.entries(config.plugins)) for (const [localId, rule] of Object.entries(plugin.rules ?? {})) {
-		const id = `${alias}/${localId}`;
-		if (rules.has(id)) throw new Error(`Duplicate rule id "${id}".`);
-		rules.set(id, rule);
-		localIds.set(id, localId);
-	}
-	for (const [id, entry] of Object.entries(config.rules)) {
-		const rule = rules.get(id);
-		if (!rule) throw new Error(`Unknown rule "${id}".`);
-		const normalizedEntry = normalizeRuleConfigEntry(entry);
-		const severity = normalizedEntry.severity;
-		if (severity === "off") continue;
-		enabledRules.push({
-			id,
-			localId: localIds.get(id) ?? id,
-			options: parseRuleOptions(id, rule.options, normalizedEntry.options),
-			rule,
-			severity
-		});
-	}
-	return {
-		enabledRules,
-		rules
-	};
-}
-function formatRuleOptionIssues(index, issues) {
-	return issues.map((issue) => {
-		const path = getDotPath(issue);
-		return path === null ? `"${index}": ${issue.message}` : `"${index}.${path}": ${issue.message}`;
-	}).join("; ");
-}
-function isRuleConfigTuple(entry) {
-	return Array.isArray(entry);
-}
-function normalizeRuleConfigEntry(entry) {
-	if (isRuleConfigTuple(entry)) {
-		const [severity = "warn", ...options] = entry;
-		return {
-			options,
-			severity
-		};
-	}
-	return {
-		options: [],
-		severity: entry ?? "warn"
-	};
-}
-function parseRuleOption(id, index, schema, value) {
-	const result = safeParse(schema, value);
-	if (result.success) return result.output;
-	if (value === void 0) {
-		const emptyObjectResult = safeParse(schema, {});
-		if (emptyObjectResult.success) return emptyObjectResult.output;
-	}
-	throw new TypeError(`Invalid options for rule "${id}": ${formatRuleOptionIssues(index, result.issues)}`);
-}
-function parseRuleOptions(id, schema, options) {
-	if (!schema) {
-		if (options.length > 0) throw new TypeError(`Rule "${id}" does not accept options.`);
-		return [];
-	}
-	if (options.length > schema.length) throw new TypeError(`Invalid options for rule "${id}": Unexpected option at index ${schema.length}.`);
-	return schema.map((optionSchema, index) => parseRuleOption(id, index, optionSchema, options[index]));
-}
-//#endregion
-//#region src/core/preparation.ts
-function prepareRun(options = {}) {
-	const cwd$2 = options.cwd ?? cwd();
-	const config = options.config ?? [];
-	const files = [];
-	const directories = [];
-	for (const filePath of options.files ?? []) {
-		const path = resolve(cwd$2, filePath);
-		const resolvedConfig = resolveConfigForFile(path, config, { cwd: cwd$2 });
-		if (resolvedConfig.ignored) continue;
-		const effectiveConfig = resolvedConfig.config;
-		const language = resolveLanguageForPath(path, createLanguageRegistry(effectiveConfig), { language: effectiveConfig.language });
-		files.push({
-			agent: effectiveConfig.agent,
-			configHash: stableHash({
-				language: effectiveConfig.language,
-				languageOptions: effectiveConfig.languageOptions,
-				processor: effectiveConfig.processor,
-				resolvedLanguage: language.name,
-				settings: effectiveConfig.settings
-			}),
-			fileIndex: files.length,
-			language,
-			languageOptions: effectiveConfig.languageOptions,
-			path,
-			rules: prepareRules(effectiveConfig),
-			settings: effectiveConfig.settings
-		});
-	}
-	for (const directoryPath of options.directories ?? []) {
-		const path = resolve(cwd$2, directoryPath);
-		const resolvedConfig = resolveConfigForDirectory(path, config, { cwd: cwd$2 });
-		if (resolvedConfig.ignored) continue;
-		const effectiveConfig = resolvedConfig.config;
-		directories.push({
-			agent: effectiveConfig.agent,
-			configHash: stableHash({ settings: effectiveConfig.settings }),
-			directoryIndex: directories.length,
-			rules: prepareRules(effectiveConfig),
-			settings: effectiveConfig.settings,
-			target: {
-				kind: "directory",
-				path
-			}
-		});
-	}
-	return {
-		directories,
-		files,
-		project: options.projectTargets === false ? void 0 : prepareProject(cwd$2, config)
-	};
-}
-function createLanguageRegistry(config) {
-	const registry = createBuiltInLanguageRegistry();
-	for (const plugin of Object.values(config.plugins)) for (const language of Object.values(plugin.languages ?? {})) registerLanguage(registry, language);
-	return registry;
-}
-function prepareProject(root, config) {
-	const resolvedConfig = resolveConfigForProject(root, config, { cwd: root });
-	if (resolvedConfig.ignored) return void 0;
-	const effectiveConfig = resolvedConfig.config;
-	return {
-		agent: effectiveConfig.agent,
-		configHash: stableHash({ settings: effectiveConfig.settings }),
-		root,
-		rules: prepareRules(effectiveConfig),
-		settings: effectiveConfig.settings
-	};
-}
-function prepareRules(config) {
-	return buildRuleRegistry(config).enabledRules.map((enabledRule, ruleIndex) => ({
-		enabledRule,
-		ruleIndex
-	}));
-}
-//#endregion
 //#region src/core/project/index.ts
 var ProjectIndexBuilder = class {
 	files = [];
@@ -1767,7 +1904,7 @@ var ProjectIndexBuilder = class {
 	}
 };
 function createProjectJobs(options) {
-	const executions = options.runtimes.map((runtime) => projectExecution(runtime, options.project.target)).filter((execution) => execution !== void 0);
+	const executions = options.runtimes.map((runtime) => projectExecution(runtime)).filter((execution) => execution !== void 0);
 	if (executions.length === 0) return { jobs: [] };
 	const owner = options.cacheStore.beginOwner({
 		kind: "project",
@@ -1777,10 +1914,9 @@ function createProjectJobs(options) {
 		cacheOwner: owner,
 		cacheTargetHash: options.project.hash,
 		configHash: options.configHash,
+		descriptor: options.project.target,
 		identity: "project",
-		kind: "project",
-		language: "project",
-		text: options.project.hash
+		kind: "project"
 	};
 	return {
 		jobs: executions.map((execution) => {
@@ -1845,125 +1981,108 @@ function copyTargetSnapshot(target) {
 		semanticHash: target.semanticHash
 	};
 }
-function projectExecution(runtime, target) {
+function projectExecution(runtime) {
 	if (runtime.handlers.onTargetWith) return {
-		run: () => runtime.handlers.onTargetWith?.(target),
+		handler: "with",
 		runtime
 	};
 	if (runtime.handlers.onTargetProject) return {
-		run: () => runtime.handlers.onTargetProject?.(target),
+		handler: "project",
 		runtime
 	};
 }
-async function executeSourceSession(input, options) {
-	openSession(options.metrics);
+//#endregion
+//#region src/core/source/planner.ts
+/**
+* Converts one rich extractor result into detached descriptors and admits its compact jobs.
+*
+* The returned outcome promise captures only cache ownership and hashes. This function does not
+* await rule execution, so its `SourceFile`, parser output, and rich targets become unreachable
+* when planning returns.
+*/
+async function planSource(input, options) {
+	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
+	let file;
 	try {
-		if (options.signal?.aborted) return { outcomes: [] };
-		let file;
-		try {
-			file = await options.src.readFile(input.path);
-		} catch (error) {
-			return {
-				failure: fileFailure(input, "read", failureMessage(error, "Failed to read source file.")),
-				outcomes: []
-			};
-		}
-		if (options.signal?.aborted) return { outcomes: [] };
-		let targets;
-		try {
-			targets = await input.language.extract(file, {
-				cwd: options.cwd,
-				languageOptions: input.languageOptions,
-				src: options.src
-			});
-		} catch (error) {
-			return {
-				failure: fileFailure(input, "extract", failureMessage(error, "Failed to extract source targets.")),
-				outcomes: []
-			};
-		}
-		const contentHash = hashText(file.text);
-		const project = options.projectSnapshots === false ? void 0 : createProjectSnapshot(input, file.language, file.path, contentHash, targets);
-		const cacheOwner = options.cacheStore.beginOwner({
+		file = await options.src.readFile(input.path);
+	} catch (error) {
+		reportFilePlanningComplete(input, 0, options);
+		return {
+			failure: fileFailure(input, "read", failureMessage(error, "Failed to read source file.")),
+			outcomes: Promise.resolve([])
+		};
+	}
+	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
+	let targets;
+	try {
+		targets = await input.language.extract(file, {
+			cwd: options.cwd,
+			languageOptions: input.languageOptions,
+			src: options.src
+		});
+	} catch (error) {
+		reportFilePlanningComplete(input, 0, options);
+		return {
+			failure: fileFailure(input, "extract", failureMessage(error, "Failed to extract source targets.")),
+			outcomes: Promise.resolve([])
+		};
+	}
+	const { contentHash } = file;
+	let cacheOwner;
+	let jobs;
+	let project;
+	try {
+		project = options.projectSnapshots === false ? void 0 : createProjectSnapshot(input, file.language, file.path, contentHash, targets);
+		cacheOwner = options.cacheStore.beginOwner({
 			kind: "file",
 			path: file.path
 		});
-		const jobs = createSourceJobs(input, createExecutionTargets(input, targets, options.ruleRuntimes, options.cwd, cacheOwner));
-		if (options.signal?.aborted) {
-			cacheOwner.commit({
-				contentHash,
-				mode: "merge"
-			});
-			return {
-				outcomes: [],
-				project
-			};
-		}
-		const batch = options.scheduler.schedule(jobs);
-		try {
-			options.progress?.onFileReady?.({
-				fileIndex: input.fileIndex,
-				inputPath: input.path,
-				jobsAdded: batch.jobsAdded,
-				progress: options.scheduler.snapshot()
-			});
-		} catch (error) {
-			options.scheduler.cancelWithError(error);
-			throw error;
-		}
-		const outcomes = await batch.outcomes;
-		cacheOwner.commit(options.signal?.aborted ? {
+		const baseFile = {
+			contentHash,
+			language: file.language,
+			path: file.path
+		};
+		jobs = createSourceJobs(input, createExecutionTargets(input, targets, baseFile, options.ruleRuntimes, options.cwd, cacheOwner));
+	} catch (error) {
+		reportFilePlanningComplete(input, 0, options);
+		return {
+			failure: fileFailure(input, "extract", failureMessage(error, "Failed to plan source targets.")),
+			outcomes: Promise.resolve([])
+		};
+	}
+	if (options.signal?.aborted) {
+		cacheOwner.commit({
 			contentHash,
 			mode: "merge"
-		} : { contentHash });
+		});
 		return {
-			outcomes,
+			outcomes: Promise.resolve([]),
 			project
 		};
-	} finally {
-		closeSession(options.metrics);
-	}
-}
-async function executeSourceSessions(inputs, options) {
-	const results = new Array(inputs.length);
-	let cursor = 0;
-	let firstError;
-	let failed = false;
-	let stopping = false;
-	const workerCount = Math.min(options.sourceWindow, inputs.length);
-	const workers = Array.from({ length: workerCount }, async () => {
-		while (!stopping && !options.signal?.aborted) {
-			const index = cursor;
-			cursor += 1;
-			const input = inputs[index];
-			if (!input) return;
-			try {
-				results[index] = await executeSourceSession(input, {
-					...options,
-					ruleRuntimes: options.createRuleRuntimes(input)
-				});
-			} catch (error) {
-				stopping = true;
-				if (!failed) {
-					failed = true;
-					firstError = error;
-				}
-			}
-		}
-	});
-	await Promise.all(workers);
-	if (failed) throw firstError;
-	return results.filter((result) => result !== void 0);
-}
-function resolveSourceWindow(ruleConcurrency) {
-	return Math.max(1, Math.min(ruleConcurrency, 4));
+	}
+	const batch = options.scheduler.schedule(jobs);
+	reportFilePlanningComplete(input, batch.jobsAdded, options);
+	return {
+		outcomes: batch.outcomes.then((settled) => {
+			cacheOwner.commit(options.signal?.aborted ? {
+				contentHash,
+				mode: "merge"
+			} : { contentHash });
+			return settled;
+		}),
+		project
+	};
 }
-function closeSession(metrics) {
-	if (!metrics) return;
-	metrics.active -= 1;
-	metrics.closed += 1;
+/**
+* Starts every input plan independently and preserves input-ordered results.
+*/
+async function planSources(inputs, options) {
+	return Promise.all(inputs.map((input) => planSource(input, {
+		...options,
+		ruleRuntimes: options.createRuleRuntimes(input)
+	})));
 }
-function createExecutionTargets(input, targets, runtimes, cwd, cacheOwner) {
+function createExecutionTargets(input, targets, file, runtimes, cwd, cacheOwner) {
 	const resolveIdentity = createTargetIdentityResolver(targets.map((target) => ({
 		filePath: target.kind === "file" ? normalizeCachePath(cwd, input.path) : void 0,
 		identity: target.identity,
@@ -1971,32 +2090,50 @@ function createExecutionTargets(input, targets, runtimes, cwd, cacheOwner) {
 		name: target.name,
 		range: target.range
 	})));
-	return targets.map((target, targetIndex) => {
+	return targets.flatMap((target, targetIndex) => {
+		const executions = runtimes.map((runtime) => sourceExecution(runtime, target.kind, target.language)).filter((execution) => execution !== void 0);
+		if (executions.length === 0) return [];
+		const identity = resolveIdentity({
+			filePath: target.kind === "file" ? normalizeCachePath(cwd, input.path) : void 0,
+			identity: target.identity,
+			kind: target.kind,
+			name: target.name,
+			range: target.range
+		}, targetIndex);
+		const plannedTarget = {
+			file,
+			identity: target.identity,
+			kind: target.kind,
+			language: target.language,
+			loc: target.loc && {
+				end: { ...target.loc.end },
+				start: { ...target.loc.start }
+			},
+			metadata: snapshotMetadata(target.metadata),
+			name: target.name,
+			origin: target.origin && {
+				...target.origin,
+				range: target.origin.range && { ...target.origin.range }
+			},
+			range: target.range && { ...target.range }
+		};
 		return {
-			executions: runtimes.map((runtime) => sourceExecution(runtime, target)).filter((execution) => execution !== void 0),
+			executions,
 			target: {
 				activeFilePath: input.path,
 				cacheOwner,
+				cacheTargetHash: targetSemanticHash(target),
 				configHash: input.configHash,
-				identity: resolveIdentity({
-					filePath: target.kind === "file" ? normalizeCachePath(cwd, input.path) : void 0,
-					identity: target.identity,
-					kind: target.kind,
-					name: target.name,
-					range: target.range
-				}, targetIndex),
+				descriptor: plannedTarget,
+				identity,
 				kind: target.kind,
-				language: target.language,
 				loc: target.loc,
-				metadata: target.metadata,
 				name: target.name,
-				origin: target.origin,
-				range: target.range,
-				text: target.text
+				range: target.range
 			},
 			targetIndex
 		};
-	}).filter((target) => target.executions.length > 0);
+	});
 }
 function createProjectSnapshot(input, language, path, contentHash, targets) {
 	return {
@@ -2016,15 +2153,7 @@ function createProjectSnapshot(input, language, path, contentHash, targets) {
 				...target.name === void 0 ? {} : { name: target.name },
 				...target.range === void 0 ? {} : { range: { ...target.range } }
 			},
-			semanticHash: stableHash({
-				language: target.language,
-				loc: target.loc,
-				metadata: target.metadata,
-				name: target.name,
-				origin: target.origin,
-				range: target.range,
-				text: target.text
-			})
+			semanticHash: targetSemanticHash(target)
 		}))
 	};
 }
@@ -2077,36 +2206,81 @@ function fileFailure(input, kind, message) {
 		message
 	};
 }
-function openSession(metrics) {
-	if (!metrics) return;
-	metrics.active += 1;
-	metrics.opened += 1;
-	metrics.maximumActive = Math.max(metrics.maximumActive, metrics.active);
+function reportFilePlanningComplete(input, jobsAdded, options) {
+	try {
+		const progress = options.scheduler.completeFilePlanning();
+		options.progress?.onFileReady?.({
+			fileIndex: input.fileIndex,
+			inputPath: input.path,
+			jobsAdded,
+			progress
+		});
+	} catch (error) {
+		options.scheduler.cancelWithError(error);
+		throw error;
+	}
 }
-function sourceExecution(runtime, target) {
+function snapshotMetadata(metadata) {
+	if (metadata === void 0) return void 0;
+	return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [key, snapshotMetadataValue(value, /* @__PURE__ */ new WeakSet())]));
+}
+function snapshotMetadataValue(value, ancestors) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value !== "object") throw new TypeError("Source target metadata must contain only finite JSON data.");
+	if (ancestors.has(value)) throw new TypeError("Source target metadata must not contain cycles.");
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) return value.map((item) => snapshotMetadataValue(item, ancestors));
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) throw new TypeError("Source target metadata must contain only plain objects and arrays.");
+		return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, snapshotMetadataValue(item, ancestors)]));
+	} finally {
+		ancestors.delete(value);
+	}
+}
+function sourceExecution(runtime, kind, language) {
+	const languages = resolveRuleLanguages(runtime.enabledRule.rule.languages);
+	if (languages.kind === "off" && kind === "file" && (runtime.handlers.onTargetClass ?? runtime.handlers.onTargetFunction)) return {
+		handler: "language-declaration-error",
+		runtime
+	};
+	if (!isTargetLanguageAccepted(languages, kind, language)) return void 0;
 	if (runtime.handlers.onTargetWith) return {
-		run: () => runtime.handlers.onTargetWith?.(target),
+		handler: "with",
 		runtime
 	};
-	if (target.kind === "class" && runtime.handlers.onTargetClass) return {
-		run: () => runtime.handlers.onTargetClass?.(target),
+	if (kind === "class" && runtime.handlers.onTargetClass) return {
+		handler: "class",
 		runtime
 	};
-	if (target.kind === "file" && runtime.handlers.onTargetFile) return {
-		run: () => runtime.handlers.onTargetFile?.(target),
+	if (kind === "file" && runtime.handlers.onTargetFile) return {
+		handler: "file",
 		runtime
 	};
-	if (target.kind === "function" && runtime.handlers.onTargetFunction) return {
-		run: () => runtime.handlers.onTargetFunction?.(target),
+	if (kind === "function" && runtime.handlers.onTargetFunction) return {
+		handler: "function",
 		runtime
 	};
 }
+/** Keeps per-rule cache fingerprints and compact project snapshots on one semantic target identity. */
+function targetSemanticHash(target) {
+	return stableHash({
+		language: target.language,
+		loc: target.loc,
+		metadata: target.metadata,
+		name: target.name,
+		origin: target.origin,
+		range: target.range,
+		text: target.text
+	});
+}
 //#endregion
 //#region src/core/targets/directory.ts
 function createDirectoryJobs(input, runtimes) {
 	const target = input.target;
 	return runtimes.flatMap((runtime) => {
-		const execution = directoryExecution(runtime, target);
+		const execution = directoryExecution(runtime);
 		if (!execution) return [];
 		const ruleId = runtime.enabledRule.id;
 		return [{
@@ -2134,22 +2308,22 @@ function createDirectoryJobs(input, runtimes) {
 			},
 			target: {
 				activeFilePath: target.path,
+				cacheTargetHash: stableHash(target),
 				configHash: input.configHash,
+				descriptor: target,
 				identity: target.path,
-				kind: "directory",
-				language: "directory",
-				text: target.path
+				kind: "directory"
 			}
 		}];
 	});
 }
-function directoryExecution(runtime, target) {
+function directoryExecution(runtime) {
 	if (runtime.handlers.onTargetWith) return {
-		run: () => runtime.handlers.onTargetWith?.(target),
+		handler: "with",
 		runtime
 	};
 	if (runtime.handlers.onTargetDirectory) return {
-		run: () => runtime.handlers.onTargetDirectory?.(target),
+		handler: "directory",
 		runtime
 	};
 }
@@ -2199,11 +2373,12 @@ async function runAlint(options = {}) {
 		startedAt: runStartedAt
 	});
 	const cwd$1 = options.cwd ?? cwd();
+	const config = options.config ?? [];
 	const setupConfig = options.setupConfig ?? {
 		providers: [],
 		version: 1
 	};
-	const src = createSourceRuntime();
+	const src = createSourceRuntime({ extract: createSourceExtractor(cwd$1, config, () => src) });
 	const normalizedCacheConfig = normalizeRunnerCacheConfig(options.runner?.cache, cwd$1);
 	const cacheStore = await createCacheStore({
 		cwd: cwd$1,
@@ -2250,7 +2425,7 @@ async function runAlint(options = {}) {
 	try {
 		const projectRuntimes = preparation.project ? createRuntimes(preparation.project) : [];
 		const projectBuilder = preparation.project && projectRuntimes.some((runtime) => runtime.handlers.onTargetWith || runtime.handlers.onTargetProject) ? new ProjectIndexBuilder(preparation.project.root) : void 0;
-		const sourceResults = await executeSourceSessions(preparation.files, {
+		const sourceResults = await planSources(preparation.files, {
 			cacheStore,
 			createRuleRuntimes: createRuntimes,
 			cwd: cwd$1,
@@ -2258,20 +2433,18 @@ async function runAlint(options = {}) {
 			projectSnapshots: projectBuilder !== void 0,
 			scheduler,
 			signal: options.signal,
-			sourceWindow: resolveSourceWindow(concurrency),
 			src
 		});
-		for (const result of sourceResults) {
-			outcomes.push(...result.outcomes);
-			if (result.failure) fileFailures.push(result.failure);
-		}
+		for (const result of sourceResults) if (result.failure) fileFailures.push(result.failure);
+		const pendingOutcomes = sourceResults.map((result) => result.outcomes);
 		if (projectBuilder) {
 			for (const result of [...sourceResults].sort((left, right) => (left.project?.fileIndex ?? Number.MAX_SAFE_INTEGER) - (right.project?.fileIndex ?? Number.MAX_SAFE_INTEGER))) if (result.project) projectBuilder.add(result.project);
 		}
 		const directoryBatches = preparation.directories.map((input) => {
 			return scheduler.schedule(createDirectoryJobs(input, createRuntimes(input)));
 		});
-		outcomes.push(...(await Promise.all(directoryBatches.map((batch) => batch.outcomes))).flat());
+		pendingOutcomes.push(...directoryBatches.map((batch) => batch.outcomes));
+		let clearEmptyProjectOwner = false;
 		if (fileFailures.length === 0 && preparation.project && !options.signal?.aborted) {
 			if (projectBuilder) {
 				const project = createProjectJobs({
@@ -2282,19 +2455,26 @@ async function runAlint(options = {}) {
 				});
 				const projectOwner = project.owner;
 				const batch = scheduler.schedule(project.jobs);
-				outcomes.push(...await batch.outcomes);
-				projectOwner?.commit({ mode: options.signal?.aborted ? "merge" : "replace" });
-			} else if (!options.cacheOnly) cacheStore.beginOwner({
-				kind: "project",
-				path: preparation.project.root
-			}).commit({ mode: "replace" });
+				pendingOutcomes.push(batch.outcomes.then((settled) => {
+					projectOwner?.commit({ mode: options.signal?.aborted ? "merge" : "replace" });
+					return settled;
+				}));
+			} else if (!options.cacheOnly) clearEmptyProjectOwner = true;
 		}
+		const planningProgress = runProgress.completePlanning();
+		options.progress?.onPlanningEnd?.({ progress: planningProgress });
+		outcomes.push(...(await Promise.all(pendingOutcomes)).flat());
+		if (clearEmptyProjectOwner) cacheStore.beginOwner({
+			kind: "project",
+			path: preparation.project.root
+		}).commit({ mode: "replace" });
 	} catch (error) {
 		scheduler.cancelWithError(error);
 		infrastructureError = error;
 		infrastructureFailed = true;
 		admissionFailed = true;
 	} finally {
+		runProgress.completePlanning();
 		try {
 			await scheduler.close();
 		} catch (error) {
@@ -2311,7 +2491,11 @@ async function runAlint(options = {}) {
 	const ruleFailures = outcomes.flatMap((outcome) => outcome.state === "failed" ? [outcome.failure] : []);
 	const failures = [...fileFailures.sort((left, right) => left.file.index - right.file.index), ...ruleFailures];
 	const result = {
-		diagnostics: outcomes.flatMap((outcome) => outcome.diagnostics),
+		diagnostics: [
+			...missingLanguageDiagnostics(preparation.missingLanguages),
+			...unregisteredLanguageDiagnostics(preparation.unregisteredLanguages),
+			...outcomes.flatMap((outcome) => outcome.diagnostics)
+		],
 		execution: executionCounts(outcomes),
 		usage: runUsage(outcomes)
 	};
@@ -2385,4 +2569,303 @@ function usageTotals(records) {
 	};
 }
 //#endregion
-export { AlintAbortError, AlintRunCancelledError, AlintRunError, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange };
+//#region src/models/benchmark-scheduler.ts
+/** Runs FIFO job queues independently so one provider's cap cannot throttle or overload another provider. */
+async function scheduleProviderJobs(jobs, concurrencyByProvider, execute) {
+	const queues = /* @__PURE__ */ new Map();
+	for (const [index, job] of jobs.entries()) {
+		const queue = queues.get(job.providerId) ?? [];
+		queue.push({
+			index,
+			job
+		});
+		queues.set(job.providerId, queue);
+	}
+	const limits = /* @__PURE__ */ new Map();
+	for (const providerId of queues.keys()) {
+		const limit = concurrencyByProvider[providerId] ?? 1;
+		if (!Number.isInteger(limit) || limit < 1) throw new RangeError(`Benchmark concurrency for provider "${providerId}" must be a positive integer.`);
+		limits.set(providerId, limit);
+	}
+	const results = Array.from({ length: jobs.length });
+	const workers = [];
+	for (const [providerId, queue] of queues) {
+		const workerCount = Math.min(limits.get(providerId), queue.length);
+		let nextJobIndex = 0;
+		for (let workerIndex = 0; workerIndex < workerCount; workerIndex += 1) workers.push((async () => {
+			while (nextJobIndex < queue.length) {
+				const scheduled = queue[nextJobIndex];
+				nextJobIndex += 1;
+				if (scheduled !== void 0) results[scheduled.index] = { value: await execute(scheduled.job, scheduled.index) };
+			}
+		})());
+	}
+	await Promise.all(workers);
+	return results.map((result, index) => {
+		if (result === void 0) throw new Error(`Benchmark scheduler did not complete job ${index}.`);
+		return result.value;
+	});
+}
+//#endregion
+//#region src/models/benchmark.ts
+const defaultSampleCount = 3;
+const defaultTimeoutMs = 6e4;
+const maxOutputTokens = 128;
+/**
+* Benchmarks model jobs concurrently within independent provider limits.
+*
+* Each model's repeat warm-up, measured repeats, and non-repeats remain serial so concurrent samples cannot
+* distort that model's cache behavior. Non-repeat prompts put their nonce before the shared corpus.
+*/
+async function benchmarkModels(config, options = {}) {
+	const request = options.request ?? measureModel;
+	const sampleCount = options.sampleCount ?? defaultSampleCount;
+	const seed = options.seed ?? Math.floor(Date.now() / 1e3);
+	const timeoutMs = options.timeoutMs ?? config.runner?.timeoutMs ?? defaultTimeoutMs;
+	const jobs = config.providers.flatMap((provider) => provider.models.map((model) => ({
+		identity: `${provider.id}/${model.id}`,
+		model,
+		providerId: provider.id
+	})));
+	const results = Array.from({ length: jobs.length });
+	const active = /* @__PURE__ */ new Map();
+	const modelsTotal = jobs.length;
+	if (!Number.isInteger(sampleCount) || sampleCount < 1) throw new RangeError("Benchmark sample count must be a positive integer.");
+	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new RangeError("Benchmark timeout must be greater than zero.");
+	return scheduleProviderJobs(jobs, options.providerConcurrency ?? {}, async (job, modelIndex) => {
+		const baseResult = {
+			modelId: job.model.id,
+			providerId: job.providerId,
+			success: {
+				attempted: 0,
+				completed: 0
+			}
+		};
+		let model;
+		try {
+			model = resolveModel(config, { request: job.identity });
+		} catch (error) {
+			const result = {
+				...baseResult,
+				error: errorMessageFrom(error) ?? "Could not resolve model."
+			};
+			results[modelIndex] = result;
+			reportProgress(options, modelsTotal, results, active);
+			return result;
+		}
+		const result = await benchmarkModel(model, modelIndex, seed, sampleCount, timeoutMs, request, (current) => {
+			active.set(modelIndex, current);
+			reportProgress(options, modelsTotal, results, active);
+		});
+		active.delete(modelIndex);
+		results[modelIndex] = result;
+		reportProgress(options, modelsTotal, results, active);
+		return result;
+	});
+}
+async function attempt(result, request, timeoutMs, onStarted) {
+	result.success.attempted += 1;
+	onStarted();
+	const measurement = await request(AbortSignal.timeout(timeoutMs));
+	result.success.completed += 1;
+	return measurement;
+}
+async function benchmarkModel(model, modelIndex, seed, sampleCount, timeoutMs, request, onProgress) {
+	const result = {
+		modelId: model.id,
+		providerId: model.provider.id,
+		success: {
+			attempted: 0,
+			completed: 0
+		}
+	};
+	const repeatPrompt = benchmarkPrompt(seed, model, 0, true);
+	const repeatMeasurements = [];
+	const nonRepeatMeasurements = [];
+	try {
+		await attempt(result, (signal) => request({
+			model,
+			prompt: repeatPrompt,
+			signal
+		}), timeoutMs, () => onProgress(currentProgress(model, modelIndex, result, "repeat", 0, sampleCount, true)));
+		for (let index = 0; index < sampleCount; index += 1) repeatMeasurements.push(await attempt(result, (signal) => request({
+			model,
+			prompt: repeatPrompt,
+			signal
+		}), timeoutMs, () => onProgress(currentProgress(model, modelIndex, result, "repeat", index + 1, sampleCount, false))));
+		for (let index = 0; index < sampleCount; index += 1) {
+			const prompt = benchmarkPrompt(seed, model, index + 1, false);
+			nonRepeatMeasurements.push(await attempt(result, (signal) => request({
+				model,
+				prompt,
+				signal
+			}), timeoutMs, () => onProgress(currentProgress(model, modelIndex, result, "non-repeat", index + 1, sampleCount, false))));
+		}
+	} catch (error) {
+		return {
+			...result,
+			error: errorMessageFrom(error) ?? "Benchmark request failed."
+		};
+	}
+	return {
+		...result,
+		nonRepeatMs: median(nonRepeatMeasurements.map((measurement) => measurement.durationMs)),
+		repeatMs: median(repeatMeasurements.map((measurement) => measurement.durationMs)),
+		throughput: medianOptional(nonRepeatMeasurements.map(throughputOf))
+	};
+}
+function benchmarkPrompt(seed, model, sample, repeat) {
+	const nonce = repeat ? `${seed}:${model.provider.id}/${model.id}:repeat` : `${seed}:${model.provider.id}/${model.id}:non-repeat:${sample}`;
+	const corpus = sampleCorpus(seed + sample);
+	return [
+		`[alint benchmark nonce: ${nonce}]`,
+		"Read the following source review corpus. Return exactly eight concise bullet points summarizing its behavior, risks, and maintainability. Do not quote the nonce.",
+		"",
+		corpus
+	].join("\n");
+}
+function currentProgress(model, modelIndex, result, phase, sample, samples, warmup) {
+	return {
+		modelId: model.id,
+		modelIndex,
+		phase,
+		providerId: model.provider.id,
+		sample,
+		samples,
+		success: { ...result.success },
+		warmup
+	};
+}
+async function measureModel({ model, prompt, signal }) {
+	const messages = [{
+		content: prompt,
+		role: "user"
+	}];
+	const startedAt = performance.now();
+	let firstOutputAt;
+	const result = streamText({
+		...model.params,
+		abortSignal: signal,
+		baseURL: model.provider.endpoint,
+		headers: model.provider.headers,
+		maxTokens: maxOutputTokens,
+		messages,
+		model: model.id,
+		streamOptions: { includeUsage: true },
+		temperature: 0
+	});
+	const completion = Promise.allSettled([
+		result.messages,
+		result.steps,
+		result.totalUsage,
+		result.usage
+	]);
+	let settled;
+	try {
+		for await (const event of result.eventStream) if (firstOutputAt === void 0 && (event.type === "reasoning.delta" || event.type === "text.delta")) firstOutputAt = performance.now();
+	} finally {
+		settled = await completion;
+	}
+	const endedAt = performance.now();
+	const usageResult = settled[3];
+	if (usageResult.status === "rejected") throw usageResult.reason;
+	return {
+		durationMs: endedAt - startedAt,
+		firstOutputMs: firstOutputAt === void 0 ? void 0 : firstOutputAt - startedAt,
+		outputTokens: usageResult.value?.outputTokens
+	};
+}
+function median(values) {
+	const sorted = [...values].sort((left, right) => left - right);
+	const middle = Math.floor(sorted.length / 2);
+	return sorted.length % 2 === 0 ? (sorted[middle - 1] + sorted[middle]) / 2 : sorted[middle];
+}
+function medianOptional(values) {
+	const present = values.filter((value) => value !== void 0);
+	return present.length === 0 ? void 0 : median(present);
+}
+function reportProgress(options, modelsTotal, results, active) {
+	options.onProgress?.({
+		active: [...active.values()].sort((left, right) => left.modelIndex - right.modelIndex).map((current) => ({
+			...current,
+			success: { ...current.success }
+		})),
+		modelsTotal,
+		results: results.map((result) => result === void 0 ? void 0 : {
+			...result,
+			success: { ...result.success }
+		})
+	});
+}
+function throughputOf(measurement) {
+	if (measurement.firstOutputMs === void 0 || measurement.outputTokens === void 0 || measurement.durationMs <= measurement.firstOutputMs) return;
+	return measurement.outputTokens / ((measurement.durationMs - measurement.firstOutputMs) / 1e3);
+}
+const corpusLines = [
+	"type QueueEntry = { id: string, attempts: number, payload: string }",
+	"type QueueState = { active: Map<string, QueueEntry>, pending: QueueEntry[] }",
+	"",
+	"export function createQueue(limit: number) {",
+	"  const state: QueueState = { active: new Map(), pending: [] }",
+	"  let closed = false",
+	"",
+	"  function enqueue(entry: QueueEntry): boolean {",
+	"    if (closed || state.active.has(entry.id)) return false",
+	"    state.pending.push({ ...entry })",
+	"    drain()",
+	"    return true",
+	"  }",
+	"",
+	"  function drain(): void {",
+	"    while (!closed && state.active.size < limit && state.pending.length > 0) {",
+	"      const next = state.pending.shift()",
+	"      if (!next) break",
+	"      state.active.set(next.id, next)",
+	"      void execute(next).finally(() => {",
+	"        state.active.delete(next.id)",
+	"        drain()",
+	"      })",
+	"    }",
+	"  }",
+	"",
+	"  async function execute(entry: QueueEntry): Promise<void> {",
+	"    const response = await fetch(\"/jobs/\" + entry.id, {",
+	"      body: JSON.stringify(entry.payload),",
+	"      headers: { \"content-type\": \"application/json\" },",
+	"      method: \"POST\",",
+	"    })",
+	"    if (!response.ok && entry.attempts < 3) {",
+	"      state.pending.push({ ...entry, attempts: entry.attempts + 1 })",
+	"    }",
+	"  }",
+	"",
+	"  function close(): void {",
+	"    closed = true",
+	"    state.pending.length = 0",
+	"  }",
+	"",
+	"  return { close, enqueue }",
+	"}",
+	"",
+	"The queue accepts independent jobs and limits concurrent requests.",
+	"Its retry path changes ordering because failed jobs return at the tail.",
+	"Closing drops pending work but does not cancel requests already in flight.",
+	"Callers receive admission status but cannot observe completion or failure.",
+	"The mutable map prevents duplicate active identifiers, not duplicate pending identifiers.",
+	"A synchronous drain call establishes ownership before asynchronous execution starts.",
+	"Network failures reject execute and are not retried by the response-status branch.",
+	"The relative URL assumes a runtime with an application-specific fetch base.",
+	"Payload serialization can throw before a request is created.",
+	"The limit must be positive or pending work can remain stuck forever."
+];
+function sampleCorpus(seed) {
+	const offset = Math.abs(seed) % corpusLines.length;
+	const rotated = [...corpusLines.slice(offset), ...corpusLines.slice(0, offset)].join("\n");
+	return [
+		1,
+		2,
+		3
+	].map((section) => `--- corpus section ${section} ---\n${rotated}`).join("\n\n");
+}
+//#endregion
+export { AlintAbortError, AlintRunCancelledError, AlintRunError, benchmarkModels, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceExtractor, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange, targetIdentity, withLanguage, withStableIdentities };