@alint-js/core 0.0.38 → 0.1.1

package/dist/index.mjs

@@ -3,14 +3,15 @@ import { n as definePlugin, r as defineRule, t as defineConfig } from "./define-
 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";
-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 { 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 process, { cwd } from "node:process";
-import { array, check, description, getDotPath, is, literal, number, object, optional, 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";
 //#region src/config/config-array.ts
 const effectiveBasePathSymbol = Symbol("effectiveBasePath");
 const inheritedMatcherScopesSymbol = Symbol("inheritedMatcherScopes");
@@ -253,7 +254,7 @@ function withLanguage$1(file, language) {
 }
 //#endregion
 //#region src/core/languages/registry.ts
-function createLanguageRegistry() {
+function createLanguageRegistry$1() {
 	return {
 		byExtension: /* @__PURE__ */ new Map(),
 		languages: /* @__PURE__ */ new Map()
@@ -305,7 +306,10 @@ function withLanguage(file, language) {
 //#endregion
 //#region src/core/languages/resolve.ts
 function resolveLanguage(file, registry, options) {
-	const languageName = options.language ?? options.processedLanguage ?? registry.byExtension.get(extname(file.path)) ?? "text/plain";
+	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 language = registry.languages.get(languageName);
 	if (!language) throw new Error(`Unknown language "${languageName}".`);
 	return language;
@@ -313,232 +317,172 @@ function resolveLanguage(file, registry, options) {
 //#endregion
 //#region src/core/languages/index.ts
 function createBuiltInLanguageRegistry() {
-	const registry = createLanguageRegistry();
+	const registry = createLanguageRegistry$1();
 	registerLanguage(registry, textLanguage);
 	registerLanguage(registry, javascriptLanguage);
 	registerLanguage(registry, typescriptLanguage);
 	return registry;
 }
 //#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
+//#region package.json
+var version = "0.1.1";
+//#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;
+		}
 	};
+	return api;
 }
-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 hashText(text) {
+	return createHash("sha256").update(text).digest("hex");
 }
-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 stableHash(value) {
+	return hashText(stableStringify(value));
 }
-function parseRuleOptions(id, schema, options) {
-	if (!schema) {
-		if (options.length > 0) throw new TypeError(`Rule "${id}" does not accept options.`);
-		return [];
+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(",")}}`;
 	}
-	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]));
+	return JSON.stringify(value);
 }
 //#endregion
-//#region src/models/resolve.ts
-function resolveModel(registry, options = {}) {
-	const candidates = flattenModels(registry);
-	const ruleId = options.ruleId ?? "<unknown>";
-	if (options.request !== void 0) {
-		const request = options.request;
-		const candidate = candidates.find((candidate) => matchesRequest(candidate, request));
-		if (candidate === void 0) throw new Error(`Unknown model "${request}".`);
-		if (!satisfiesHardRequirements(candidate.model, options.requirement)) throw new Error(`Model "${request}" does not satisfy requirement for rule "${ruleId}".`);
-		return toResolvedModel(candidate, options.requirement);
-	}
-	const candidate = preferSize(candidates.filter(({ model }) => satisfiesHardRequirements(model, options.requirement)), options.requirement);
-	if (candidate === void 0) throw new Error(`No model satisfies requirement for rule "${ruleId}".`);
-	return toResolvedModel(candidate, options.requirement);
-}
-function flattenModels(registry) {
-	return registry.providers.flatMap((provider) => provider.models.map((model) => ({
-		model,
-		provider
-	})));
-}
-function matchesRequest(candidate, request) {
-	return [
-		candidate.model.id,
-		candidate.model.name,
-		...candidate.model.aliases ?? []
-	].filter((name) => name !== void 0).some((name) => name === request || `${candidate.provider.id}/${name}` === request);
-}
-function preferSize(candidates, requirement) {
-	if (requirement?.size === void 0) return candidates[0];
-	return candidates.find(({ model }) => model.size === requirement.size) ?? candidates[0];
-}
-function satisfiesHardRequirements(model, requirement) {
-	if (requirement === void 0) return true;
-	if (requirement.capabilities !== void 0 && !requirement.capabilities.every((capability) => (model.capabilities ?? []).includes(capability))) return false;
-	if (requirement.minContextWindow !== void 0 && (model.contextWindow === void 0 || model.contextWindow < requirement.minContextWindow)) return false;
-	return true;
-}
-function toResolvedModel(candidate, requirement) {
-	const { model, provider } = candidate;
-	return {
-		aliases: [...model.aliases ?? []],
-		capabilities: [...model.capabilities ?? []],
-		contextWindow: model.contextWindow,
-		id: model.id,
-		name: model.name ?? model.id,
-		params: {
-			...model.defaultParams ?? {},
-			...requirement?.params ?? {}
-		},
-		provider: {
-			endpoint: provider.endpoint,
-			headers: { ...provider.headers ?? {} },
-			id: provider.id,
-			type: provider.type
-		},
-		size: model.size
-	};
-}
+//#region src/core/cache/types.ts
+const CACHE_MAGIC = "ALINT_CACHE";
 //#endregion
-//#region src/core/cache.ts
-const CACHE_SCHEMA_VERSION = 1;
+//#region src/core/cache/store.ts
 const DEFAULT_CACHE_FILE_NAME = ".alintcache";
-const CacheFileSchema = pipe(object({
-	createdAt: pipe(string(), description("Cache file creation timestamp.")),
-	entries: pipe(unknown(), check((value) => typeof value === "object" && value !== null && !Array.isArray(value)), record(string(), object({
-		diagnostics: pipe(array(object({
-			filePath: pipe(string(), description("Diagnostic file path.")),
-			message: pipe(string(), description("Diagnostic message.")),
-			ruleId: pipe(string(), description("Diagnostic rule id.")),
-			severity: pipe(union([literal("error"), literal("warn")]), description("Diagnostic severity."))
-		})), description("Diagnostics produced for the cached target.")),
-		filePath: pipe(string(), description("Cache entry file path.")),
-		fingerprint: pipe(object({
-			alintVersion: pipe(string(), description("Alint version used to create the cache entry.")),
-			configHash: pipe(string(), description("Runner config hash used to create the cache entry.")),
-			modelHash: pipe(string(), description("Model configuration hash used to create the cache entry.")),
-			ruleHash: pipe(string(), description("Rule configuration hash used to create the cache entry."))
-		}), description("Cache entry fingerprint.")),
-		target: pipe(object({
-			hash: pipe(string(), description("Cached target hash.")),
-			identity: pipe(string(), description("Stable cached target identity.")),
-			kind: pipe(string(), description("Cached target kind."))
-		}), description("Cached target metadata.")),
-		usage: pipe(array(object({
-			inputTokens: pipe(optional(number()), description("Optional input token count.")),
-			modelId: pipe(string(), description("Usage model id.")),
-			outputTokens: pipe(optional(number()), description("Optional output token count.")),
-			providerId: pipe(string(), description("Usage provider id.")),
-			ruleId: pipe(string(), description("Usage rule id.")),
-			totalTokens: pipe(optional(number()), description("Optional total token count."))
-		})), description("Inference usage records for the cache entry."))
-	})), description("Cache entries keyed by cache key.")),
-	files: pipe(unknown(), check((value) => typeof value === "object" && value !== null && !Array.isArray(value)), record(string(), object({
-		contentHash: pipe(string(), description("Cached file content hash.")),
-		entries: pipe(array(string()), description("Cache entry keys associated with the file.")),
-		path: pipe(string(), description("Normalized cached file path."))
-	})), description("Cached files keyed by normalized file path.")),
-	schemaVersion: pipe(literal(CACHE_SCHEMA_VERSION), description("Cache schema version.")),
-	updatedAt: pipe(string(), description("Cache file update timestamp."))
-}), description("Alint cache file."));
-function createCacheKey(input) {
-	return stableHash(input);
-}
+const FiniteNumberSchema = pipe(number(), finite());
+const PositionSchema = object({
+	column: FiniteNumberSchema,
+	line: FiniteNumberSchema
+});
+const SourceLocationSchema = object({
+	end: PositionSchema,
+	start: PositionSchema
+});
+const DiagnosticLocationSchema = object({
+	end: optional(PositionSchema),
+	start: PositionSchema
+});
+const SourceRangeSchema = object({
+	end: FiniteNumberSchema,
+	start: FiniteNumberSchema
+});
+const DiagnosticSchema = object({
+	cached: optional(boolean()),
+	evidence: optional(custom(isJsonValue)),
+	filePath: string(),
+	loc: optional(DiagnosticLocationSchema),
+	message: string(),
+	model: optional(object({
+		providerId: string(),
+		requested: optional(string()),
+		resolvedId: string()
+	})),
+	ruleId: string(),
+	severity: union([literal("error"), literal("warn")])
+});
+const UsageSchema = object({
+	filePath: optional(string()),
+	inputTokens: optional(FiniteNumberSchema),
+	metadata: optional(custom(isJsonValue)),
+	modelId: string(),
+	outputTokens: optional(FiniteNumberSchema),
+	providerId: string(),
+	ruleId: string(),
+	totalTokens: optional(FiniteNumberSchema)
+});
+const CacheEntrySchema = object({
+	diagnostics: array(DiagnosticSchema),
+	fingerprint: object({
+		configHash: string(),
+		modelHash: string(),
+		ruleHash: string(),
+		targetHash: string()
+	}),
+	target: object({
+		hash: string(),
+		identity: string(),
+		kind: string(),
+		loc: optional(SourceLocationSchema),
+		name: optional(string()),
+		range: optional(SourceRangeSchema)
+	}),
+	usage: array(UsageSchema)
+});
+function objectRecord(value) {
+	return pipe(unknown(), check((input) => typeof input === "object" && input !== null && !Array.isArray(input)), record(string(), value));
+}
+const CacheFileBodySchema = pipe(object({
+	createdAt: string(),
+	entries: objectRecord(CacheEntrySchema),
+	owners: objectRecord(object({
+		contentHash: optional(string()),
+		kind: union([literal("file"), literal("project")]),
+		path: string(),
+		slots: array(string())
+	})),
+	updatedAt: string()
+}), check((body) => {
+	const entryKeys = Object.keys(body.entries);
+	const referencedSlots = Object.values(body.owners).flatMap((owner) => owner.slots);
+	const uniqueSlots = new Set(referencedSlots);
+	return uniqueSlots.size === referencedSlots.length && uniqueSlots.size === entryKeys.length && entryKeys.every((key) => uniqueSlots.has(key));
+}));
 async function createCacheStore(options) {
 	const location = resolveCacheLocation(options.cwd, options.location);
 	if (!options.enabled) return createNoopCacheStore(location);
-	const cacheFile = await readCacheFile(location);
+	const header = `${CACHE_MAGIC} 2 ${options.alintVersion ?? version}`;
+	const body = await loadCacheBody(location, header, options.readOnly === true);
+	if (options.readOnly) return createReadOnlyCacheStore(location, body, options.cwd);
+	const fileExists = options.fileExists ?? defaultFileExists;
+	const writeFile$1 = options.writeFile ?? writeFile;
 	return {
-		get: (key) => cacheFile.entries[key],
+		beginOwner: (owner) => beginOwner(body, owner, options.cwd),
 		location,
-		markFile: (filePath, contentHash, entries) => {
-			const path = normalizeCachePath(options.cwd, filePath);
-			cacheFile.files[path] = {
-				contentHash,
-				entries,
-				path
-			};
-		},
 		reconcile: async () => {
-			await mkdir(dirname(location), { recursive: true });
-			cacheFile.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-			const tempPath = join(dirname(location), `.${DEFAULT_CACHE_FILE_NAME}.${process.pid}.${randomUUID()}.tmp`);
-			await writeFile(tempPath, `${JSON.stringify(cacheFile, null, 2)}\n`);
-			await rename(tempPath, location);
-		},
-		set: (key, entry) => {
-			cacheFile.entries[key] = entry;
+			await collectMissingFileOwners(body, options.cwd, fileExists);
+			body.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+			await persistCacheBody(location, header, body, writeFile$1);
 		}
 	};
 }
 function createTargetIdentityResolver(targets) {
 	const baseCounts = /* @__PURE__ */ new Map();
+	const duplicateCandidateCounts = /* @__PURE__ */ new Map();
 	for (const target of targets) {
 		const base = createBaseTargetIdentity(target);
 		baseCounts.set(base, (baseCounts.get(base) ?? 0) + 1);
 	}
-	return (target) => {
+	for (const target of targets) {
+		const base = createBaseTargetIdentity(target);
+		if ((baseCounts.get(base) ?? 0) <= 1) continue;
+		const candidate = target.range ? `${base}:${target.range.start}:${target.range.end}` : base;
+		duplicateCandidateCounts.set(candidate, (duplicateCandidateCounts.get(candidate) ?? 0) + 1);
+	}
+	return (target, targetIndex) => {
 		const base = createBaseTargetIdentity(target);
 		if ((baseCounts.get(base) ?? 0) <= 1) return base;
-		if (target.range) return `${base}:${target.range.start}:${target.range.end}`;
-		return base;
+		const candidate = target.range ? `${base}:${target.range.start}:${target.range.end}` : base;
+		if ((duplicateCandidateCounts.get(candidate) ?? 0) <= 1) return candidate;
+		return `${candidate}:${targetIndex}`;
 	};
 }
-function hashText(text) {
-	return createHash("sha256").update(text).digest("hex");
-}
 function normalizeCachePath(cwd, filePath) {
-	return relative$1(cwd, isAbsolute$1(filePath) ? resolve$1(filePath) : resolve$1(cwd, filePath)).split(sep).join("/");
+	return relative$1(cwd, isAbsolute$1(filePath) ? resolve$1(filePath) : resolve$1(cwd, filePath)).split(sep).join("/") || ".";
 }
 function normalizeRunnerCacheConfig(cache, cwd) {
 	if (cache === false) return {
@@ -559,12 +503,50 @@ function resolveCacheLocation(cwd, location) {
 	const resolved = isAbsolute$1(location) ? resolve$1(location) : resolve$1(cwd, location);
 	if (location.endsWith("/") || location.endsWith("\\")) return join(resolved, DEFAULT_CACHE_FILE_NAME);
 	try {
-		if (statSyncIsDirectory(resolved)) return join(resolved, DEFAULT_CACHE_FILE_NAME);
+		if (statSync(resolved).isDirectory()) return join(resolved, DEFAULT_CACHE_FILE_NAME);
 	} catch {}
 	return resolved;
 }
-function stableHash(value) {
-	return hashText(stableStringify(value));
+function beginOwner(body, owner, cwd) {
+	const normalizedOwner = {
+		kind: owner.kind,
+		path: normalizeCachePath(cwd, owner.path)
+	};
+	const key = ownerKey(normalizedOwner, cwd);
+	const previousOwner = body.owners[key];
+	const nextEntries = /* @__PURE__ */ new Map();
+	return {
+		commit: (metadata = {}) => {
+			const committedEntries = metadata.mode === "merge" ? ownerEntries(body, body.owners[key]) : /* @__PURE__ */ new Map();
+			for (const [entryKey, cacheEntry] of nextEntries) committedEntries.set(entryKey, cacheEntry);
+			const replacedSlots = /* @__PURE__ */ new Set([...previousOwner?.slots ?? [], ...body.owners[key]?.slots ?? []]);
+			for (const replacedSlot of replacedSlots) delete body.entries[replacedSlot];
+			for (const [entryKey, cacheEntry] of committedEntries) body.entries[entryKey] = cacheEntry;
+			body.owners[key] = {
+				contentHash: metadata.contentHash,
+				kind: normalizedOwner.kind,
+				path: normalizedOwner.path,
+				slots: [...committedEntries.keys()].sort()
+			};
+			body.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		},
+		discard: (cacheSlot) => nextEntries.delete(slotKey(normalizedOwner, cacheSlot, cwd)),
+		lookup: (cacheSlot, fingerprint) => {
+			const entryKey = slotKey(normalizedOwner, cacheSlot, cwd);
+			const cached = body.entries[entryKey];
+			if (!cached || !fingerprintsEqual(cached.fingerprint, fingerprint)) return void 0;
+			nextEntries.set(entryKey, cached);
+			return cached;
+		},
+		put: (cacheSlot, cacheEntry) => nextEntries.set(slotKey(normalizedOwner, cacheSlot, cwd), cacheEntry)
+	};
+}
+async function collectMissingFileOwners(body, cwd, fileExists) {
+	for (const [key, owner] of Object.entries(body.owners)) {
+		if (owner.kind !== "file" || await fileExists(resolve$1(cwd, owner.path))) continue;
+		for (const entryKey of owner.slots) delete body.entries[entryKey];
+		delete body.owners[key];
+	}
 }
 function createBaseTargetIdentity(target) {
 	if (target.identity && (target.kind !== "file" || target.identity !== "file")) return target.filePath ? `${target.kind}:${target.filePath}:${target.identity}` : `${target.kind}:${target.identity}`;
@@ -573,53 +555,216 @@ function createBaseTargetIdentity(target) {
 	if (target.range) return `${target.kind}:${target.range.start}:${target.range.end}`;
 	return target.kind;
 }
-function createEmptyCacheFile() {
+function createEmptyCacheBody() {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
 	return {
 		createdAt: now,
 		entries: {},
-		files: {},
-		schemaVersion: CACHE_SCHEMA_VERSION,
+		owners: {},
 		updatedAt: now
 	};
 }
 function createNoopCacheStore(location) {
+	const transaction = {
+		commit: () => {},
+		discard: () => {},
+		lookup: () => void 0,
+		put: () => {}
+	};
+	return {
+		beginOwner: () => transaction,
+		location,
+		reconcile: async () => {}
+	};
+}
+function createReadOnlyCacheStore(location, body, cwd) {
+	const transaction = (owner) => ({
+		commit: () => {},
+		discard: () => {},
+		lookup: (slot, fingerprint) => {
+			const cached = body.entries[slotKey(owner, slot, cwd)];
+			return cached && fingerprintsEqual(cached.fingerprint, fingerprint) ? cached : void 0;
+		},
+		put: () => {}
+	});
 	return {
-		get: () => void 0,
+		beginOwner: transaction,
 		location,
-		markFile: () => {},
-		reconcile: async () => {},
-		set: () => {}
+		reconcile: async () => {}
 	};
 }
-function isCacheFile(value) {
-	return is(CacheFileSchema, value);
+async function defaultFileExists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch (error) {
+		if (isMissingFileError(error)) return false;
+		throw error;
+	}
+}
+function fingerprintsEqual(left, right) {
+	return left.configHash === right.configHash && left.modelHash === right.modelHash && left.ruleHash === right.ruleHash && left.targetHash === right.targetHash;
+}
+function hasJsonArrayProperties(input, ancestors) {
+	let arrayLength;
+	let indexCount = 0;
+	for (const key of Reflect.ownKeys(input)) {
+		const descriptor = Object.getOwnPropertyDescriptor(input, key);
+		if (!descriptor || !("value" in descriptor)) return false;
+		if (key === "length") {
+			if (descriptor.enumerable || typeof descriptor.value !== "number") return false;
+			arrayLength = descriptor.value;
+			continue;
+		}
+		if (typeof key !== "string" || !isCanonicalArrayIndex(key) || !descriptor.enumerable) return false;
+		if (!isJsonValueAt(descriptor.value, ancestors)) return false;
+		indexCount += 1;
+	}
+	return arrayLength !== void 0 && indexCount === arrayLength;
+}
+function hasJsonObjectProperties(input, ancestors) {
+	for (const key of Reflect.ownKeys(input)) {
+		if (typeof key !== "string") return false;
+		const descriptor = Object.getOwnPropertyDescriptor(input, key);
+		if (!descriptor || !descriptor.enumerable || !("value" in descriptor)) return false;
+		if (!isJsonValueAt(descriptor.value, ancestors)) return false;
+	}
+	return true;
+}
+function isCanonicalArrayIndex(key) {
+	const index = Number(key);
+	return Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === key;
 }
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
+function isJsonValue(input) {
+	return isJsonValueAt(input, /* @__PURE__ */ new WeakSet());
 }
-async function readCacheFile(location) {
+function isJsonValueAt(input, ancestors) {
+	if (input === null || typeof input === "string" || typeof input === "boolean") return true;
+	if (typeof input === "number") return Number.isFinite(input);
+	if (typeof input !== "object") return false;
+	if (ancestors.has(input)) return false;
+	ancestors.add(input);
 	try {
-		const parsed = JSON.parse(await readFile(location, "utf8"));
-		if (isCacheFile(parsed)) return parsed;
-	} catch {}
-	return createEmptyCacheFile();
+		if (Array.isArray(input)) {
+			if (Object.getPrototypeOf(input) !== Array.prototype) return false;
+			return hasJsonArrayProperties(input, ancestors);
+		}
+		if (Object.getPrototypeOf(input) !== Object.prototype && Object.getPrototypeOf(input) !== null) return false;
+		return hasJsonObjectProperties(input, ancestors);
+	} catch {
+		return false;
+	} finally {
+		ancestors.delete(input);
+	}
 }
-function stableStringify(value) {
-	if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-	if (isRecord(value)) return `{${Object.keys(value).sort().map((key) => {
-		const property = value[key];
-		if (property === void 0) return;
-		return `${JSON.stringify(key)}:${stableStringify(property)}`;
-	}).filter((entry) => entry !== void 0).join(",")}}`;
-	return JSON.stringify(value);
+function isMissingFileError(error) {
+	return isNodeErrorCode(error, "ENOENT") || isNodeErrorCode(error, "ENOTDIR");
+}
+function isNodeErrorCode(error, code) {
+	return error instanceof Error && "code" in error && error.code === code;
+}
+async function loadCacheBody(location, expectedHeader, readOnly) {
+	let handle;
+	try {
+		handle = await open(location, "r");
+		const header = await readHeader(handle);
+		await handle.close();
+		handle = void 0;
+		if (header !== expectedHeader) {
+			if (!readOnly) await rm(location, { force: true });
+			return createEmptyCacheBody();
+		}
+		const text = await readFile(location, "utf8");
+		return parseCacheBody(text.slice(text.indexOf("\n") + 1));
+	} catch (error) {
+		await handle?.close().catch(() => {});
+		if (isMissingFileError(error)) return createEmptyCacheBody();
+		if (!readOnly) await rm(location, { force: true }).catch(() => {});
+		return createEmptyCacheBody();
+	}
+}
+function ownerEntries(body, owner) {
+	const entries = /* @__PURE__ */ new Map();
+	for (const slot of owner?.slots ?? []) {
+		const cacheEntry = body.entries[slot];
+		if (cacheEntry) entries.set(slot, cacheEntry);
+	}
+	return entries;
+}
+function ownerKey(owner, cwd) {
+	return stableHash({
+		kind: owner.kind,
+		path: normalizeCachePath(cwd, owner.path)
+	});
+}
+function parseCacheBody(text) {
+	const value = JSON.parse(text);
+	return parse(CacheFileBodySchema, value);
+}
+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`);
+	try {
+		await writeFile(tempPath, `${header}\n${JSON.stringify(validatedBody)}\n`);
+		await rename(tempPath, location);
+	} catch (error) {
+		await rm(tempPath, { force: true }).catch(() => {});
+		throw error;
+	}
 }
-function statSyncIsDirectory(path) {
-	return statSync(path).isDirectory();
+async function readHeader(handle) {
+	const buffer = Buffer.alloc(256);
+	const { bytesRead } = await handle.read(buffer, 0, 256, 0);
+	const newline = buffer.subarray(0, bytesRead).indexOf(10);
+	return newline < 0 ? void 0 : buffer.subarray(0, newline).toString("utf8");
+}
+function slotKey(owner, slot, cwd) {
+	return stableHash({
+		owner: ownerKey(owner, cwd),
+		...slot
+	});
 }
 //#endregion
-//#region package.json
-var version = "0.0.38";
+//#region src/core/execution/records.ts
+function snapshotDiagnostic(diagnostic) {
+	const snapshot = { ...diagnostic };
+	if (diagnostic.loc) snapshot.loc = {
+		...diagnostic.loc.end ? { end: { ...diagnostic.loc.end } } : {},
+		start: { ...diagnostic.loc.start }
+	};
+	if (diagnostic.model) snapshot.model = { ...diagnostic.model };
+	return snapshot;
+}
+function snapshotDiagnostics(diagnostics) {
+	return diagnostics.map(snapshotDiagnostic);
+}
+function snapshotFailure(failure) {
+	return {
+		job: snapshotProgressJobRef(failure.job),
+		kind: failure.kind,
+		message: failure.message
+	};
+}
+function snapshotProgressJobRef(job) {
+	return {
+		id: job.id,
+		index: job.index,
+		inputPath: job.inputPath,
+		ruleId: job.ruleId,
+		target: {
+			identity: job.target.identity,
+			kind: job.target.kind,
+			name: job.target.name
+		}
+	};
+}
+function snapshotUsage(record) {
+	return { ...record };
+}
+function snapshotUsageRecords(records) {
+	return records.map(snapshotUsage);
+}
 //#endregion
 //#region src/core/execution/job.ts
 var CacheReplayProcessingError = class {
@@ -628,76 +773,43 @@ var CacheReplayProcessingError = class {
 		this.cause = cause;
 	}
 };
-function createRuleJobs(plans) {
-	const jobs = [];
-	const total = plans.reduce((sum, plan) => sum + plan.planned, 0);
-	const ruleTotals = /* @__PURE__ */ new Map();
-	const ruleIndexes = /* @__PURE__ */ new Map();
-	for (const plan of plans) for (const target of plan.targets) for (const execution of target.executions) {
-		const ruleId = execution.runtime.enabledRule.id;
-		ruleTotals.set(ruleId, (ruleTotals.get(ruleId) ?? 0) + 1);
-	}
-	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;
-		const ruleIndex = (ruleIndexes.get(ruleId) ?? 0) + 1;
-		ruleIndexes.set(ruleId, ruleIndex);
-		jobs.push({
-			execution,
-			job: {
-				id: stableHash({
-					index,
-					planId: plan.id,
-					ruleId,
-					targetIdentity: target.identity
-				}),
-				index,
-				inputPath: plan.path,
-				ruleId,
-				ruleIndex,
-				ruleTotal: ruleTotals.get(ruleId) ?? 0,
-				target: {
-					identity: target.identity,
-					kind: target.kind,
-					name: target.name
-				},
-				total
-			},
-			target
-		});
-	}
-	return jobs;
+function compareJobOrder(left, right) {
+	return scopeRank(left.scope) - scopeRank(right.scope) || left.inputIndex - right.inputIndex || left.targetIndex - right.targetIndex || left.ruleIndex - right.ruleIndex;
 }
 async function executeRuleJob(job, options) {
 	const bucket = {
 		diagnostics: [],
 		usage: []
 	};
-	if (options.runSignal?.aborted) return finish(job, options, bucket, {
+	if (options.runSignal?.aborted) return finish(job, 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);
+	const slot = job.target.cacheOwner && job.execution.runtime.cacheable ? {
+		ruleId: job.execution.runtime.enabledRule.id,
+		scope: job.target.kind,
+		targetIdentity: job.target.identity
+	} : void 0;
+	const fingerprint = slot ? createFingerprint(job, options.cache.modelHash) : void 0;
+	const cachedEntry = slot && fingerprint ? job.target.cacheOwner?.lookup(slot, fingerprint) : void 0;
+	if (slot && cachedEntry) {
 		try {
-			replayCachedEntry(cachedEntry, bucket, job.job, options.progress);
+			replayCachedEntry(cachedEntry, bucket, job.jobRef, options.progress, options.runProgress);
 		} catch (error) {
 			if (!(error instanceof CacheReplayProcessingError)) throw error;
-			return finish(job, options, bucket, {
+			job.target.cacheOwner?.discard(slot);
+			return finish(job, bucket, {
 				cache: "hit",
-				cause: error.cause,
 				failure: failure(error.cause, job, "cache-replay"),
 				state: "failed"
 			});
 		}
-		return finish(job, options, bucket, {
+		return finish(job, bucket, {
 			cache: "hit",
 			state: "cached"
 		});
 	}
-	if (options.cacheOnly) return finish(job, options, bucket, {
+	if (options.cacheOnly) return finish(job, bucket, {
 		cache: "miss",
 		state: "skipped"
 	});
@@ -715,8 +827,10 @@ async function executeRuleJob(job, options) {
 	const state = {
 		activeFilePath: job.target.activeFilePath,
 		bucket,
-		job: job.job,
+		jobRef: job.jobRef,
 		reporterFailed: false,
+		runProgress: options.runProgress,
+		sealed: false,
 		signal: controller.signal
 	};
 	let handlerCause;
@@ -728,31 +842,29 @@ async function executeRuleJob(job, options) {
 		handlerCause = cause;
 		handlerFailed = true;
 	} finally {
+		state.sealed = true;
 		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, {
+	if (options.runSignal?.aborted) return finish(job, bucket, {
 		cache: "miss",
 		state: "cancelled"
 	});
-	if (timedOut) return finish(job, options, bucket, {
+	if (timedOut) return finish(job, bucket, {
 		cache: "miss",
-		cause: deadlineError,
 		failure: failure(deadlineError, job, "timeout"),
 		state: "failed"
 	});
-	if (handlerFailed) return finish(job, options, bucket, {
+	if (handlerFailed) return finish(job, bucket, {
 		cache: "miss",
-		cause: handlerCause,
 		failure: failure(handlerCause, job, "handler"),
 		state: "failed"
 	});
-	return finish(job, options, bucket, {
+	if (slot && fingerprint) try {
+		job.target.cacheOwner?.put(slot, createCacheEntry(job, fingerprint, bucket));
+	} catch {}
+	return finish(job, bucket, {
 		cache: "miss",
 		state: "completed"
 	});
@@ -762,44 +874,44 @@ function resolveRuleExecutionTimeout(timeoutMs) {
 	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) {
+function createCacheEntry(job, fingerprint, bucket) {
 	return {
-		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
-		},
+		diagnostics: snapshotDiagnostics(bucket.diagnostics),
+		fingerprint,
 		target: {
-			hash: createTargetHash(job),
+			hash: fingerprint.targetHash,
 			identity: job.target.identity,
 			kind: job.target.kind,
-			loc: job.target.loc,
+			loc: job.target.loc ? {
+				end: {
+					column: job.target.loc.end.column,
+					line: job.target.loc.end.line
+				},
+				start: {
+					column: job.target.loc.start.column,
+					line: job.target.loc.start.line
+				}
+			} : void 0,
 			name: job.target.name,
-			range: job.target.range
+			range: job.target.range ? {
+				end: job.target.range.end,
+				start: job.target.range.start
+			} : void 0
 		},
-		usage: bucket.usage
+		usage: snapshotUsageRecords(bucket.usage)
 	};
 }
-function createExecutionCacheKey(job, cache) {
-	if (!cache.enabled || !job.execution.runtime.cacheable || job.target.cacheFilePaths.length === 0) return void 0;
-	return createCacheKey({
-		alintVersion: version,
+function createFingerprint(job, modelHash) {
+	return {
 		configHash: job.target.configHash,
-		filePath: normalizeCachePath(cache.cwd, job.job.inputPath),
-		modelHash: cache.modelHash,
+		modelHash,
 		ruleHash: job.execution.runtime.ruleHash,
-		schemaVersion: 1,
-		targetHash: createTargetHash(job),
-		targetIdentity: job.target.identity,
-		targetKind: job.target.kind
-	});
+		targetHash: createTargetHash(job)
+	};
 }
 function createTargetHash(job) {
 	const target = job.target;
-	return stableHash({
+	return target.cacheTargetHash ?? stableHash({
 		language: target.language,
 		loc: target.loc,
 		metadata: target.metadata,
@@ -811,36 +923,32 @@ function createTargetHash(job) {
 }
 function failure(cause, job, kind) {
 	return {
-		job: job.job,
+		job: snapshotProgressJobRef(job.jobRef),
 		kind,
-		message: errorMessageFrom(cause) ?? String(cause)
+		message: failureMessage$1(cause)
 	};
 }
-function finish(job, options, bucket, terminal) {
-	const outcome = {
-		bucket,
-		job,
-		...terminal
-	};
-	options.progress?.onJobEnd?.({
-		cache: outcome.cache,
-		endedAt: options.clock(),
-		failure: outcome.failure,
-		job: job.job,
-		startedAt: options.startedAt,
-		state: outcome.state
-	});
-	return outcome;
-}
-function rememberCacheEntry(cache, filePaths, cacheKey) {
-	for (const filePath of filePaths) {
-		const normalizedPath = normalizeCachePath(cache.cwd, filePath);
-		const entries = cache.fileEntryKeys.get(normalizedPath) ?? /* @__PURE__ */ new Set();
-		entries.add(cacheKey);
-		cache.fileEntryKeys.set(normalizedPath, entries);
+function failureMessage$1(cause) {
+	try {
+		return errorMessageFrom(cause) ?? "Unknown rule failure.";
+	} catch {
+		return "Unknown rule failure.";
 	}
 }
-function replayCachedEntry(entry, bucket, job, progress) {
+function finish(job, bucket, terminal) {
+	const detachedTerminal = terminal.state === "failed" ? {
+		...terminal,
+		failure: snapshotFailure(terminal.failure)
+	} : terminal;
+	return {
+		diagnostics: snapshotDiagnostics(bucket.diagnostics),
+		jobRef: snapshotProgressJobRef(job.jobRef),
+		orderKey: { ...job.orderKey },
+		usage: snapshotUsageRecords(bucket.usage),
+		...detachedTerminal
+	};
+}
+function replayCachedEntry(entry, bucket, job, progress, runProgress) {
 	let diagnostics;
 	let usage;
 	try {
@@ -850,452 +958,209 @@ function replayCachedEntry(entry, bucket, job, progress) {
 		throw new CacheReplayProcessingError(cause);
 	}
 	for (const cachedDiagnostic of diagnostics) {
-		const diagnostic = {
+		const diagnostic = snapshotDiagnostic({
 			...cachedDiagnostic,
 			cached: true
-		};
+		});
 		bucket.diagnostics.push(diagnostic);
 		progress?.onDiagnostic?.({
-			diagnostic,
-			job
+			diagnostic: snapshotDiagnostic(diagnostic),
+			job: snapshotProgressJobRef(job),
+			progress: runProgress.snapshot()
 		});
 	}
 	for (const record of usage) {
-		bucket.usage.push(record);
+		const usageRecord = snapshotUsage(record);
+		bucket.usage.push(usageRecord);
 		progress?.onUsage?.({
-			job,
-			record
+			job: snapshotProgressJobRef(job),
+			progress: runProgress.snapshot(),
+			record: snapshotUsage(usageRecord)
 		});
 	}
 }
-//#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
-		};
-	});
+function scopeRank(scope) {
+	if (scope === "source") return 0;
+	if (scope === "directory") return 1;
+	return 2;
 }
 //#endregion
-//#region src/core/targets/project.ts
-function createProjectExecutionPlan(options) {
-	const project = createProjectTarget(options.root, options.files);
-	const executions = options.ruleRuntimes.map((runtime) => {
-		if (runtime.handlers.onTargetWith) return {
-			run: () => runtime.handlers.onTargetWith?.(project),
-			runtime
-		};
-		if (runtime.handlers.onTargetProject) return {
-			run: () => runtime.handlers.onTargetProject?.(project),
-			runtime
+//#region src/core/execution/progress.ts
+function createRunProgress(filesTotal) {
+	assertNonNegativeInteger(filesTotal, "File total");
+	const execution = createCounts();
+	let final = false;
+	const snapshot = () => {
+		const jobsCompleted = terminalCount(execution);
+		return {
+			execution: { ...execution },
+			filesTotal,
+			final,
+			jobsCompleted,
+			jobsStarted: jobsCompleted + execution.running,
+			jobsTotal: execution.planned
 		};
-	}).filter((execution) => execution !== void 0);
-	if (executions.length === 0) return;
-	const target = {
-		cacheFilePaths: options.files.map((file) => file.file.path),
-		configHash: options.configHash,
-		executions,
-		identity: "project",
-		kind: "project",
-		language: "project",
-		text: stableHash({
-			files: options.files.map((file) => ({
-				configHash: file.configHash,
-				contentHash: hashText(file.file.text),
-				path: normalizeCachePath(options.root, file.file.path)
-			})).sort((left, right) => left.path.localeCompare(right.path)),
-			targets: project.targets.map((target) => ({
-				filePath: normalizeCachePath(options.root, target.file.path),
-				identity: target.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
-			})),
-			tree: createProjectTreeShape(options.files, options.root)
-		})
-	};
-	return {
-		id: `project:${options.root}`,
-		index: options.index,
-		kind: "project",
-		path: options.root,
-		planned: executions.length,
-		targets: [target]
-	};
-}
-function createProjectTarget(root, files) {
-	const preparedFiles = [...files].sort((left, right) => left.file.path.localeCompare(right.file.path));
-	return {
-		files: preparedFiles.map((file) => file.file),
-		kind: "project",
-		root,
-		targets: preparedFiles.flatMap((file) => file.targets)
 	};
-}
-function createProjectTreeShape(files, root) {
-	const directories = /* @__PURE__ */ new Set();
-	const paths = files.map((file) => normalizeCachePath(root, file.file.path)).sort();
-	for (const path of paths) {
-		const parts = path.split("/");
-		for (let index = 1; index < parts.length; index += 1) directories.add(parts.slice(0, index).join("/"));
-	}
 	return {
-		directories: [...directories].sort(),
-		files: paths
+		finalize: () => {
+			if (execution.queued !== 0 || execution.running !== 0) throw new Error("Cannot finalize progress while jobs are queued or running.");
+			final = true;
+			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);
+			assertNonNegativeInteger(count, "Queued job count");
+			assertSafeSum(execution.planned, count, "Planned job count");
+			assertSafeSum(execution.queued, count, "Queued job count");
+			execution.planned += count;
+			execution.queued += count;
+			return snapshot();
+		},
+		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;
+			return snapshot();
+		}
 	};
 }
-//#endregion
-//#region src/core/targets/source.ts
-function createSourceExecutionPlans(files, cwd) {
-	return files.map((preparedFile, fileOffset) => {
-		const targets = collectExecutionTargets(preparedFile);
-		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 = {
-			id: `source:${preparedFile.file.path}`,
-			index: fileOffset + 1,
-			kind: "source",
-			path: preparedFile.file.path,
-			planned: 0,
-			preparedFile,
-			targets
-		};
-		filePlan.planned = calculateFilePlanExecutions(filePlan);
-		return filePlan;
-	});
+function assertMutable(final) {
+	if (final) throw new Error("Cannot update finalized progress.");
 }
-function calculateFilePlanExecutions(filePlan) {
-	return filePlan.targets.reduce((total, target) => total + target.executions.length, 0);
-}
-function collectExecutionTargets(preparedFile) {
-	const targets = [];
-	for (const sourceTarget of preparedFile.targets) {
-		const executions = preparedFile.ruleRuntimes.map((runtime) => {
-			return createSourceTargetExecution(runtime, sourceTarget);
-		}).filter((execution) => execution !== void 0);
-		if (executions.length === 0) continue;
-		targets.push({
-			activeFilePath: preparedFile.file.path,
-			cacheFilePaths: [preparedFile.file.path],
-			configHash: preparedFile.configHash,
-			executions,
-			identity: sourceTarget.identity,
-			kind: sourceTarget.kind,
-			language: sourceTarget.language,
-			loc: sourceTarget.loc,
-			metadata: sourceTarget.metadata,
-			name: sourceTarget.name,
-			origin: sourceTarget.origin,
-			range: sourceTarget.range,
-			text: sourceTarget.text
-		});
-	}
-	return targets;
+function assertNonNegativeInteger(value, name) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError(`${name} must be a non-negative integer.`);
 }
-function createSourceTargetExecution(runtime, target) {
-	if (runtime.handlers.onTargetWith) return {
-		run: () => runtime.handlers.onTargetWith?.(target),
-		runtime
-	};
-	if (target.kind === "class" && runtime.handlers.onTargetClass) return {
-		run: () => runtime.handlers.onTargetClass?.(target),
-		runtime
-	};
-	if (target.kind === "file" && runtime.handlers.onTargetFile) return {
-		run: () => runtime.handlers.onTargetFile?.(target),
-		runtime
-	};
-	if (target.kind === "function" && runtime.handlers.onTargetFunction) return {
-		run: () => runtime.handlers.onTargetFunction?.(target),
-		runtime
-	};
+function assertSafeSum(left, right, name) {
+	if (!Number.isSafeInteger(left + right)) throw new TypeError(`${name} must remain a safe integer.`);
 }
-function toTargetIdentityInput(cwd, filePath, target) {
+function createCounts() {
 	return {
-		filePath: target.kind === "file" ? normalizeCachePath(cwd, filePath) : void 0,
-		identity: target.identity,
-		kind: target.kind,
-		name: target.name,
-		range: target.range
+		cached: 0,
+		cancelled: 0,
+		completed: 0,
+		failed: 0,
+		planned: 0,
+		queued: 0,
+		running: 0,
+		skipped: 0
 	};
 }
+function terminalCount(execution) {
+	return execution.cached + execution.cancelled + execution.completed + execution.failed + execution.skipped;
+}
 //#endregion
-//#region src/core/run.ts
-var AlintRunCancelledError = class extends Error {
-	result;
-	constructor(result, cause) {
-		super("Alint run cancelled.", { cause });
-		this.name = "AlintRunCancelledError";
-		this.result = result;
-	}
-};
-/** Cancellation error carrying the partial result gathered before the abort. */
-var AlintAbortError = class extends AlintRunCancelledError {
-	constructor(result, options = {}) {
-		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 ?? {
-		providers: [],
-		version: 1
-	};
-	const clock = Date.now;
-	const src = createSourceRuntime();
-	const normalizedCacheConfig = normalizeRunnerCacheConfig(options.runner?.cache, cwd$1);
-	const cacheStore = await createCacheStore({
-		cwd: cwd$1,
-		enabled: normalizedCacheConfig.enabled,
-		location: normalizedCacheConfig.location
-	});
-	const cacheContext = {
-		cwd: cwd$1,
-		enabled: normalizedCacheConfig.enabled,
-		fileEntryKeys: /* @__PURE__ */ new Map(),
-		modelHash: stableHash({
-			modelOverride: options.modelOverride,
-			outputLanguage: options.outputLanguage,
-			setupConfig
-		}),
-		store: cacheStore
-	};
-	const pendingFiles = [...options.files ?? []];
-	const pendingDirectories = [...options.directories ?? []];
-	const files = (await Promise.all(pendingFiles.map(async (filePath) => {
-		const file = await src.readFile(resolve(cwd$1, filePath));
-		const resolvedConfig = resolveConfigForFile(file.path, config, { cwd: cwd$1 });
-		if (resolvedConfig.ignored) return;
-		const effectiveConfig = resolvedConfig.config;
-		const languageRegistry = createBuiltInLanguageRegistry();
-		for (const plugin of Object.values(effectiveConfig.plugins)) for (const language of Object.values(plugin.languages ?? {})) registerLanguage(languageRegistry, language);
-		const language = resolveLanguage(file, languageRegistry, { language: effectiveConfig.language });
-		const targets = await language.extract(file, {
-			cwd: cwd$1,
-			languageOptions: effectiveConfig.languageOptions,
-			src
-		});
-		const registry = buildRuleRegistry(effectiveConfig);
-		const ruleRuntimes = createRuleRuntimes({
-			cwd: cwd$1,
-			effectiveAgent: effectiveConfig.agent,
-			effectiveSettings: effectiveConfig.settings,
-			options,
-			progress: options.progress,
-			registry,
-			setupConfig,
-			src
-		});
-		return {
-			configHash: stableHash({
-				language: effectiveConfig.language,
-				languageOptions: effectiveConfig.languageOptions,
-				processor: effectiveConfig.processor,
-				resolvedLanguage: language.name,
-				settings: effectiveConfig.settings
-			}),
-			file,
-			ruleRuntimes,
-			targets
-		};
-	}))).filter((file) => file !== void 0);
-	const directories = pendingDirectories.map((directoryPath) => {
-		const target = {
-			kind: "directory",
-			path: resolve(cwd$1, directoryPath)
-		};
-		const resolvedConfig = resolveConfigForDirectory(target.path, config, { cwd: cwd$1 });
-		if (resolvedConfig.ignored) return;
-		const effectiveConfig = resolvedConfig.config;
-		const registry = buildRuleRegistry(effectiveConfig);
-		return {
-			configHash: stableHash({ settings: effectiveConfig.settings }),
-			ruleRuntimes: createRuleRuntimes({
-				cwd: cwd$1,
-				effectiveAgent: effectiveConfig.agent,
-				effectiveSettings: effectiveConfig.settings,
-				options,
-				progress: options.progress,
-				registry,
-				setupConfig,
-				src
-			}),
-			target
-		};
-	}).filter((directory) => directory !== void 0);
-	const resolvedProjectConfig = resolveConfigForProject(cwd$1, config, { cwd: cwd$1 });
-	const projectConfig = resolvedProjectConfig.config;
-	const projectRuleRuntimes = resolvedProjectConfig.ignored ? [] : createRuleRuntimes({
-		cwd: cwd$1,
-		effectiveAgent: projectConfig.agent,
-		effectiveSettings: projectConfig.settings,
-		options,
-		progress: options.progress,
-		registry: buildRuleRegistry(projectConfig),
-		setupConfig,
-		src
-	});
-	const filePlans = createSourceExecutionPlans(files, cwd$1);
-	const directoryPlans = createDirectoryExecutionPlans(directories, filePlans.length);
-	const projectPlan = resolvedProjectConfig.ignored || options.projectTargets === false ? 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
-	});
-	for (const job of jobs) options.progress?.onJobQueued?.({ job: job.job });
-	try {
-		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;
-					}
-				}
+//#region src/models/resolve.ts
+function resolveModel(registry, options = {}) {
+	const candidates = flattenModels(registry);
+	const ruleId = options.ruleId ?? "<unknown>";
+	if (options.request !== void 0) {
+		const request = options.request;
+		const canonicalCandidates = candidates.filter((candidate) => canonicalIdentity(candidate) === request);
+		if (canonicalCandidates.length > 1) throw duplicateDefinitionError(request);
+		let candidate = canonicalCandidates[0];
+		if (candidate === void 0) {
+			const matchingCandidates = candidates.filter((candidate) => matchesRequest(candidate, request));
+			const matchesByCanonical = /* @__PURE__ */ new Map();
+			for (const matchingCandidate of matchingCandidates) {
+				const identity = canonicalIdentity(matchingCandidate);
+				const matches = matchesByCanonical.get(identity) ?? [];
+				matches.push(matchingCandidate);
+				matchesByCanonical.set(identity, matches);
 			}
-		};
-		await Promise.all(Array.from({ length: Math.min(concurrency, jobs.length) }, worker));
-	} finally {
-		if (!options.cacheOnly) await reconcileCache(filePlans, cacheContext);
+			const duplicateIdentity = [...matchesByCanonical].find(([, matches]) => matches.length > 1)?.[0];
+			if (duplicateIdentity !== void 0) throw duplicateDefinitionError(duplicateIdentity);
+			if (matchingCandidates.length === 0) throw new Error(`Unknown model "${request}".`);
+			if (matchingCandidates.length > 1) {
+				const choices = [...matchesByCanonical.keys()];
+				throw new Error(`Ambiguous model "${request}".\nSpecify a provider-qualified model:\n${choices.map((choice) => `  ${choice}`).join("\n")}`);
+			}
+			candidate = matchingCandidates[0];
+		}
+		if (!satisfiesHardRequirements(candidate.model, options.requirement)) throw new Error(`Model "${request}" does not satisfy requirement for rule "${ruleId}".`);
+		return toResolvedModel(candidate, options.requirement);
 	}
-	const outcomes = Array.from({ length: jobs.length }, (_, index) => settledOutcomes[index] ?? {
-		bucket: {
-			diagnostics: [],
-			usage: []
+	const candidate = preferSize(candidates.filter(({ model }) => satisfiesHardRequirements(model, options.requirement)), options.requirement);
+	if (candidate === void 0) throw new Error(`No model satisfies requirement for rule "${ruleId}".`);
+	return toResolvedModel(candidate, options.requirement);
+}
+function canonicalIdentity({ model, provider }) {
+	return `${provider.id}/${model.id}`;
+}
+function duplicateDefinitionError(identity) {
+	return /* @__PURE__ */ new Error(`Model "${identity}" is configured more than once.\nRemove duplicate provider/model definitions from the setup configuration.`);
+}
+function flattenModels(registry) {
+	return registry.providers.flatMap((provider) => provider.models.map((model) => ({
+		model,
+		provider
+	})));
+}
+function matchesRequest(candidate, request) {
+	return [
+		candidate.model.id,
+		candidate.model.name,
+		...candidate.model.aliases ?? []
+	].filter((name) => name !== void 0).some((name) => name === request || `${candidate.provider.id}/${name}` === request);
+}
+function preferSize(candidates, requirement) {
+	if (requirement?.size === void 0) return candidates[0];
+	return candidates.find(({ model }) => model.size === requirement.size) ?? candidates[0];
+}
+function satisfiesHardRequirements(model, requirement) {
+	if (requirement === void 0) return true;
+	if (requirement.capabilities !== void 0 && !requirement.capabilities.every((capability) => (model.capabilities ?? []).includes(capability))) return false;
+	if (requirement.minContextWindow !== void 0 && (model.contextWindow === void 0 || model.contextWindow < requirement.minContextWindow)) return false;
+	return true;
+}
+function toResolvedModel(candidate, requirement) {
+	const { model, provider } = candidate;
+	return {
+		aliases: [...model.aliases ?? []],
+		capabilities: [...model.capabilities ?? []],
+		contextWindow: model.contextWindow,
+		id: model.id,
+		name: model.name ?? model.id,
+		params: {
+			...model.defaultParams ?? {},
+			...requirement?.params ?? {}
 		},
-		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: outcomes.flatMap((outcome) => outcome.bucket.diagnostics),
-		execution: executionCounts(outcomes),
-		usage: runUsage(outcomes)
+		provider: {
+			endpoint: provider.endpoint,
+			headers: { ...provider.headers ?? {} },
+			id: provider.id,
+			type: provider.type
+		},
+		size: model.size
 	};
-	options.progress?.onRunEnd?.({
-		diagnostics: result.diagnostics,
-		endedAt: clock(),
-		execution: result.execution,
-		startedAt: runStartedAt,
-		usage: result.usage
-	});
-	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;
 }
+//#endregion
+//#region src/core/execution/runtime.ts
 function createRuleRuntimes(options) {
-	return options.registry.enabledRules.map((enabledRule) => {
+	return options.rules.map(({ enabledRule, ruleIndex }) => {
 		const executionState = new AsyncLocalStorage();
 		const context = {
 			agent: options.effectiveAgent ? withAgentRetry((request) => options.effectiveAgent({
 				...request,
 				signal: combineAbortSignals(executionState.getStore()?.signal, request.signal)
-			}), options.options.runner?.agentRetries, { onRetry: ({ attempt, maxAttempts }) => {
+			}), options.runOptions.runner?.agentRetries, { onRetry: ({ attempt, maxAttempts }) => {
 				const state = executionState.getStore();
-				if (!state) return;
+				if (!state || state.sealed) return;
 				const startedAt = Date.now();
 				try {
 					options.progress?.onJobRetry?.({
 						attempt,
-						job: state.job,
+						job: snapshotProgressJobRef(state.jobRef),
 						maxAttempts,
+						progress: state.runProgress.snapshot(),
 						startedAt
 					});
 				} catch (cause) {
@@ -1313,15 +1178,17 @@ function createRuleRuntimes(options) {
 			metering: { recordUsage: (record) => {
 				const state = executionState.getStore();
 				if (!state) throw new Error("Cannot record usage outside an active rule job.");
-				const usageRecord = {
+				if (state.sealed) return;
+				const usageRecord = snapshotUsage({
 					...record,
 					ruleId: record.ruleId ?? enabledRule.id
-				};
+				});
 				state.bucket.usage.push(usageRecord);
 				try {
 					options.progress?.onUsage?.({
-						job: state.job,
-						record: usageRecord
+						job: snapshotProgressJobRef(state.jobRef),
+						progress: state.runProgress.snapshot(),
+						record: snapshotUsage(usageRecord)
 					});
 				} catch (cause) {
 					if (!state.reporterFailed) {
@@ -1332,7 +1199,7 @@ function createRuleRuntimes(options) {
 				}
 			} },
 			model: async (selector) => {
-				const request = options.options.modelOverride ?? (typeof selector === "string" ? selector : void 0);
+				const request = options.runOptions.modelOverride ?? (typeof selector === "string" ? selector : void 0);
 				const requirement = mergeModelRequirement(enabledRule.rule.model, typeof selector === "string" ? void 0 : selector);
 				const resolvedModel = resolveModel(options.setupConfig, {
 					request,
@@ -1340,19 +1207,20 @@ function createRuleRuntimes(options) {
 					ruleId: enabledRule.id
 				});
 				const state = executionState.getStore();
-				if (state) state.currentModel = toDiagnosticModel(resolvedModel, request);
+				if (state && !state.sealed) state.currentModel = toDiagnosticModel(resolvedModel, request);
 				return resolvedModel;
 			},
 			options: enabledRule.options,
-			outputLanguage: options.options.outputLanguage,
+			outputLanguage: options.runOptions.outputLanguage,
 			report: (descriptor) => {
 				const state = executionState.getStore();
 				if (!state) throw new Error("Cannot report a diagnostic outside an active rule job.");
+				if (state.sealed) return;
 				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;
 				state.currentModel = void 0;
-				const diagnostic = {
+				const diagnostic = snapshotDiagnostic({
 					evidence: descriptor.evidence,
 					filePath,
 					loc: descriptor.loc,
@@ -1360,12 +1228,13 @@ function createRuleRuntimes(options) {
 					model: diagnosticModel,
 					ruleId: enabledRule.id,
 					severity: enabledRule.severity
-				};
+				});
 				state.bucket.diagnostics.push(diagnostic);
 				try {
 					options.progress?.onDiagnostic?.({
-						diagnostic,
-						job: state.job
+						diagnostic: snapshotDiagnostic(diagnostic),
+						job: snapshotProgressJobRef(state.jobRef),
+						progress: state.runProgress.snapshot()
 					});
 				} catch (cause) {
 					if (!state.reporterFailed) {
@@ -1395,26 +1264,13 @@ function createRuleRuntimes(options) {
 				model: enabledRule.rule.model,
 				options: enabledRule.options,
 				severity: enabledRule.severity
-			})
+			}),
+			ruleIndex
 		};
 	});
 }
-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;
+	if (!base && !extra) return void 0;
 	return [.../* @__PURE__ */ new Set([...base ?? [], ...extra ?? []])];
 }
 function mergeMinContextWindow(base, extra) {
@@ -1423,7 +1279,7 @@ function mergeMinContextWindow(base, extra) {
 	return Math.max(base, extra);
 }
 function mergeModelRequirement(base, extra) {
-	if (!base && !extra) return;
+	if (!base && !extra) return void 0;
 	const capabilities = mergeCapabilities(base?.capabilities, extra?.capabilities);
 	const params = {
 		...base?.params ?? {},
@@ -1436,36 +1292,1080 @@ function mergeModelRequirement(base, extra) {
 		size: extra?.size ?? base?.size
 	};
 }
-async function reconcileCache(filePlans, cacheContext) {
-	try {
-		for (const filePlan of filePlans) {
-			const file = filePlan.preparedFile.file;
-			const normalizedPath = normalizeCachePath(cacheContext.cwd, file.path);
-			const entries = [...cacheContext.fileEntryKeys.get(normalizedPath) ?? []];
-			cacheContext.store.markFile(file.path, hashText(file.text), entries);
-		}
-		await cacheContext.store.reconcile();
-	} catch {}
+function toDiagnosticModel(model, request) {
+	return {
+		providerId: model.provider.id,
+		requested: request,
+		resolvedId: model.id
+	};
 }
-function resolveRuleConcurrency(ruleConcurrency) {
-	if (ruleConcurrency === void 0) return 4;
+//#endregion
+//#region src/core/execution/scheduler.ts
+var RuleScheduler = class {
+	options;
+	accepting = true;
+	active = 0;
+	cancellingQueued = false;
+	closePromise;
+	closeReject;
+	closeResolve;
+	infrastructureError;
+	infrastructureFailed = false;
+	lanes = [];
+	nextAdmissionIndex = 1;
+	pumpQueued = false;
+	readyLanes = [];
+	constructor(options) {
+		this.options = options;
+		resolveRuleConcurrency(options.concurrency);
+		if (options.signal?.aborted) this.accepting = false;
+		else options.signal?.addEventListener("abort", this.abort, { once: true });
+	}
+	cancelWithError(error) {
+		this.fail(error);
+	}
+	close() {
+		this.accepting = false;
+		if (!this.closePromise) this.closePromise = new Promise((resolve, reject) => {
+			this.closeResolve = resolve;
+			this.closeReject = reject;
+		});
+		this.queuePump();
+		this.settleClose();
+		return this.closePromise;
+	}
+	schedule(jobs) {
+		if (!this.accepting || jobs.length === 0) return {
+			jobsAdded: 0,
+			outcomes: Promise.resolve([])
+		};
+		const lane = createLane();
+		this.lanes.push(lane);
+		let jobsAdded = 0;
+		for (const job of jobs) {
+			if (!this.accepting) break;
+			const index = jobsAdded;
+			try {
+				job.jobRef.index = this.nextAdmissionIndex;
+				this.nextAdmissionIndex += 1;
+				const progress = this.options.progress.queue();
+				jobsAdded += 1;
+				lane.remaining += 1;
+				lane.items.push({
+					index,
+					job,
+					lane
+				});
+				this.options.reporter?.onJobQueued?.({
+					job: snapshotProgressJobRef(job.jobRef),
+					progress
+				});
+			} catch (error) {
+				this.fail(error);
+				throw error;
+			}
+		}
+		lane.outcomes.length = jobsAdded;
+		if (jobsAdded === 0) this.settleLane(lane);
+		else {
+			this.enqueue(lane);
+			this.queuePump();
+		}
+		return {
+			jobsAdded,
+			outcomes: lane.promise
+		};
+	}
+	snapshot() {
+		return this.options.progress.snapshot();
+	}
+	abort = () => {
+		this.accepting = false;
+		this.cancelQueued();
+		this.settleClose();
+	};
+	cancel(item, from, startedAt) {
+		const outcome = cancelledOutcome(item.job);
+		const progress = this.options.progress.finish(from, "cancelled");
+		item.lane.outcomes[item.index] = outcome;
+		item.lane.remaining -= 1;
+		try {
+			this.options.reporter?.onJobEnd?.({
+				cache: "miss",
+				endedAt: this.options.clock(),
+				job: snapshotProgressJobRef(item.job.jobRef),
+				progress,
+				startedAt,
+				state: "cancelled"
+			});
+		} catch (error) {
+			this.fail(error);
+		}
+		this.settleLane(item.lane);
+	}
+	cancelQueued() {
+		if (this.cancellingQueued) return;
+		this.cancellingQueued = true;
+		this.readyLanes = [];
+		for (const lane of this.lanes) lane.ready = false;
+		try {
+			for (const lane of [...this.lanes]) {
+				const queued = lane.items.splice(0);
+				for (const item of queued) this.cancel(item, "queued");
+			}
+		} finally {
+			this.cancellingQueued = false;
+		}
+	}
+	enqueue(lane) {
+		if (lane.ready || lane.settled || lane.items.length === 0) return;
+		lane.ready = true;
+		this.readyLanes.push(lane);
+	}
+	fail(error) {
+		this.recordFailure(error);
+		this.accepting = false;
+		this.cancelQueued();
+		this.settleClose();
+	}
+	finish(item, outcome, startedAt) {
+		const progress = this.options.progress.finish("running", outcome.state);
+		item.lane.outcomes[item.index] = outcome;
+		item.lane.remaining -= 1;
+		try {
+			this.options.reporter?.onJobEnd?.({
+				cache: outcome.cache,
+				endedAt: this.options.clock(),
+				failure: outcome.failure ? snapshotFailure(outcome.failure) : void 0,
+				job: snapshotProgressJobRef(item.job.jobRef),
+				progress,
+				startedAt,
+				state: outcome.state
+			});
+		} catch (error) {
+			this.fail(error);
+		}
+		this.settleLane(item.lane);
+	}
+	next() {
+		while (this.readyLanes.length > 0) {
+			const lane = this.readyLanes.shift();
+			lane.ready = false;
+			const item = lane.items.shift();
+			this.enqueue(lane);
+			if (item) return item;
+		}
+	}
+	pump() {
+		this.pumpQueued = false;
+		if (this.infrastructureFailed || this.options.signal?.aborted) {
+			this.cancelQueued();
+			this.settleClose();
+			return;
+		}
+		while (this.active < this.options.concurrency) {
+			const item = this.next();
+			if (!item) break;
+			let startedAt;
+			try {
+				startedAt = this.options.clock();
+			} catch (error) {
+				this.fail(error);
+				this.cancel(item, "queued");
+				break;
+			}
+			try {
+				const progress = this.options.progress.start();
+				this.options.reporter?.onJobStart?.({
+					job: snapshotProgressJobRef(item.job.jobRef),
+					progress,
+					startedAt
+				});
+			} catch (error) {
+				this.fail(error);
+				this.cancel(item, "running");
+				break;
+			}
+			this.active += 1;
+			this.run(item, startedAt);
+		}
+		this.settleClose();
+	}
+	queuePump() {
+		if (this.pumpQueued) return;
+		this.pumpQueued = true;
+		queueMicrotask(() => this.pump());
+	}
+	recordFailure(error) {
+		if (this.infrastructureFailed) return;
+		this.infrastructureFailed = true;
+		this.infrastructureError = error;
+	}
+	removeLane(lane) {
+		const index = this.lanes.indexOf(lane);
+		if (index < 0) return;
+		this.lanes.splice(index, 1);
+		if (lane.ready) {
+			const readyIndex = this.readyLanes.indexOf(lane);
+			if (readyIndex >= 0) this.readyLanes.splice(readyIndex, 1);
+			lane.ready = false;
+		}
+	}
+	async run(item, startedAt) {
+		try {
+			const outcome = await this.options.execute(item.job, startedAt);
+			this.finish(item, outcome, startedAt);
+		} catch (error) {
+			this.fail(error);
+			this.cancel(item, "running", startedAt);
+		} finally {
+			this.active -= 1;
+			this.queuePump();
+			this.settleClose();
+		}
+	}
+	settleClose() {
+		if (!this.closePromise || this.active !== 0 || this.lanes.length !== 0) return;
+		this.options.signal?.removeEventListener("abort", this.abort);
+		if (this.infrastructureFailed) this.closeReject?.(this.infrastructureError);
+		else this.closeResolve?.();
+	}
+	settleLane(lane) {
+		if (lane.settled || lane.remaining !== 0) return;
+		lane.settled = true;
+		this.removeLane(lane);
+		lane.resolve(lane.outcomes.filter((outcome) => outcome !== void 0));
+		this.settleClose();
+	}
+};
+function cancelledOutcome(job) {
+	return {
+		cache: "miss",
+		diagnostics: [],
+		jobRef: snapshotProgressJobRef(job.jobRef),
+		orderKey: { ...job.orderKey },
+		state: "cancelled",
+		usage: []
+	};
+}
+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 createLane() {
+	let resolve;
+	return {
+		items: [],
+		outcomes: [],
+		promise: new Promise((resolvePromise) => {
+			resolve = resolvePromise;
+		}),
+		ready: false,
+		remaining: 0,
+		resolve,
+		settled: false
+	};
+}
+//#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 = [];
+	hash;
+	hasher = createStableHasher();
+	nextFileIndex = 0;
+	pending = /* @__PURE__ */ new Map();
+	root;
+	targets = [];
+	constructor(root) {
+		this.root = root;
+		this.hasher.update({ root });
+	}
+	add(snapshot) {
+		if (this.hash !== void 0) throw new Error("Cannot add a project file after the index has been built.");
+		if (!Number.isSafeInteger(snapshot.fileIndex) || snapshot.fileIndex < 0) throw new TypeError("Project file index must be a non-negative safe integer.");
+		if (snapshot.fileIndex < this.nextFileIndex || this.pending.has(snapshot.fileIndex)) throw new Error(`Project file index ${snapshot.fileIndex} has already been added.`);
+		this.pending.set(snapshot.fileIndex, copySnapshot(snapshot));
+		this.flushContiguousSnapshots();
+	}
+	build() {
+		if (this.pending.size > 0) throw new Error(`Cannot build project index with a gap at file index ${this.nextFileIndex}.`);
+		this.hash ??= this.hasher.digest();
+		return {
+			hash: this.hash,
+			target: {
+				files: this.files.map(copyFile),
+				kind: "project",
+				root: this.root,
+				targets: this.targets.map(copyDescriptor)
+			}
+		};
+	}
+	flushContiguousSnapshots() {
+		let snapshot = this.pending.get(this.nextFileIndex);
+		while (snapshot) {
+			this.pending.delete(this.nextFileIndex);
+			this.files.push(copyFile(snapshot.file));
+			this.targets.push(...snapshot.targets.map((target) => copyDescriptor(target.descriptor)));
+			this.hasher.update({
+				configHash: snapshot.configHash,
+				file: snapshot.file,
+				targets: snapshot.targets.map((target) => ({
+					descriptor: target.descriptor,
+					semanticHash: target.semanticHash
+				}))
+			});
+			this.nextFileIndex += 1;
+			snapshot = this.pending.get(this.nextFileIndex);
+		}
+	}
+};
+function createProjectJobs(options) {
+	const executions = options.runtimes.map((runtime) => projectExecution(runtime, options.project.target)).filter((execution) => execution !== void 0);
+	if (executions.length === 0) return { jobs: [] };
+	const owner = options.cacheStore.beginOwner({
+		kind: "project",
+		path: options.project.target.root
+	});
+	const target = {
+		cacheOwner: owner,
+		cacheTargetHash: options.project.hash,
+		configHash: options.configHash,
+		identity: "project",
+		kind: "project",
+		language: "project",
+		text: options.project.hash
+	};
+	return {
+		jobs: executions.map((execution) => {
+			const ruleId = execution.runtime.enabledRule.id;
+			return {
+				execution,
+				jobRef: {
+					id: stableHash({
+						input: options.project.target.root,
+						ruleId,
+						targetIdentity: "project",
+						targetIndex: 0
+					}),
+					index: 0,
+					inputPath: options.project.target.root,
+					ruleId,
+					target: {
+						identity: "project",
+						kind: "project"
+					}
+				},
+				orderKey: {
+					inputIndex: 0,
+					ruleIndex: execution.runtime.ruleIndex,
+					scope: "project",
+					targetIndex: 0
+				},
+				target
+			};
+		}),
+		owner
+	};
+}
+function copyDescriptor(descriptor) {
+	return {
+		filePath: descriptor.filePath,
+		identity: descriptor.identity,
+		kind: descriptor.kind,
+		name: descriptor.name,
+		range: descriptor.range && { ...descriptor.range }
+	};
+}
+function copyFile(file) {
+	return {
+		contentHash: file.contentHash,
+		language: file.language,
+		path: file.path,
+		targetCount: file.targetCount
+	};
+}
+function copySnapshot(snapshot) {
+	return {
+		configHash: snapshot.configHash,
+		file: copyFile(snapshot.file),
+		fileIndex: snapshot.fileIndex,
+		targets: snapshot.targets.map(copyTargetSnapshot)
+	};
+}
+function copyTargetSnapshot(target) {
+	return {
+		descriptor: copyDescriptor(target.descriptor),
+		semanticHash: target.semanticHash
+	};
+}
+function projectExecution(runtime, target) {
+	if (runtime.handlers.onTargetWith) return {
+		run: () => runtime.handlers.onTargetWith?.(target),
+		runtime
+	};
+	if (runtime.handlers.onTargetProject) return {
+		run: () => runtime.handlers.onTargetProject?.(target),
+		runtime
+	};
+}
+async function executeSourceSession(input, options) {
+	openSession(options.metrics);
+	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({
+			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 ? {
+			contentHash,
+			mode: "merge"
+		} : { contentHash });
+		return {
+			outcomes,
+			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));
+}
+function closeSession(metrics) {
+	if (!metrics) return;
+	metrics.active -= 1;
+	metrics.closed += 1;
+}
+function createExecutionTargets(input, targets, runtimes, cwd, cacheOwner) {
+	const resolveIdentity = createTargetIdentityResolver(targets.map((target) => ({
+		filePath: target.kind === "file" ? normalizeCachePath(cwd, input.path) : void 0,
+		identity: target.identity,
+		kind: target.kind,
+		name: target.name,
+		range: target.range
+	})));
+	return targets.map((target, targetIndex) => {
+		return {
+			executions: runtimes.map((runtime) => sourceExecution(runtime, target)).filter((execution) => execution !== void 0),
+			target: {
+				activeFilePath: input.path,
+				cacheOwner,
+				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),
+				kind: target.kind,
+				language: target.language,
+				loc: target.loc,
+				metadata: target.metadata,
+				name: target.name,
+				origin: target.origin,
+				range: target.range,
+				text: target.text
+			},
+			targetIndex
+		};
+	}).filter((target) => target.executions.length > 0);
+}
+function createProjectSnapshot(input, language, path, contentHash, targets) {
+	return {
+		configHash: input.configHash,
+		file: {
+			contentHash,
+			language,
+			path,
+			targetCount: targets.length
+		},
+		fileIndex: input.fileIndex,
+		targets: targets.map((target) => ({
+			descriptor: {
+				filePath: target.file.path,
+				identity: target.identity,
+				kind: target.kind,
+				...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
+			})
+		}))
+	};
+}
+function createSourceJobs(input, targets) {
+	return targets.flatMap(({ executions, target, targetIndex }) => executions.map((execution) => {
+		const ruleId = execution.runtime.enabledRule.id;
+		return {
+			execution,
+			jobRef: {
+				id: stableHash({
+					fileIndex: input.fileIndex,
+					input: input.path,
+					ruleId,
+					targetIdentity: target.identity,
+					targetIndex
+				}),
+				index: 0,
+				inputPath: input.path,
+				ruleId,
+				target: {
+					identity: target.identity,
+					kind: target.kind,
+					name: target.name
+				}
+			},
+			orderKey: {
+				inputIndex: input.fileIndex,
+				ruleIndex: execution.runtime.ruleIndex,
+				scope: "source",
+				targetIndex
+			},
+			target
+		};
+	}));
+}
+function failureMessage(error, fallback) {
+	try {
+		return errorMessageFrom(error) ?? fallback;
+	} catch {
+		return fallback;
+	}
+}
+function fileFailure(input, kind, message) {
+	return {
+		file: {
+			index: input.fileIndex,
+			path: input.path
+		},
+		kind,
+		message
+	};
+}
+function openSession(metrics) {
+	if (!metrics) return;
+	metrics.active += 1;
+	metrics.opened += 1;
+	metrics.maximumActive = Math.max(metrics.maximumActive, metrics.active);
+}
+function sourceExecution(runtime, target) {
+	if (runtime.handlers.onTargetWith) return {
+		run: () => runtime.handlers.onTargetWith?.(target),
+		runtime
+	};
+	if (target.kind === "class" && runtime.handlers.onTargetClass) return {
+		run: () => runtime.handlers.onTargetClass?.(target),
+		runtime
+	};
+	if (target.kind === "file" && runtime.handlers.onTargetFile) return {
+		run: () => runtime.handlers.onTargetFile?.(target),
+		runtime
+	};
+	if (target.kind === "function" && runtime.handlers.onTargetFunction) return {
+		run: () => runtime.handlers.onTargetFunction?.(target),
+		runtime
+	};
+}
+//#endregion
+//#region src/core/targets/directory.ts
+function createDirectoryJobs(input, runtimes) {
+	const target = input.target;
+	return runtimes.flatMap((runtime) => {
+		const execution = directoryExecution(runtime, target);
+		if (!execution) return [];
+		const ruleId = runtime.enabledRule.id;
+		return [{
+			execution,
+			jobRef: {
+				id: stableHash({
+					directoryIndex: input.directoryIndex,
+					input: target.path,
+					ruleId,
+					targetIdentity: target.path
+				}),
+				index: 0,
+				inputPath: target.path,
+				ruleId,
+				target: {
+					identity: target.path,
+					kind: "directory"
+				}
+			},
+			orderKey: {
+				inputIndex: input.directoryIndex,
+				ruleIndex: runtime.ruleIndex,
+				scope: "directory",
+				targetIndex: 0
+			},
+			target: {
+				activeFilePath: target.path,
+				configHash: input.configHash,
+				identity: target.path,
+				kind: "directory",
+				language: "directory",
+				text: target.path
+			}
+		}];
+	});
+}
+function directoryExecution(runtime, target) {
+	if (runtime.handlers.onTargetWith) return {
+		run: () => runtime.handlers.onTargetWith?.(target),
+		runtime
+	};
+	if (runtime.handlers.onTargetDirectory) return {
+		run: () => runtime.handlers.onTargetDirectory?.(target),
+		runtime
+	};
+}
+//#endregion
+//#region src/core/run.ts
+var AlintRunCancelledError = class extends Error {
+	result;
+	constructor(result, cause) {
+		super("Alint run cancelled.", { cause });
+		this.name = "AlintRunCancelledError";
+		this.result = result;
+	}
+};
+/** Cancellation error carrying the partial result gathered before the abort. */
+var AlintAbortError = class extends AlintRunCancelledError {
+	constructor(result, options = {}) {
+		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 clock = Date.now;
+	const timeoutMs = resolveRuleExecutionTimeout(options.runner?.timeoutMs);
+	const concurrency = resolveRuleConcurrency(options.runner?.ruleConcurrency);
+	const prepareStartedAt = clock();
+	options.progress?.onPrepareStart?.({ startedAt: prepareStartedAt });
+	const preparation = prepareRun(options);
+	options.progress?.onPrepareEnd?.({
+		endedAt: clock(),
+		filesTotal: preparation.files.length,
+		startedAt: prepareStartedAt
+	});
+	const runProgress = createRunProgress(preparation.files.length);
+	const runStartedAt = clock();
+	options.progress?.onExecuteStart?.({
+		progress: runProgress.snapshot(),
+		startedAt: runStartedAt
+	});
+	const cwd$1 = options.cwd ?? cwd();
+	const setupConfig = options.setupConfig ?? {
+		providers: [],
+		version: 1
+	};
+	const src = createSourceRuntime();
+	const normalizedCacheConfig = normalizeRunnerCacheConfig(options.runner?.cache, cwd$1);
+	const cacheStore = await createCacheStore({
+		cwd: cwd$1,
+		enabled: normalizedCacheConfig.enabled,
+		location: normalizedCacheConfig.location,
+		readOnly: options.cacheOnly
+	});
+	const cacheContext = { modelHash: stableHash({
+		modelOverride: options.modelOverride,
+		outputLanguage: options.outputLanguage,
+		setupConfig
+	}) };
+	const createRuntimes = (input) => createRuleRuntimes({
+		cwd: cwd$1,
+		effectiveAgent: input.agent,
+		effectiveSettings: input.settings,
+		progress: options.progress,
+		rules: input.rules,
+		runOptions: options,
+		runProgress,
+		setupConfig,
+		src
+	});
+	const scheduler = new RuleScheduler({
+		clock,
+		concurrency,
+		execute: (job, _startedAt) => executeRuleJob(job, {
+			cache: cacheContext,
+			cacheOnly: options.cacheOnly,
+			progress: options.progress,
+			runProgress,
+			runSignal: options.signal,
+			timeoutMs
+		}),
+		progress: runProgress,
+		reporter: options.progress,
+		signal: options.signal
+	});
+	const outcomes = [];
+	const fileFailures = [];
+	let infrastructureError;
+	let infrastructureFailed = false;
+	let admissionFailed = false;
+	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, {
+			cacheStore,
+			createRuleRuntimes: createRuntimes,
+			cwd: cwd$1,
+			progress: options.progress,
+			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);
+		}
+		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());
+		if (fileFailures.length === 0 && preparation.project && !options.signal?.aborted) {
+			if (projectBuilder) {
+				const project = createProjectJobs({
+					cacheStore,
+					configHash: preparation.project.configHash,
+					project: projectBuilder.build(),
+					runtimes: projectRuntimes
+				});
+				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" });
+		}
+	} catch (error) {
+		scheduler.cancelWithError(error);
+		infrastructureError = error;
+		infrastructureFailed = true;
+		admissionFailed = true;
+	} finally {
+		try {
+			await scheduler.close();
+		} catch (error) {
+			infrastructureError ??= error;
+			infrastructureFailed = true;
+		}
+		if (!admissionFailed && !options.cacheOnly) try {
+			await cacheStore.reconcile();
+		} catch {}
+	}
+	runProgress.finalize();
+	if (admissionFailed) throw infrastructureError;
+	outcomes.sort((left, right) => compareJobOrder(left.orderKey, right.orderKey));
+	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),
+		execution: executionCounts(outcomes),
+		usage: runUsage(outcomes)
+	};
+	options.progress?.onExecuteEnd?.({
+		endedAt: clock(),
+		progress: runProgress.snapshot()
+	});
+	options.progress?.onRunEnd?.({
+		diagnostics: snapshotDiagnostics(result.diagnostics),
+		endedAt: clock(),
+		execution: { ...result.execution },
+		progress: runProgress.snapshot(),
+		startedAt: runStartedAt,
+		usage: snapshotRunUsage(result.usage)
+	});
+	if (infrastructureFailed) throw infrastructureError;
+	if (options.signal?.aborted) throw new AlintAbortError(result, { cause: options.signal.reason });
+	if (failures.length > 0) throw new AlintRunError(fileFailures.length > 0 ? `${failures.length} alint execution${failures.length === 1 ? "" : "s"} failed.` : `${failures.length} rule execution${failures.length === 1 ? "" : "s"} failed.`, result, {
+		cause: new AggregateError(failures.map((failure) => new Error(failure.message)), "Alint execution failures."),
+		failures
+	});
+	return result;
+}
+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 runUsage(outcomes) {
 	const live = [];
 	const cached = [];
-	for (const outcome of outcomes) (outcome.state === "cached" ? cached : live).push(...outcome.bucket.usage);
+	for (const outcome of outcomes) (outcome.state === "cached" ? cached : live).push(...outcome.usage);
 	return {
 		...usageTotals(live),
 		...cached.length > 0 ? { cached: usageTotals(cached) } : {}
 	};
 }
-function toDiagnosticModel(model, request) {
+function snapshotRunUsage(usage) {
 	return {
-		providerId: model.provider.id,
-		requested: request,
-		resolvedId: model.id
+		...usage,
+		...usage.cached ? { cached: {
+			...usage.cached,
+			records: snapshotUsageRecords(usage.cached.records)
+		} } : {},
+		records: snapshotUsageRecords(usage.records)
 	};
 }
 function usageTotals(records) {