@alint-js/core 0.6.0 → 0.7.1

package/dist/index.mjs

@@ -4,16 +4,17 @@ import { a as createSourceFile, c as sliceRange, d as stableHash, i as SourceCha
 import { minimatch } from "minimatch";
 import { basename, extname, isAbsolute, relative, resolve } from "pathe";
 import { array, boolean, check, custom, finite, getDotPath, integer, literal, looseObject, maxValue, minValue, number, object, optional, parse, picklist, pipe, record, safeParse, string, union, unknown } from "valibot";
-import { randomUUID } from "node:crypto";
-import { access, appendFile, mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { basename as basename$1, dirname, extname as extname$1, isAbsolute as isAbsolute$1, join, relative as relative$1, resolve as resolve$1, sep } from "node:path";
 import process, { cwd } from "node:process";
 import { Buffer } from "node:buffer";
+import { randomUUID } from "node:crypto";
 import { statSync } from "node:fs";
+import { access, appendFile, mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { basename as basename$1, dirname, extname as extname$1, isAbsolute as isAbsolute$1, join, relative as relative$1, resolve as resolve$1, sep } from "node:path";
 import lockfile from "proper-lockfile";
 import { isNodeErrorCode } from "@alint-js/utils/node";
 import { errorMessageFrom } from "@moeru/std/error";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { setImmediate } from "node:timers/promises";
 import { streamText } from "@xsai/stream-text";
 //#region src/config/config-array.ts
 const effectiveBasePathSymbol = Symbol("effectiveBasePath");
@@ -269,848 +270,480 @@ function mergeStopGateConfig(resolved, item) {
 	};
 }
 //#endregion
-//#region src/core/languages/js/index.ts
-const javascriptLanguage = {
-	extensions: [
-		".cjs",
-		".js",
-		".jsx",
-		".mjs"
-	],
-	extract: (file) => extractJsSourceTargets(withLanguage(file, "javascript")),
-	name: "javascript"
-};
+//#region package.json
+var version = "0.7.1";
 //#endregion
-//#region src/core/languages/registry.ts
-function createLanguageRegistry$1() {
+//#region src/core/cache/types.ts
+const CACHE_MAGIC = "ALINT_CACHE";
+//#endregion
+//#region src/core/cache/store.ts
+const DEFAULT_CACHE_FILE_NAME = ".alintcache";
+const LOCK_STALE_MS = 2e4;
+const LOCK_UPDATE_MS = 3e3;
+const METADATA_READ_LIMIT = 4096;
+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)
+});
+const CachedOwnerSchema = object({
+	contentHash: optional(string()),
+	kind: union([literal("file"), literal("project")]),
+	path: string(),
+	slots: array(string())
+});
+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(CachedOwnerSchema),
+	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));
+}));
+const CacheMetadataSchema = object({
+	alintVersion: string(),
+	createdAt: string(),
+	magic: literal(CACHE_MAGIC),
+	schemaVersion: literal(2),
+	type: literal("metadata")
+});
+const PutEventSchema = object({
+	at: string(),
+	entry: CacheEntrySchema,
+	owner: CachedOwnerSchema,
+	ownerKey: string(),
+	slotKey: string(),
+	type: literal("put")
+});
+const ReplaceOwnerEventSchema = object({
+	at: string(),
+	entries: array(object({
+		entry: CacheEntrySchema,
+		slotKey: string()
+	})),
+	mode: union([literal("merge"), literal("replace")]),
+	owner: CachedOwnerSchema,
+	ownerKey: string(),
+	type: literal("replace-owner")
+});
+const RemoveOwnerEventSchema = object({
+	at: string(),
+	ownerKey: string(),
+	type: literal("remove-owner")
+});
+const CacheEventSchema = union([
+	PutEventSchema,
+	ReplaceOwnerEventSchema,
+	RemoveOwnerEventSchema
+]);
+async function createCacheStore(options) {
+	const location = resolveCacheLocation(options.cwd, options.location);
+	if (!options.enabled) return createNoopCacheStore(location);
+	const alintVersion = options.alintVersion ?? version;
+	const initial = await loadCacheLog(location, alintVersion);
+	if (options.readOnly) return createReadOnlyCacheStore(location, initial.body, options.cwd);
+	const dependencies = {
+		append: options.appendFile ?? appendFile,
+		lock: options.lock ?? { acquire: lockfile.lock },
+		write: options.writeFile ?? writeFile
+	};
+	const trimmed = await trimOnce(location, alintVersion, initial, dependencies);
+	const writer = createEventWriter(location, trimmed.metadata, dependencies);
+	const fileExists = options.fileExists ?? defaultFileExists;
 	return {
-		byExtension: /* @__PURE__ */ new Map(),
-		languages: /* @__PURE__ */ new Map()
+		beginOwner: (owner, metadata) => beginOwner(trimmed.body, owner, options.cwd, writer, metadata),
+		flush: () => writer.flush(false),
+		location,
+		reconcile: async () => {
+			const removedOwners = await collectMissingFileOwners(trimmed.body, options.cwd, fileExists);
+			for (const ownerKey of removedOwners) writer.enqueue({
+				at: (/* @__PURE__ */ new Date()).toISOString(),
+				ownerKey,
+				type: "remove-owner"
+			});
+			await writer.flush(true);
+		}
 	};
 }
-function registerLanguage(registry, language) {
-	const existing = registry.languages.get(language.name);
-	if (existing && existing !== language) throw new Error(`Duplicate language "${language.name}".`);
-	for (const extension of language.extensions ?? []) {
-		const existingOwner = registry.byExtension.get(extension);
-		if (existingOwner && existingOwner !== language.name) throw new Error(`Duplicate language extension "${extension}".`);
+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);
 	}
-	registry.languages.set(language.name, language);
-	for (const extension of language.extensions ?? []) registry.byExtension.set(extension, language.name);
-}
-//#endregion
-//#region src/core/languages/text.ts
-const textLanguage = {
-	extensions: [],
-	extract: (file) => [{
-		file,
-		identity: "file",
-		kind: "file",
-		language: "plaintext",
-		origin: { physicalPath: file.path },
-		text: file.text
-	}],
-	name: "plaintext"
-};
-//#endregion
-//#region src/core/languages/ts/index.ts
-const typescriptLanguage = {
-	extensions: [
-		".cts",
-		".mts",
-		".ts",
-		".tsx"
-	],
-	extract: (file) => extractJsSourceTargets(withLanguage(file, "typescript")),
-	name: "typescript"
-};
-//#endregion
-//#region src/core/languages/resolve.ts
-function resolveLanguage(file, registry, options) {
-	return resolveLanguageForPath(file.path, registry, options);
-}
-function resolveLanguageForPath(filePath, registry, options) {
-	const languageName = options.language ?? options.processedLanguage ?? registry.byExtension.get(extname$1(filePath)) ?? "plaintext";
-	const language = registry.languages.get(languageName);
-	if (!language) {
-		const registered = [...registry.languages.keys()].sort().join(", ");
-		throw new Error(`Unknown language "${languageName}". Languages come from plugins, and these are registered: ${registered}.`);
+	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 language;
+	return (target, targetIndex) => {
+		const base = createBaseTargetIdentity(target);
+		if ((baseCounts.get(base) ?? 0) <= 1) 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}`;
+	};
 }
-//#endregion
-//#region src/core/languages/index.ts
-function createBuiltInLanguageRegistry() {
-	const registry = createLanguageRegistry$1();
-	registerLanguage(registry, textLanguage);
-	registerLanguage(registry, javascriptLanguage);
-	registerLanguage(registry, typescriptLanguage);
-	return registry;
+function normalizeCachePath(cwd, filePath) {
+	const resolvedPath = isAbsolute$1(filePath) ? resolve$1(filePath) : resolve$1(cwd, filePath);
+	return relative$1(cwd, resolvedPath).split(sep).join("/") || ".";
 }
-//#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
-		});
-	}
+function normalizeRunnerCacheConfig(cache, cwd) {
+	if (cache === false) return {
+		enabled: false,
+		location: resolveCacheLocation(cwd)
+	};
+	if (cache === true || cache === void 0) return {
+		enabled: true,
+		location: resolveCacheLocation(cwd)
+	};
 	return {
-		enabledRules,
-		rules
+		enabled: cache.enabled ?? true,
+		location: resolveCacheLocation(cwd, cache.location)
 	};
 }
-function formatRuleOptionIssues(index, issues) {
-	return issues.map((issue) => {
-		const path = getDotPath(issue);
-		return path === null ? `"${index}": ${issue.message}` : `"${index}.${path}": ${issue.message}`;
-	}).join("; ");
+function resolveCacheLocation(cwd, location) {
+	if (!location) return join(cwd, DEFAULT_CACHE_FILE_NAME);
+	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 (statSync(resolved).isDirectory()) return join(resolved, DEFAULT_CACHE_FILE_NAME);
+	} catch {}
+	return resolved;
 }
-function isRuleConfigTuple(entry) {
-	return Array.isArray(entry);
+async function appendBatch(location, payload, append) {
+	const handle = await open(location, "a+");
+	try {
+		const { size } = await handle.stat();
+		let separator = "";
+		if (size > 0) {
+			const finalByte = Buffer.alloc(1);
+			await handle.read(finalByte, 0, 1, size - 1);
+			separator = finalByte[0] === 10 ? "" : "\n";
+		}
+		await append(location, `${separator}${payload}`, "utf8");
+	} finally {
+		await handle.close();
+	}
 }
-function normalizeRuleConfigEntry(entry) {
-	if (isRuleConfigTuple(entry)) {
-		const [severity = "warn", ...options] = entry;
-		return {
-			options,
-			severity
+function applyEvent(body, event) {
+	if (event.type === "remove-owner") {
+		removeOwner(body, event.ownerKey);
+		body.updatedAt = event.at;
+		return;
+	}
+	if (event.type === "put") {
+		const current = body.owners[event.ownerKey];
+		const slots = new Set(current?.slots ?? []);
+		slots.add(event.slotKey);
+		body.entries[event.slotKey] = event.entry;
+		body.owners[event.ownerKey] = {
+			...event.owner,
+			slots: [...slots].sort()
 		};
+		body.updatedAt = event.at;
+		return;
 	}
+	const entries = event.mode === "merge" ? ownerEntries(body, body.owners[event.ownerKey]) : /* @__PURE__ */ new Map();
+	for (const item of event.entries) entries.set(item.slotKey, item.entry);
+	for (const slot of body.owners[event.ownerKey]?.slots ?? []) delete body.entries[slot];
+	for (const [slotKey, entry] of entries) body.entries[slotKey] = entry;
+	body.owners[event.ownerKey] = {
+		...event.owner,
+		slots: [...entries.keys()].sort()
+	};
+	body.updatedAt = event.at;
+}
+function beginOwner(body, owner, cwd, writer, ownerMetadata = {}) {
+	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();
+	const checkpointEntries = /* @__PURE__ */ new Map();
+	const commit = (metadata = {}) => {
+		const contentHash = metadata.contentHash ?? ownerMetadata.contentHash;
+		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;
+		const cachedOwner = {
+			contentHash,
+			kind: normalizedOwner.kind,
+			path: normalizedOwner.path,
+			slots: [...committedEntries.keys()].sort()
+		};
+		body.owners[key] = cachedOwner;
+		body.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		writer.enqueue({
+			at: body.updatedAt,
+			entries: [...committedEntries].map(([slotKey, entry]) => ({
+				entry,
+				slotKey
+			})),
+			mode: metadata.mode ?? "replace",
+			owner: cachedOwner,
+			ownerKey: key,
+			type: "replace-owner"
+		});
+		checkpointEntries.clear();
+	};
 	return {
-		options: [],
-		severity: entry ?? "warn"
+		checkpoint: async () => {
+			const cachedOwner = {
+				contentHash: ownerMetadata.contentHash,
+				kind: normalizedOwner.kind,
+				path: normalizedOwner.path,
+				slots: []
+			};
+			for (const [entryKey, cacheEntry] of checkpointEntries) {
+				const event = {
+					at: (/* @__PURE__ */ new Date()).toISOString(),
+					entry: cacheEntry,
+					owner: cachedOwner,
+					ownerKey: key,
+					slotKey: entryKey,
+					type: "put"
+				};
+				applyEvent(body, event);
+				writer.enqueue(event);
+			}
+			checkpointEntries.clear();
+			await writer.flush(false);
+		},
+		commit,
+		discard: (cacheSlot) => {
+			const entryKey = slotKey(normalizedOwner, cacheSlot, cwd);
+			nextEntries.delete(entryKey);
+			checkpointEntries.delete(entryKey);
+		},
+		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) => {
+			const entryKey = slotKey(normalizedOwner, cacheSlot, cwd);
+			nextEntries.set(entryKey, cacheEntry);
+			checkpointEntries.set(entryKey, cacheEntry);
+		}
 	};
 }
-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;
+async function collectMissingFileOwners(body, cwd, fileExists) {
+	const removed = [];
+	for (const [key, owner] of Object.entries(body.owners)) {
+		if (owner.kind !== "file" || await fileExists(resolve$1(cwd, owner.path))) continue;
+		removeOwner(body, key);
+		removed.push(key);
 	}
-	throw new TypeError(`Invalid options for rule "${id}": ${formatRuleOptionIssues(index, result.issues)}`);
+	return removed;
 }
-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]));
+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}`;
+	if (target.kind === "file") return target.filePath ? `file:${target.filePath}` : "file";
+	if (target.name) return `${target.kind}:${target.name}`;
+	if (target.range) return `${target.kind}:${target.range.start}:${target.range.end}`;
+	return target.kind;
 }
-//#endregion
-//#region src/core/languages/diagnostics.ts
-/** A rule named a language and nothing registered it. This is a builtin rule. Not a real rule. */
-const MISSING_LANGUAGE_RULE = "alint/missing-language";
-/** A linted file's extension belongs to no registered language. This is a builtin rule. Not a real rule either. */
-const UNREGISTERED_LANGUAGE_RULE = "alint/unregistered-language";
-/**
-* One diagnostic per missing language, always an error: a rule scoped to a language nothing provides
-* matches no file, so leaving it at a warning would let a run pass having silently checked nothing.
-*/
-function missingLanguageDiagnostics(missing) {
-	return [...missing.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([languageId, entry]) => {
-		const ruleIds = [...entry.ruleIds].sort();
-		const subject = ruleIds.length === 1 ? `Rule "${ruleIds[0]}" needs` : `Rules ${ruleIds.map((id) => `"${id}"`).join(", ")} need`;
-		return {
-			filePath: entry.filePath,
-			message: `${subject} the "${languageId}" language, which no plugin registered. Add a plugin that provides "${languageId}", or turn the rule off.`,
-			ruleId: MISSING_LANGUAGE_RULE,
-			severity: "error"
-		};
-	});
+function createEmptyCacheBody(createdAt = (/* @__PURE__ */ new Date()).toISOString()) {
+	return {
+		createdAt,
+		entries: {},
+		owners: {},
+		updatedAt: createdAt
+	};
 }
-/** Records one rule that named a language the config never registered, grouped by language id. */
-function recordMissingLanguage(into, languageId, ruleId, path) {
-	const existing = into.get(languageId);
-	if (existing === void 0) {
-		into.set(languageId, {
-			filePath: path,
-			ruleIds: /* @__PURE__ */ new Set([ruleId])
+function createEventWriter(location, metadata, dependencies) {
+	const backlog = [];
+	let validationError;
+	let previousWrite = Promise.resolve();
+	const persistBacklog = async () => {
+		if (validationError) throw validationError;
+		if (backlog.length === 0) return;
+		await mkdir(dirname(location), { recursive: true });
+		await withCacheLock(location, dependencies.lock, getCacheLockOptions({
+			factor: 2,
+			maxTimeout: 16e3,
+			minTimeout: 2e3,
+			retries: 4
+		}), async () => {
+			await ensureCompatibleMetadata(location, metadata, dependencies.write);
+			const batchSize = backlog.length;
+			await appendBatch(location, backlog.slice(0, batchSize).map((event) => `${JSON.stringify(event)}\n`).join(""), dependencies.append);
+			backlog.splice(0, batchSize);
 		});
-		return;
-	}
-	existing.ruleIds.add(ruleId);
-	if (path < existing.filePath) existing.filePath = path;
-}
-/**
-* Records one linted file no language claimed, grouped by extension so a missing pack is one
-* diagnostic, not one per file. `'off'` records nothing.
-*/
-function recordUnregistered(into, path, severity) {
-	if (severity === "off") return;
-	const key = extname(path) || basename(path);
-	const existing = into.get(key);
-	into.set(key, {
-		count: (existing?.count ?? 0) + 1,
-		filePath: existing !== void 0 && existing.filePath < path ? existing.filePath : path,
-		severity: existing?.severity === "error" ? "error" : severity
-	});
-}
-/** One diagnostic per extension, sorted, for the run to prepend to its results. */
-function unregisteredLanguageDiagnostics(unregistered) {
-	return [...unregistered.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([extension, entry]) => ({
-		filePath: entry.filePath,
-		message: `No language is registered for "${extension}": ${entry.count} ${entry.count === 1 ? "file was" : "files were"} handled as plain text. Register one through a plugin's "languages", or pin \`language: 'plaintext'\` to accept plain text.`,
-		ruleId: UNREGISTERED_LANGUAGE_RULE,
-		severity: entry.severity
-	}));
-}
-function unregisteredLanguageSeverity(linterOptions) {
-	const value = linterOptions.reportUnregisteredLanguages;
-	return value === "error" || value === "off" ? value : "warn";
-}
-//#endregion
-//#region src/core/languages/rule-languages.ts
-/**
-* The language a file falls back to when no registered language claims its extension. Not a real
-* language, which is why `'any'` excludes it.
-*/
-const PLAIN_TEXT = "plaintext";
-/**
-* Whether a rule reads this target.
-*
-* A rule with language off still reads file targets, because reading raw text, or asking a model about a
-* whole file, needs no language. However, it never reads the function and class targets extraction produces.
-* `'file'` is the one kind every language yields, plain text included, so it is the dividing line.
-*
-* `'any'` means any real language, so a file that fell back to plain text because nothing claimed
-* its extension is withheld: the rule asked for structure and there is none to give. The run says so
-* once per extension through `alint/unregistered-language` rather than letting each rule report an
-* empty file.
-*/
-function isTargetLanguageAccepted(languages, targetKind, targetLanguage) {
-	if (languages.kind === "off") return targetKind === "file";
-	if (languages.kind === "any") return targetLanguage !== PLAIN_TEXT;
-	return languages.ids.includes(targetLanguage);
+		validationError = void 0;
+	};
+	return {
+		enqueue: (event) => {
+			try {
+				backlog.push(parse(CacheEventSchema, event));
+			} catch (error) {
+				validationError ??= error;
+			}
+		},
+		flush: (finalAttempt) => {
+			const write = previousWrite.then(persistBacklog);
+			previousWrite = write.catch(() => {});
+			return finalAttempt ? write : write.catch(() => {});
+		}
+	};
 }
-function resolveRuleLanguages(languages) {
-	if (languages === void 0) return { kind: "off" };
-	if (languages === "any") return { kind: "any" };
-	if ("ids" in languages) return {
-		ids: languages.ids,
-		kind: "list",
-		skipMissing: languages.skipMissing ?? false
+function createNoopCacheStore(location) {
+	const transaction = {
+		checkpoint: async () => {},
+		commit: () => {},
+		discard: () => {},
+		lookup: () => void 0,
+		put: () => {}
 	};
 	return {
-		ids: languages,
-		kind: "list",
-		skipMissing: false
+		beginOwner: () => transaction,
+		flush: async () => {},
+		location,
+		reconcile: async () => {}
 	};
 }
-//#endregion
-//#region src/core/preparation.ts
-/**
-* The `ctx.src.extract` a run hands to rules, for parsing files it was never asked to lint, which
-* an index builder sweeping the workspace needs.
-*
-* It resolves each file's OWN config rather than a caller's, because the language a file resolves to
-* is a config decision and two config groups may register different plugins. It extracts on demand
-* and holds nothing: source planning releases rich extractor values after compact jobs are admitted,
-* and a run-wide parse memo here would put that retention back. A caller keeps only what it derives.
-*
-* `getSrc` defers reading the runtime because the runtime is built around this closure. It is assigned
-* before any rule runs, so by the first call it is present.
-*/
-function createSourceExtractor(cwd, config, getSrc) {
-	return async (filePath, options = {}) => {
-		const path = resolve(cwd, filePath);
-		const resolvedConfig = resolveConfigForFile(path, config, { cwd });
-		if (resolvedConfig.ignored) return [];
-		const effectiveConfig = resolvedConfig.config;
-		const language = resolveLanguageForPath(path, createLanguageRegistry(effectiveConfig), { language: options.language ?? effectiveConfig.language });
-		const src = getSrc();
-		const file = await src.readFile(path);
-		return language.extract(file, {
-			cwd,
-			languageOptions: effectiveConfig.languageOptions,
-			src
-		});
+function createReadOnlyCacheStore(location, body, cwd) {
+	return {
+		beginOwner: (owner) => ({
+			checkpoint: async () => {},
+			commit: () => {},
+			discard: () => {},
+			lookup: (slot, fingerprint) => {
+				const cached = body.entries[slotKey(owner, slot, cwd)];
+				return cached && fingerprintsEqual(cached.fingerprint, fingerprint) ? cached : void 0;
+			},
+			put: () => {}
+		}),
+		flush: async () => {},
+		location,
+		reconcile: async () => {}
 	};
 }
-function prepareRun(options = {}) {
-	const cwd$2 = options.cwd ?? cwd();
-	const config = options.config ?? [];
-	const files = [];
-	const directories = [];
-	const missingLanguages = /* @__PURE__ */ new Map();
-	const unregisteredLanguages = /* @__PURE__ */ new Map();
-	for (const filePath of options.files ?? []) {
-		const path = resolve(cwd$2, filePath);
-		const resolvedConfig = resolveConfigForFile(path, config, { cwd: cwd$2 });
-		if (resolvedConfig.ignored) continue;
-		const effectiveConfig = resolvedConfig.config;
-		const languageRegistry = createLanguageRegistry(effectiveConfig);
-		const language = resolveLanguageForPath(path, languageRegistry, { language: effectiveConfig.language });
-		const rules = prepareRules(effectiveConfig);
-		recordMissingLanguages(missingLanguages, rules, languageRegistry, path);
-		if (effectiveConfig.language === void 0 && language.name === "plaintext" && rules.some(({ enabledRule }) => !isTargetLanguageAccepted(resolveRuleLanguages(enabledRule.rule.languages), "file", "plaintext"))) recordUnregistered(unregisteredLanguages, path, unregisteredLanguageSeverity(effectiveConfig.linterOptions));
-		files.push({
-			agent: effectiveConfig.agent,
-			configHash: stableHash({
-				language: effectiveConfig.language,
-				languageOptions: effectiveConfig.languageOptions,
-				processor: effectiveConfig.processor,
-				resolvedLanguage: language.name,
-				settings: effectiveConfig.settings
-			}),
-			fileIndex: files.length,
-			language,
-			languageOptions: effectiveConfig.languageOptions,
-			path,
-			rules,
-			settings: effectiveConfig.settings
-		});
-	}
-	for (const directoryPath of options.directories ?? []) {
-		const path = resolve(cwd$2, directoryPath);
-		const resolvedConfig = resolveConfigForDirectory(path, config, { cwd: cwd$2 });
-		if (resolvedConfig.ignored) continue;
-		const effectiveConfig = resolvedConfig.config;
-		directories.push({
-			agent: effectiveConfig.agent,
-			configHash: stableHash({ settings: effectiveConfig.settings }),
-			directoryIndex: directories.length,
-			rules: prepareRules(effectiveConfig),
-			settings: effectiveConfig.settings,
-			target: {
-				kind: "directory",
-				path
-			}
-		});
+async function defaultFileExists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch (error) {
+		if (isMissingFileError(error)) return false;
+		throw error;
 	}
+}
+function emptyLoadedLog(alintVersion) {
+	const metadata = {
+		alintVersion,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		magic: CACHE_MAGIC,
+		schemaVersion: 2,
+		type: "metadata"
+	};
 	return {
-		directories,
-		files,
-		missingLanguages,
-		project: options.projectTargets === false ? void 0 : prepareProject(cwd$2, config),
-		unregisteredLanguages
+		body: createEmptyCacheBody(metadata.createdAt),
+		metadata
 	};
 }
-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;
+async function ensureCompatibleMetadata(location, metadata, write) {
+	try {
+		if (parseMetadataLine(await readMetadataLine(location), metadata.alintVersion)) return;
+	} catch (error) {
+		if (!isMissingFileError(error)) throw error;
+	}
+	await write(location, `${JSON.stringify(metadata)}\n`);
 }
-function prepareProject(root, config) {
-	const resolvedConfig = resolveConfigForProject(root, config, { cwd: root });
-	if (resolvedConfig.ignored) return void 0;
-	const effectiveConfig = resolvedConfig.config;
+function fingerprintsEqual(left, right) {
+	return left.configHash === right.configHash && left.modelHash === right.modelHash && left.ruleHash === right.ruleHash && left.targetHash === right.targetHash;
+}
+function getCacheLockOptions(retries) {
 	return {
-		agent: effectiveConfig.agent,
-		configHash: stableHash({ settings: effectiveConfig.settings }),
-		root,
-		rules: prepareRules(effectiveConfig),
-		settings: effectiveConfig.settings
+		realpath: false,
+		retries,
+		stale: LOCK_STALE_MS,
+		update: LOCK_UPDATE_MS
 	};
 }
-function prepareRules(config) {
-	return buildRuleRegistry(config).enabledRules.map((enabledRule, ruleIndex) => ({
-		enabledRule,
-		ruleIndex
-	}));
-}
-function recordMissingLanguages(into, rules, registry, path) {
-	for (const { enabledRule } of rules) {
-		const languages = resolveRuleLanguages(enabledRule.rule.languages);
-		if (languages.kind !== "list" || languages.skipMissing) continue;
-		for (const languageId of languages.ids) if (!registry.languages.has(languageId)) recordMissingLanguage(into, languageId, enabledRule.id, path);
-	}
-}
-//#endregion
-//#region package.json
-var version = "0.6.0";
-//#endregion
-//#region src/core/cache/types.ts
-const CACHE_MAGIC = "ALINT_CACHE";
-//#endregion
-//#region src/core/cache/store.ts
-const DEFAULT_CACHE_FILE_NAME = ".alintcache";
-const LOCK_STALE_MS = 2e4;
-const LOCK_UPDATE_MS = 3e3;
-const METADATA_READ_LIMIT = 4096;
-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)
-});
-const CachedOwnerSchema = object({
-	contentHash: optional(string()),
-	kind: union([literal("file"), literal("project")]),
-	path: string(),
-	slots: array(string())
-});
-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(CachedOwnerSchema),
-	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));
-}));
-const CacheMetadataSchema = object({
-	alintVersion: string(),
-	createdAt: string(),
-	magic: literal(CACHE_MAGIC),
-	schemaVersion: literal(2),
-	type: literal("metadata")
-});
-const PutEventSchema = object({
-	at: string(),
-	entry: CacheEntrySchema,
-	owner: CachedOwnerSchema,
-	ownerKey: string(),
-	slotKey: string(),
-	type: literal("put")
-});
-const ReplaceOwnerEventSchema = object({
-	at: string(),
-	entries: array(object({
-		entry: CacheEntrySchema,
-		slotKey: string()
-	})),
-	mode: union([literal("merge"), literal("replace")]),
-	owner: CachedOwnerSchema,
-	ownerKey: string(),
-	type: literal("replace-owner")
-});
-const RemoveOwnerEventSchema = object({
-	at: string(),
-	ownerKey: string(),
-	type: literal("remove-owner")
-});
-const CacheEventSchema = union([
-	PutEventSchema,
-	ReplaceOwnerEventSchema,
-	RemoveOwnerEventSchema
-]);
-async function createCacheStore(options) {
-	const location = resolveCacheLocation(options.cwd, options.location);
-	if (!options.enabled) return createNoopCacheStore(location);
-	const alintVersion = options.alintVersion ?? version;
-	const initial = await loadCacheLog(location, alintVersion);
-	if (options.readOnly) return createReadOnlyCacheStore(location, initial.body, options.cwd);
-	const dependencies = {
-		append: options.appendFile ?? appendFile,
-		lock: options.lock ?? { acquire: lockfile.lock },
-		write: options.writeFile ?? writeFile
-	};
-	const trimmed = await trimOnce(location, alintVersion, initial, dependencies);
-	const writer = createEventWriter(location, trimmed.metadata, dependencies);
-	const fileExists = options.fileExists ?? defaultFileExists;
-	return {
-		beginOwner: (owner, metadata) => beginOwner(trimmed.body, owner, options.cwd, writer, metadata),
-		flush: () => writer.flush(false),
-		location,
-		reconcile: async () => {
-			const removedOwners = await collectMissingFileOwners(trimmed.body, options.cwd, fileExists);
-			for (const ownerKey of removedOwners) writer.enqueue({
-				at: (/* @__PURE__ */ new Date()).toISOString(),
-				ownerKey,
-				type: "remove-owner"
-			});
-			await writer.flush(true);
-		}
-	};
-}
-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);
-	}
-	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;
-		const candidate = target.range ? `${base}:${target.range.start}:${target.range.end}` : base;
-		if ((duplicateCandidateCounts.get(candidate) ?? 0) <= 1) return candidate;
-		return `${candidate}:${targetIndex}`;
-	};
-}
-function normalizeCachePath(cwd, filePath) {
-	const resolvedPath = isAbsolute$1(filePath) ? resolve$1(filePath) : resolve$1(cwd, filePath);
-	return relative$1(cwd, resolvedPath).split(sep).join("/") || ".";
-}
-function normalizeRunnerCacheConfig(cache, cwd) {
-	if (cache === false) return {
-		enabled: false,
-		location: resolveCacheLocation(cwd)
-	};
-	if (cache === true || cache === void 0) return {
-		enabled: true,
-		location: resolveCacheLocation(cwd)
-	};
-	return {
-		enabled: cache.enabled ?? true,
-		location: resolveCacheLocation(cwd, cache.location)
-	};
-}
-function resolveCacheLocation(cwd, location) {
-	if (!location) return join(cwd, DEFAULT_CACHE_FILE_NAME);
-	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 (statSync(resolved).isDirectory()) return join(resolved, DEFAULT_CACHE_FILE_NAME);
-	} catch {}
-	return resolved;
-}
-async function appendBatch(location, payload, append) {
-	const handle = await open(location, "a+");
-	try {
-		const { size } = await handle.stat();
-		let separator = "";
-		if (size > 0) {
-			const finalByte = Buffer.alloc(1);
-			await handle.read(finalByte, 0, 1, size - 1);
-			separator = finalByte[0] === 10 ? "" : "\n";
-		}
-		await append(location, `${separator}${payload}`, "utf8");
-	} finally {
-		await handle.close();
-	}
-}
-function applyEvent(body, event) {
-	if (event.type === "remove-owner") {
-		removeOwner(body, event.ownerKey);
-		body.updatedAt = event.at;
-		return;
-	}
-	if (event.type === "put") {
-		const current = body.owners[event.ownerKey];
-		const slots = new Set(current?.slots ?? []);
-		slots.add(event.slotKey);
-		body.entries[event.slotKey] = event.entry;
-		body.owners[event.ownerKey] = {
-			...event.owner,
-			slots: [...slots].sort()
-		};
-		body.updatedAt = event.at;
-		return;
-	}
-	const entries = event.mode === "merge" ? ownerEntries(body, body.owners[event.ownerKey]) : /* @__PURE__ */ new Map();
-	for (const item of event.entries) entries.set(item.slotKey, item.entry);
-	for (const slot of body.owners[event.ownerKey]?.slots ?? []) delete body.entries[slot];
-	for (const [slotKey, entry] of entries) body.entries[slotKey] = entry;
-	body.owners[event.ownerKey] = {
-		...event.owner,
-		slots: [...entries.keys()].sort()
-	};
-	body.updatedAt = event.at;
-}
-function beginOwner(body, owner, cwd, writer, ownerMetadata = {}) {
-	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();
-	const checkpointEntries = /* @__PURE__ */ new Map();
-	const commit = (metadata = {}) => {
-		const contentHash = metadata.contentHash ?? ownerMetadata.contentHash;
-		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;
-		const cachedOwner = {
-			contentHash,
-			kind: normalizedOwner.kind,
-			path: normalizedOwner.path,
-			slots: [...committedEntries.keys()].sort()
-		};
-		body.owners[key] = cachedOwner;
-		body.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-		writer.enqueue({
-			at: body.updatedAt,
-			entries: [...committedEntries].map(([slotKey, entry]) => ({
-				entry,
-				slotKey
-			})),
-			mode: metadata.mode ?? "replace",
-			owner: cachedOwner,
-			ownerKey: key,
-			type: "replace-owner"
-		});
-		checkpointEntries.clear();
-	};
-	return {
-		checkpoint: async () => {
-			const cachedOwner = {
-				contentHash: ownerMetadata.contentHash,
-				kind: normalizedOwner.kind,
-				path: normalizedOwner.path,
-				slots: []
-			};
-			for (const [entryKey, cacheEntry] of checkpointEntries) {
-				const event = {
-					at: (/* @__PURE__ */ new Date()).toISOString(),
-					entry: cacheEntry,
-					owner: cachedOwner,
-					ownerKey: key,
-					slotKey: entryKey,
-					type: "put"
-				};
-				applyEvent(body, event);
-				writer.enqueue(event);
-			}
-			checkpointEntries.clear();
-			await writer.flush(false);
-		},
-		commit,
-		discard: (cacheSlot) => {
-			const entryKey = slotKey(normalizedOwner, cacheSlot, cwd);
-			nextEntries.delete(entryKey);
-			checkpointEntries.delete(entryKey);
-		},
-		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) => {
-			const entryKey = slotKey(normalizedOwner, cacheSlot, cwd);
-			nextEntries.set(entryKey, cacheEntry);
-			checkpointEntries.set(entryKey, cacheEntry);
-		}
-	};
-}
-async function collectMissingFileOwners(body, cwd, fileExists) {
-	const removed = [];
-	for (const [key, owner] of Object.entries(body.owners)) {
-		if (owner.kind !== "file" || await fileExists(resolve$1(cwd, owner.path))) continue;
-		removeOwner(body, key);
-		removed.push(key);
-	}
-	return removed;
-}
-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}`;
-	if (target.kind === "file") return target.filePath ? `file:${target.filePath}` : "file";
-	if (target.name) return `${target.kind}:${target.name}`;
-	if (target.range) return `${target.kind}:${target.range.start}:${target.range.end}`;
-	return target.kind;
-}
-function createEmptyCacheBody(createdAt = (/* @__PURE__ */ new Date()).toISOString()) {
-	return {
-		createdAt,
-		entries: {},
-		owners: {},
-		updatedAt: createdAt
-	};
-}
-function createEventWriter(location, metadata, dependencies) {
-	const backlog = [];
-	let validationError;
-	let previousWrite = Promise.resolve();
-	const persistBacklog = async () => {
-		if (validationError) throw validationError;
-		if (backlog.length === 0) return;
-		await mkdir(dirname(location), { recursive: true });
-		await withCacheLock(location, dependencies.lock, getCacheLockOptions({
-			factor: 2,
-			maxTimeout: 16e3,
-			minTimeout: 2e3,
-			retries: 4
-		}), async () => {
-			await ensureCompatibleMetadata(location, metadata, dependencies.write);
-			const batchSize = backlog.length;
-			await appendBatch(location, backlog.slice(0, batchSize).map((event) => `${JSON.stringify(event)}\n`).join(""), dependencies.append);
-			backlog.splice(0, batchSize);
-		});
-		validationError = void 0;
-	};
-	return {
-		enqueue: (event) => {
-			try {
-				backlog.push(parse(CacheEventSchema, event));
-			} catch (error) {
-				validationError ??= error;
-			}
-		},
-		flush: (finalAttempt) => {
-			const write = previousWrite.then(persistBacklog);
-			previousWrite = write.catch(() => {});
-			return finalAttempt ? write : write.catch(() => {});
-		}
-	};
-}
-function createNoopCacheStore(location) {
-	const transaction = {
-		checkpoint: async () => {},
-		commit: () => {},
-		discard: () => {},
-		lookup: () => void 0,
-		put: () => {}
-	};
-	return {
-		beginOwner: () => transaction,
-		flush: async () => {},
-		location,
-		reconcile: async () => {}
-	};
-}
-function createReadOnlyCacheStore(location, body, cwd) {
-	return {
-		beginOwner: (owner) => ({
-			checkpoint: async () => {},
-			commit: () => {},
-			discard: () => {},
-			lookup: (slot, fingerprint) => {
-				const cached = body.entries[slotKey(owner, slot, cwd)];
-				return cached && fingerprintsEqual(cached.fingerprint, fingerprint) ? cached : void 0;
-			},
-			put: () => {}
-		}),
-		flush: async () => {},
-		location,
-		reconcile: async () => {}
-	};
-}
-async function defaultFileExists(path) {
-	try {
-		await access(path);
-		return true;
-	} catch (error) {
-		if (isMissingFileError(error)) return false;
-		throw error;
-	}
-}
-function emptyLoadedLog(alintVersion) {
-	const metadata = {
-		alintVersion,
-		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-		magic: CACHE_MAGIC,
-		schemaVersion: 2,
-		type: "metadata"
-	};
-	return {
-		body: createEmptyCacheBody(metadata.createdAt),
-		metadata
-	};
-}
-async function ensureCompatibleMetadata(location, metadata, write) {
-	try {
-		if (parseMetadataLine(await readMetadataLine(location), metadata.alintVersion)) return;
-	} catch (error) {
-		if (!isMissingFileError(error)) throw error;
-	}
-	await write(location, `${JSON.stringify(metadata)}\n`);
-}
-function fingerprintsEqual(left, right) {
-	return left.configHash === right.configHash && left.modelHash === right.modelHash && left.ruleHash === right.ruleHash && left.targetHash === right.targetHash;
-}
-function getCacheLockOptions(retries) {
-	return {
-		realpath: false,
-		retries,
-		stale: LOCK_STALE_MS,
-		update: LOCK_UPDATE_MS
-	};
-}
-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;
-		}
-		const index = typeof key === "string" ? Number(key) : NaN;
-		if (typeof key !== "string" || !Number.isInteger(index) || index < 0 || index >= 2 ** 32 - 1 || String(index) !== key || !descriptor.enumerable) return false;
-		if (!isJsonValueAt(descriptor.value, ancestors)) return false;
-		indexCount += 1;
+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;
+		}
+		const index = typeof key === "string" ? Number(key) : NaN;
+		if (typeof key !== "string" || !Number.isInteger(index) || index < 0 || index >= 2 ** 32 - 1 || String(index) !== key || !descriptor.enumerable) return false;
+		if (!isJsonValueAt(descriptor.value, ancestors)) return false;
+		indexCount += 1;
 	}
 	return arrayLength !== void 0 && indexCount === arrayLength;
 }
@@ -1145,141 +778,509 @@ function isJsonValueAt(input, ancestors) {
 		ancestors.delete(input);
 	}
 }
-function isMissingFileError(error) {
-	return isNodeErrorCode(error, "ENOENT") || isNodeErrorCode(error, "ENOTDIR");
+function isMissingFileError(error) {
+	return isNodeErrorCode(error, "ENOENT") || isNodeErrorCode(error, "ENOTDIR");
+}
+async function loadCacheLog(location, alintVersion) {
+	try {
+		const metadata = parseMetadataLine(await readMetadataLine(location), alintVersion);
+		if (!metadata) return emptyLoadedLog(alintVersion);
+		return replayLog(await readFile(location, "utf8"), metadata);
+	} catch (error) {
+		if (isMissingFileError(error)) return emptyLoadedLog(alintVersion);
+		throw error;
+	}
+}
+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 parseMetadataLine(line, expectedAlintVersion) {
+	if (!line) return void 0;
+	try {
+		const value = JSON.parse(line);
+		const metadata = parse(CacheMetadataSchema, value);
+		if (expectedAlintVersion !== void 0 && metadata.alintVersion !== expectedAlintVersion) return void 0;
+		return metadata;
+	} catch {
+		return;
+	}
+}
+async function persistCompactedLog(location, loaded, write) {
+	const metadata = parse(CacheMetadataSchema, loaded.metadata);
+	const events = Object.entries(loaded.body.owners).map(([ownerKey, owner]) => ({
+		at: loaded.body.updatedAt,
+		entries: [...ownerEntries(loaded.body, owner)].map(([slotKey, entry]) => ({
+			entry,
+			slotKey
+		})),
+		mode: "replace",
+		owner,
+		ownerKey,
+		type: "replace-owner"
+	})).map((event) => parse(CacheEventSchema, event));
+	const contents = [`${JSON.stringify(metadata)}\n`, ...events.map((event) => `${JSON.stringify(event)}\n`)].join("");
+	const tempPath = join(dirname(location), `.${basename$1(location)}.${process.pid}.${randomUUID()}.tmp`);
+	try {
+		await write(tempPath, contents);
+		await rename(tempPath, location);
+	} catch (error) {
+		await rm(tempPath, { force: true }).catch(() => {});
+		throw error;
+	}
+}
+async function readMetadataLine(location) {
+	const handle = await open(location, "r");
+	try {
+		const buffer = Buffer.alloc(METADATA_READ_LIMIT);
+		const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+		const newlineIndex = buffer.subarray(0, bytesRead).indexOf(10);
+		if (newlineIndex < 0) return void 0;
+		const lineEnd = newlineIndex > 0 && buffer[newlineIndex - 1] === 13 ? newlineIndex - 1 : newlineIndex;
+		return buffer.toString("utf8", 0, lineEnd);
+	} finally {
+		await handle.close();
+	}
+}
+function removeOwner(body, key) {
+	for (const slot of body.owners[key]?.slots ?? []) delete body.entries[slot];
+	delete body.owners[key];
+}
+function replayLog(text, metadata) {
+	const body = createEmptyCacheBody(metadata.createdAt);
+	const lines = text.split(/\r?\n/);
+	for (let index = 1; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (!line) continue;
+		try {
+			const value = JSON.parse(line);
+			applyEvent(body, parse(CacheEventSchema, value));
+		} catch {}
+	}
+	return {
+		body: parse(CacheFileBodySchema, body),
+		metadata
+	};
+}
+function slotKey(owner, slot, cwd) {
+	return stableHash({
+		owner: ownerKey(owner, cwd),
+		...slot
+	});
+}
+async function trimOnce(location, alintVersion, fallback, dependencies) {
+	await mkdir(dirname(location), { recursive: true });
+	try {
+		return await withCacheLock(location, dependencies.lock, getCacheLockOptions(0), async () => {
+			const latest = await loadCacheLog(location, alintVersion);
+			await persistCompactedLog(location, latest, dependencies.write);
+			return latest;
+		});
+	} catch (error) {
+		if (isNodeErrorCode(error, "ELOCKED")) return fallback;
+		throw error;
+	}
+}
+async function withCacheLock(location, lock, options, operation) {
+	let compromised;
+	const release = await lock.acquire(location, {
+		...options,
+		onCompromised: (error) => {
+			compromised = error;
+		}
+	});
+	let operationError;
+	try {
+		const result = await operation();
+		if (compromised) throw compromised;
+		return result;
+	} catch (error) {
+		operationError = error;
+		throw error;
+	} finally {
+		try {
+			await release();
+		} catch (error) {
+			if (operationError === void 0) throw error;
+		}
+	}
+}
+//#endregion
+//#region src/core/languages/js/index.ts
+const javascriptLanguage = {
+	extensions: [
+		".cjs",
+		".js",
+		".jsx",
+		".mjs"
+	],
+	extract: (file) => extractJsSourceTargets(withLanguage(file, "javascript")),
+	name: "javascript"
+};
+//#endregion
+//#region src/core/languages/registry.ts
+function createLanguageRegistry$1() {
+	return {
+		byExtension: /* @__PURE__ */ new Map(),
+		languages: /* @__PURE__ */ new Map()
+	};
+}
+function registerLanguage(registry, language) {
+	const existing = registry.languages.get(language.name);
+	if (existing && existing !== language) throw new Error(`Duplicate language "${language.name}".`);
+	for (const extension of language.extensions ?? []) {
+		const existingOwner = registry.byExtension.get(extension);
+		if (existingOwner && existingOwner !== language.name) throw new Error(`Duplicate language extension "${extension}".`);
+	}
+	registry.languages.set(language.name, language);
+	for (const extension of language.extensions ?? []) registry.byExtension.set(extension, language.name);
+}
+//#endregion
+//#region src/core/languages/text.ts
+const textLanguage = {
+	extensions: [],
+	extract: (file) => [{
+		file,
+		identity: "file",
+		kind: "file",
+		language: "plaintext",
+		origin: { physicalPath: file.path },
+		text: file.text
+	}],
+	name: "plaintext"
+};
+//#endregion
+//#region src/core/languages/ts/index.ts
+const typescriptLanguage = {
+	extensions: [
+		".cts",
+		".mts",
+		".ts",
+		".tsx"
+	],
+	extract: (file) => extractJsSourceTargets(withLanguage(file, "typescript")),
+	name: "typescript"
+};
+//#endregion
+//#region src/core/languages/resolve.ts
+function resolveLanguage(file, registry, options) {
+	return resolveLanguageForPath(file.path, registry, options);
+}
+function resolveLanguageForPath(filePath, registry, options) {
+	const languageName = options.language ?? options.processedLanguage ?? registry.byExtension.get(extname$1(filePath)) ?? "plaintext";
+	const language = registry.languages.get(languageName);
+	if (!language) {
+		const registered = [...registry.languages.keys()].sort().join(", ");
+		throw new Error(`Unknown language "${languageName}". Languages come from plugins, and these are registered: ${registered}.`);
+	}
+	return language;
+}
+//#endregion
+//#region src/core/languages/index.ts
+function createBuiltInLanguageRegistry() {
+	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
+	};
+}
+function formatRuleOptionIssues(index, issues) {
+	return issues.map((issue) => {
+		const path = getDotPath(issue);
+		return path === null ? `"${index}": ${issue.message}` : `"${index}.${path}": ${issue.message}`;
+	}).join("; ");
 }
-async function loadCacheLog(location, alintVersion) {
-	try {
-		const metadata = parseMetadataLine(await readMetadataLine(location), alintVersion);
-		if (!metadata) return emptyLoadedLog(alintVersion);
-		return replayLog(await readFile(location, "utf8"), metadata);
-	} catch (error) {
-		if (isMissingFileError(error)) return emptyLoadedLog(alintVersion);
-		throw error;
+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 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);
+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;
 	}
-	return entries;
+	throw new TypeError(`Invalid options for rule "${id}": ${formatRuleOptionIssues(index, result.issues)}`);
 }
-function ownerKey(owner, cwd) {
-	return stableHash({
-		kind: owner.kind,
-		path: normalizeCachePath(cwd, owner.path)
+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/languages/diagnostics.ts
+/** A rule named a language and nothing registered it. This is a builtin rule. Not a real rule. */
+const MISSING_LANGUAGE_RULE = "alint/missing-language";
+/** A linted file's extension belongs to no registered language. This is a builtin rule. Not a real rule either. */
+const UNREGISTERED_LANGUAGE_RULE = "alint/unregistered-language";
+/**
+* One diagnostic per missing language, always an error: a rule scoped to a language nothing provides
+* matches no file, so leaving it at a warning would let a run pass having silently checked nothing.
+*/
+function missingLanguageDiagnostics(missing) {
+	return [...missing.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([languageId, entry]) => {
+		const ruleIds = [...entry.ruleIds].sort();
+		const subject = ruleIds.length === 1 ? `Rule "${ruleIds[0]}" needs` : `Rules ${ruleIds.map((id) => `"${id}"`).join(", ")} need`;
+		return {
+			filePath: entry.filePath,
+			message: `${subject} the "${languageId}" language, which no plugin registered. Add a plugin that provides "${languageId}", or turn the rule off.`,
+			ruleId: MISSING_LANGUAGE_RULE,
+			severity: "error"
+		};
 	});
 }
-function parseMetadataLine(line, expectedAlintVersion) {
-	if (!line) return void 0;
-	try {
-		const value = JSON.parse(line);
-		const metadata = parse(CacheMetadataSchema, value);
-		if (expectedAlintVersion !== void 0 && metadata.alintVersion !== expectedAlintVersion) return void 0;
-		return metadata;
-	} catch {
+/** Records one rule that named a language the config never registered, grouped by language id. */
+function recordMissingLanguage(into, languageId, ruleId, path) {
+	const existing = into.get(languageId);
+	if (existing === void 0) {
+		into.set(languageId, {
+			filePath: path,
+			ruleIds: /* @__PURE__ */ new Set([ruleId])
+		});
 		return;
 	}
+	existing.ruleIds.add(ruleId);
+	if (path < existing.filePath) existing.filePath = path;
 }
-async function persistCompactedLog(location, loaded, write) {
-	const metadata = parse(CacheMetadataSchema, loaded.metadata);
-	const events = Object.entries(loaded.body.owners).map(([ownerKey, owner]) => ({
-		at: loaded.body.updatedAt,
-		entries: [...ownerEntries(loaded.body, owner)].map(([slotKey, entry]) => ({
-			entry,
-			slotKey
-		})),
-		mode: "replace",
-		owner,
-		ownerKey,
-		type: "replace-owner"
-	})).map((event) => parse(CacheEventSchema, event));
-	const contents = [`${JSON.stringify(metadata)}\n`, ...events.map((event) => `${JSON.stringify(event)}\n`)].join("");
-	const tempPath = join(dirname(location), `.${basename$1(location)}.${process.pid}.${randomUUID()}.tmp`);
-	try {
-		await write(tempPath, contents);
-		await rename(tempPath, location);
-	} catch (error) {
-		await rm(tempPath, { force: true }).catch(() => {});
-		throw error;
-	}
+/**
+* Records one linted file no language claimed, grouped by extension so a missing pack is one
+* diagnostic, not one per file. `'off'` records nothing.
+*/
+function recordUnregistered(into, path, severity) {
+	if (severity === "off") return;
+	const key = extname(path) || basename(path);
+	const existing = into.get(key);
+	into.set(key, {
+		count: (existing?.count ?? 0) + 1,
+		filePath: existing !== void 0 && existing.filePath < path ? existing.filePath : path,
+		severity: existing?.severity === "error" ? "error" : severity
+	});
 }
-async function readMetadataLine(location) {
-	const handle = await open(location, "r");
-	try {
-		const buffer = Buffer.alloc(METADATA_READ_LIMIT);
-		const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-		const newlineIndex = buffer.subarray(0, bytesRead).indexOf(10);
-		if (newlineIndex < 0) return void 0;
-		const lineEnd = newlineIndex > 0 && buffer[newlineIndex - 1] === 13 ? newlineIndex - 1 : newlineIndex;
-		return buffer.toString("utf8", 0, lineEnd);
-	} finally {
-		await handle.close();
+/** One diagnostic per extension, sorted, for the run to prepend to its results. */
+function unregisteredLanguageDiagnostics(unregistered) {
+	return [...unregistered.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([extension, entry]) => ({
+		filePath: entry.filePath,
+		message: `No language is registered for "${extension}": ${entry.count} ${entry.count === 1 ? "file was" : "files were"} handled as plain text. Register one through a plugin's "languages", or pin \`language: 'plaintext'\` to accept plain text.`,
+		ruleId: UNREGISTERED_LANGUAGE_RULE,
+		severity: entry.severity
+	}));
+}
+function unregisteredLanguageSeverity(linterOptions) {
+	const value = linterOptions.reportUnregisteredLanguages;
+	return value === "error" || value === "off" ? value : "warn";
+}
+//#endregion
+//#region src/core/languages/rule-languages.ts
+/**
+* The language a file falls back to when no registered language claims its extension. Not a real
+* language, which is why `'any'` excludes it.
+*/
+const PLAIN_TEXT = "plaintext";
+/**
+* Whether a rule reads this target.
+*
+* A rule with language off still reads file targets, because reading raw text, or asking a model about a
+* whole file, needs no language. However, it never reads the function and class targets extraction produces.
+* `'file'` is the one kind every language yields, plain text included, so it is the dividing line.
+*
+* `'any'` means any real language, so a file that fell back to plain text because nothing claimed
+* its extension is withheld: the rule asked for structure and there is none to give. The run says so
+* once per extension through `alint/unregistered-language` rather than letting each rule report an
+* empty file.
+*/
+function isTargetLanguageAccepted(languages, targetKind, targetLanguage) {
+	if (languages.kind === "off") return targetKind === "file";
+	if (languages.kind === "any") return targetLanguage !== PLAIN_TEXT;
+	return languages.ids.includes(targetLanguage);
+}
+function resolveRuleLanguages(languages) {
+	if (languages === void 0) return { kind: "off" };
+	if (languages === "any") return { kind: "any" };
+	if ("ids" in languages) return {
+		ids: languages.ids,
+		kind: "list",
+		skipMissing: languages.skipMissing ?? false
+	};
+	return {
+		ids: languages,
+		kind: "list",
+		skipMissing: false
+	};
+}
+//#endregion
+//#region src/core/preparation.ts
+/**
+* The `ctx.src.extract` a run hands to rules, for parsing files it was never asked to lint, which
+* an index builder sweeping the workspace needs.
+*
+* It resolves each file's OWN config rather than a caller's, because the language a file resolves to
+* is a config decision and two config groups may register different plugins. It extracts on demand
+* and holds nothing: source planning releases rich extractor values after compact jobs are admitted,
+* and a run-wide parse memo here would put that retention back. A caller keeps only what it derives.
+*
+* `getSrc` defers reading the runtime because the runtime is built around this closure. It is assigned
+* before any rule runs, so by the first call it is present.
+*/
+function createSourceExtractor(cwd, config, getSrc) {
+	return async (filePath, options = {}) => {
+		const path = resolve(cwd, filePath);
+		const resolvedConfig = resolveConfigForFile(path, config, { cwd });
+		if (resolvedConfig.ignored) return [];
+		const effectiveConfig = resolvedConfig.config;
+		const language = resolveLanguageForPath(path, createLanguageRegistry(effectiveConfig), { language: options.language ?? effectiveConfig.language });
+		const src = getSrc();
+		const file = await src.readFile(path);
+		return language.extract(file, {
+			cwd,
+			languageOptions: effectiveConfig.languageOptions,
+			src
+		});
+	};
+}
+function prepareRun(options = {}) {
+	const cwd$2 = options.cwd ?? cwd();
+	const config = options.config ?? [];
+	const files = [];
+	const directories = [];
+	const missingLanguages = /* @__PURE__ */ new Map();
+	const unregisteredLanguages = /* @__PURE__ */ new Map();
+	for (const filePath of options.files ?? []) {
+		const path = resolve(cwd$2, filePath);
+		const resolvedConfig = resolveConfigForFile(path, config, { cwd: cwd$2 });
+		if (resolvedConfig.ignored) continue;
+		const effectiveConfig = resolvedConfig.config;
+		const languageRegistry = createLanguageRegistry(effectiveConfig);
+		const language = resolveLanguageForPath(path, languageRegistry, { language: effectiveConfig.language });
+		const rules = prepareRules(effectiveConfig);
+		recordMissingLanguages(missingLanguages, rules, languageRegistry, path);
+		if (effectiveConfig.language === void 0 && language.name === "plaintext" && rules.some(({ enabledRule }) => !isTargetLanguageAccepted(resolveRuleLanguages(enabledRule.rule.languages), "file", "plaintext"))) recordUnregistered(unregisteredLanguages, path, unregisteredLanguageSeverity(effectiveConfig.linterOptions));
+		files.push({
+			agent: effectiveConfig.agent,
+			configHash: stableHash({
+				language: effectiveConfig.language,
+				languageOptions: effectiveConfig.languageOptions,
+				processor: effectiveConfig.processor,
+				resolvedLanguage: language.name,
+				settings: effectiveConfig.settings
+			}),
+			fileIndex: files.length,
+			language,
+			languageOptions: effectiveConfig.languageOptions,
+			path,
+			rules,
+			settings: effectiveConfig.settings
+		});
 	}
-}
-function removeOwner(body, key) {
-	for (const slot of body.owners[key]?.slots ?? []) delete body.entries[slot];
-	delete body.owners[key];
-}
-function replayLog(text, metadata) {
-	const body = createEmptyCacheBody(metadata.createdAt);
-	const lines = text.split(/\r?\n/);
-	for (let index = 1; index < lines.length; index += 1) {
-		const line = lines[index];
-		if (!line) continue;
-		try {
-			const value = JSON.parse(line);
-			applyEvent(body, parse(CacheEventSchema, value));
-		} catch {}
+	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 {
-		body: parse(CacheFileBodySchema, body),
-		metadata
+		directories,
+		files,
+		missingLanguages,
+		project: options.projectTargets === false ? void 0 : prepareProject(cwd$2, config),
+		unregisteredLanguages
 	};
 }
-function slotKey(owner, slot, cwd) {
-	return stableHash({
-		owner: ownerKey(owner, cwd),
-		...slot
-	});
+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;
 }
-async function trimOnce(location, alintVersion, fallback, dependencies) {
-	await mkdir(dirname(location), { recursive: true });
-	try {
-		return await withCacheLock(location, dependencies.lock, getCacheLockOptions(0), async () => {
-			const latest = await loadCacheLog(location, alintVersion);
-			await persistCompactedLog(location, latest, dependencies.write);
-			return latest;
-		});
-	} catch (error) {
-		if (isNodeErrorCode(error, "ELOCKED")) return fallback;
-		throw error;
-	}
+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
+	};
 }
-async function withCacheLock(location, lock, options, operation) {
-	let compromised;
-	const release = await lock.acquire(location, {
-		...options,
-		onCompromised: (error) => {
-			compromised = error;
-		}
-	});
-	let operationError;
-	try {
-		const result = await operation();
-		if (compromised) throw compromised;
-		return result;
-	} catch (error) {
-		operationError = error;
-		throw error;
-	} finally {
-		try {
-			await release();
-		} catch (error) {
-			if (operationError === void 0) throw error;
-		}
+function prepareRules(config) {
+	return buildRuleRegistry(config).enabledRules.map((enabledRule, ruleIndex) => ({
+		enabledRule,
+		ruleIndex
+	}));
+}
+function recordMissingLanguages(into, rules, registry, path) {
+	for (const { enabledRule } of rules) {
+		const languages = resolveRuleLanguages(enabledRule.rule.languages);
+		if (languages.kind !== "list" || languages.skipMissing) continue;
+		for (const languageId of languages.ids) if (!registry.languages.has(languageId)) recordMissingLanguage(into, languageId, enabledRule.id, path);
 	}
 }
 //#endregion
@@ -2363,88 +2364,14 @@ function projectExecution(runtime) {
 //#endregion
 //#region src/core/source/planner.ts
 /**
-* Converts one rich extractor result into detached descriptors and admits its compact jobs.
-*
-* The returned outcome promise captures only cache ownership and hashes. This function does not
-* await rule execution, so its `SourceFile`, parser output, and rich targets become unreachable
-* when planning returns.
-*/
-async function planSource(input, options) {
-	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
-	let file;
-	try {
-		file = await options.src.readFile(input.path);
-	} catch (error) {
-		reportFilePlanningComplete(input, 0, options);
-		return {
-			failure: fileFailure(input, "read", failureMessage(error, "Failed to read source file.")),
-			outcomes: Promise.resolve([])
-		};
-	}
-	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
-	let targets;
-	try {
-		targets = await input.language.extract(file, {
-			cwd: options.cwd,
-			languageOptions: input.languageOptions,
-			src: options.src
-		});
-	} catch (error) {
-		reportFilePlanningComplete(input, 0, options);
-		return {
-			failure: fileFailure(input, "extract", failureMessage(error, "Failed to extract source targets.")),
-			outcomes: Promise.resolve([])
-		};
-	}
-	const { contentHash } = file;
-	let cacheOwner;
-	let jobs;
-	let project;
-	try {
-		project = options.projectSnapshots === false ? void 0 : createProjectSnapshot(input, file.language, file.path, contentHash, targets);
-		cacheOwner = options.cacheStore.beginOwner({
-			kind: "file",
-			path: file.path
-		}, { contentHash });
-		const baseFile = {
-			contentHash,
-			language: file.language,
-			path: file.path
-		};
-		jobs = createSourceJobs(input, createExecutionTargets(input, targets, baseFile, options.ruleRuntimes, options.cwd, cacheOwner));
-	} catch (error) {
-		reportFilePlanningComplete(input, 0, options);
-		return {
-			failure: fileFailure(input, "extract", failureMessage(error, "Failed to plan source targets.")),
-			outcomes: Promise.resolve([])
-		};
-	}
-	if (options.signal?.aborted) {
-		cacheOwner.commit({ mode: "merge" });
-		return {
-			outcomes: Promise.resolve([]),
-			project
-		};
-	}
-	const batch = options.scheduler.schedule(jobs);
-	reportFilePlanningComplete(input, batch.jobsAdded, options);
-	return {
-		outcomes: batch.outcomes.then(async (settled) => {
-			cacheOwner.commit(options.signal?.aborted ? { mode: "merge" } : void 0);
-			await options.cacheStore.flush();
-			return settled;
-		}),
-		project
-	};
-}
-/**
-* Starts every input plan independently and preserves input-ordered results.
+* Starts every input read independently, then batches CPU-heavy extraction and job admission.
 */
 async function planSources(inputs, options) {
-	return Promise.all(inputs.map((input) => planSource(input, {
+	const waitForPlanning = createPlanningAdmission();
+	return Promise.all(inputs.map((input) => planSourceWithAdmission(input, {
 		...options,
 		ruleRuntimes: options.createRuleRuntimes(input)
-	})));
+	}, waitForPlanning)));
 }
 function createExecutionTargets(input, targets, file, runtimes, cwd, cacheOwner) {
 	const resolveIdentity = createTargetIdentityResolver(targets.map((target) => ({
@@ -2499,6 +2426,28 @@ function createExecutionTargets(input, targets, file, runtimes, cwd, cacheOwner)
 		};
 	});
 }
+function createPlanningAdmission() {
+	const batchSize = 32;
+	let admitted = 0;
+	let pendingYield;
+	return async () => {
+		let currentPendingYield = pendingYield;
+		while (currentPendingYield) {
+			await currentPendingYield;
+			currentPendingYield = pendingYield;
+		}
+		admitted += 1;
+		if (admitted < batchSize) return;
+		admitted = 0;
+		const currentYield = setImmediate();
+		pendingYield = currentYield;
+		try {
+			await currentYield;
+		} finally {
+			if (pendingYield === currentYield) pendingYield = void 0;
+		}
+	};
+}
 function createProjectSnapshot(input, language, path, contentHash, targets) {
 	return {
 		configHash: input.configHash,
@@ -2570,6 +2519,76 @@ function fileFailure(input, kind, message) {
 		message
 	};
 }
+async function planSourceWithAdmission(input, options, waitForPlanning) {
+	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
+	let file;
+	try {
+		file = await options.src.readFile(input.path);
+	} catch (error) {
+		reportFilePlanningComplete(input, 0, options);
+		return {
+			failure: fileFailure(input, "read", failureMessage(error, "Failed to read source file.")),
+			outcomes: Promise.resolve([])
+		};
+	}
+	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
+	await waitForPlanning?.();
+	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
+	let targets;
+	try {
+		targets = await input.language.extract(file, {
+			cwd: options.cwd,
+			languageOptions: input.languageOptions,
+			src: options.src
+		});
+	} catch (error) {
+		reportFilePlanningComplete(input, 0, options);
+		return {
+			failure: fileFailure(input, "extract", failureMessage(error, "Failed to extract source targets.")),
+			outcomes: Promise.resolve([])
+		};
+	}
+	const { contentHash } = file;
+	let cacheOwner;
+	let jobs;
+	let project;
+	try {
+		project = options.projectSnapshots === false ? void 0 : createProjectSnapshot(input, file.language, file.path, contentHash, targets);
+		cacheOwner = options.cacheStore.beginOwner({
+			kind: "file",
+			path: file.path
+		}, { contentHash });
+		const baseFile = {
+			contentHash,
+			language: file.language,
+			path: file.path
+		};
+		jobs = createSourceJobs(input, createExecutionTargets(input, targets, baseFile, options.ruleRuntimes, options.cwd, cacheOwner));
+	} catch (error) {
+		reportFilePlanningComplete(input, 0, options);
+		return {
+			failure: fileFailure(input, "extract", failureMessage(error, "Failed to plan source targets.")),
+			outcomes: Promise.resolve([])
+		};
+	}
+	if (options.signal?.aborted) {
+		cacheOwner.commit({ mode: "merge" });
+		return {
+			outcomes: Promise.resolve([]),
+			project
+		};
+	}
+	const batch = options.scheduler.schedule(jobs);
+	reportFilePlanningComplete(input, batch.jobsAdded, options);
+	return {
+		outcomes: batch.outcomes.then(async (settled) => {
+			cacheOwner.commit(options.signal?.aborted ? { mode: "merge" } : void 0);
+			await options.cacheStore.flush();
+			return settled;
+		}),
+		project
+	};
+}
 function reportFilePlanningComplete(input, jobsAdded, options) {
 	try {
 		const progress = options.scheduler.completeFilePlanning();
@@ -3120,6 +3139,7 @@ async function measureModel({ model, prompt, signal }) {
 	}];
 	const startedAt = performance.now();
 	let firstOutputAt;
+	let outputDeltaCount = 0;
 	const result = streamText({
 		...model.params,
 		abortSignal: signal,
@@ -3139,7 +3159,10 @@ async function measureModel({ model, prompt, signal }) {
 	]);
 	let settled;
 	try {
-		for await (const event of result.eventStream) if (firstOutputAt === void 0 && (event.type === "reasoning.delta" || event.type === "text.delta")) firstOutputAt = performance.now();
+		for await (const event of result.eventStream) if ((event.type === "reasoning.delta" || event.type === "text.delta") && event.delta.length > 0) {
+			outputDeltaCount += 1;
+			firstOutputAt ??= performance.now();
+		}
 	} finally {
 		settled = await completion;
 	}
@@ -3148,7 +3171,7 @@ async function measureModel({ model, prompt, signal }) {
 	if (usageResult.status === "rejected") throw usageResult.reason;
 	return {
 		durationMs: endedAt - startedAt,
-		firstOutputMs: firstOutputAt === void 0 ? void 0 : firstOutputAt - startedAt,
+		firstOutputMs: firstOutputAt === void 0 || outputDeltaCount < 2 ? void 0 : firstOutputAt - startedAt,
 		outputTokens: usageResult.value?.outputTokens
 	};
 }
@@ -3245,4 +3268,4 @@ function sampleCorpus(seed) {
 	].map((section) => `--- corpus section ${section} ---\n${rotated}`).join("\n\n");
 }
 //#endregion
-export { AlintAbortError, AlintCachePersistenceError, AlintRunCancelledError, AlintRunError, benchmarkModels, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceExtractor, createSourceFile, createSourceRuntime, defaultStopGateConfig, defineConfig, definePlugin, defineRule, hasDiscoveryFilePatterns, matchesDiscoveryFile, maximumStopGateTimeoutMs, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, resolveStopGateConfig, runAlint, sliceLines, sliceRange, stableHash, targetIdentity, withLanguage, withStableIdentities };
+export { AlintAbortError, AlintCachePersistenceError, AlintRunCancelledError, AlintRunError, benchmarkModels, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceExtractor, createSourceFile, createSourceRuntime, defaultStopGateConfig, defineConfig, definePlugin, defineRule, hasDiscoveryFilePatterns, matchesDiscoveryFile, maximumStopGateTimeoutMs, normalizeConfig, normalizeRunnerCacheConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, resolveStopGateConfig, runAlint, sliceLines, sliceRange, stableHash, targetIdentity, withLanguage, withStableIdentities };