@alint-js/core 0.5.0 → 0.7.0

package/dist/index.mjs

@@ -1,15 +1,17 @@
 import { o as withAgentRetry, t as combineAbortSignals } from "./agent-B6GG68NX.mjs";
 import { n as definePlugin, r as defineRule, t as defineConfig } from "./define-Da342Fcx.mjs";
-import { a as createSourceFile, c as sliceRange, d as stableHash, i as SourceChangedError, l as withLanguage, n as targetIdentity, o as createSourceRuntime, r as withStableIdentities, s as sliceLines, t as extractJsSourceTargets, u as createStableHasher } from "./extract-CLXRRiJW.mjs";
+import { a as createSourceFile, c as sliceRange, d as stableHash, i as SourceChangedError, l as withLanguage, n as targetIdentity, o as createSourceRuntime, r as withStableIdentities, s as sliceLines, t as extractJsSourceTargets, u as createStableHasher } from "./extract-DhLFgRej.mjs";
 import { minimatch } from "minimatch";
 import { basename, extname, isAbsolute, relative, resolve } from "pathe";
-import { access, 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 { randomUUID } from "node:crypto";
+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 process, { cwd } from "node:process";
-import { array, boolean, check, custom, finite, getDotPath, literal, number, object, optional, parse, pipe, record, safeParse, string, union, unknown } from "valibot";
 import { Buffer } from "node:buffer";
+import { 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 { streamText } from "@xsai/stream-text";
@@ -236,744 +238,1049 @@ function withExpansionMetadata(item, inheritedMatcherScopes, effectiveBasePath)
 	return 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 src/config/stop-gate.ts
+const maximumStopGateTimeoutMs = 861e5;
+const defaultStopGateConfig = {
+	enabled: false,
+	target: "dirty-files",
+	timeoutMs: 9e5
 };
-//#endregion
-//#region src/core/languages/registry.ts
-function createLanguageRegistry$1() {
+const stopGateConfigSchema = looseObject({
+	enabled: optional(boolean("integrations.stopGate.enabled must be a boolean.")),
+	target: optional(picklist(["all", "dirty-files"], "integrations.stopGate.target must be \"all\" or \"dirty-files\".")),
+	timeoutMs: optional(pipe(number(`integrations.stopGate.timeoutMs must be an integer from 1 to ${maximumStopGateTimeoutMs}.`), integer(`integrations.stopGate.timeoutMs must be an integer from 1 to ${maximumStopGateTimeoutMs}.`), minValue(1, `integrations.stopGate.timeoutMs must be an integer from 1 to ${maximumStopGateTimeoutMs}.`), maxValue(maximumStopGateTimeoutMs, `integrations.stopGate.timeoutMs must be an integer from 1 to ${maximumStopGateTimeoutMs}.`)))
+}, "integrations.stopGate must be an object.");
+function resolveStopGateConfig(config, cwd) {
+	const project = resolveConfigForProject(cwd, config, { cwd });
+	for (const skipped of project.skipped) if (skipped.item.integrations?.stopGate !== void 0) throw new Error("integrations.stopGate must be declared in a global config item without files, directories, or ignores.");
+	return project.matched.reduce((resolved, item) => mergeStopGateConfig(resolved, item), { ...defaultStopGateConfig });
+}
+function assertStopGateConfig(value) {
+	parse(stopGateConfigSchema, value);
+}
+function mergeStopGateConfig(resolved, item) {
+	const stopGate = item.integrations?.stopGate;
+	if (stopGate === void 0) return resolved;
+	assertStopGateConfig(stopGate);
 	return {
-		byExtension: /* @__PURE__ */ new Map(),
-		languages: /* @__PURE__ */ new Map()
+		enabled: stopGate.enabled ?? resolved.enabled,
+		target: stopGate.target ?? resolved.target,
+		timeoutMs: stopGate.timeoutMs ?? resolved.timeoutMs
 	};
 }
-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"
-};
+//#region package.json
+var version = "0.7.0";
 //#endregion
-//#region src/core/languages/ts/index.ts
-const typescriptLanguage = {
-	extensions: [
-		".cts",
-		".mts",
-		".ts",
-		".tsx"
-	],
-	extract: (file) => extractJsSourceTargets(withLanguage(file, "typescript")),
-	name: "typescript"
-};
+//#region src/core/cache/types.ts
+const CACHE_MAGIC = "ALINT_CACHE";
 //#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;
+//#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));
 }
-//#endregion
-//#region src/core/languages/index.ts
-function createBuiltInLanguageRegistry() {
-	const registry = createLanguageRegistry$1();
-	registerLanguage(registry, textLanguage);
-	registerLanguage(registry, javascriptLanguage);
-	registerLanguage(registry, typescriptLanguage);
-	return registry;
+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);
+		}
+	};
 }
-//#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);
+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 [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
-		});
+	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 {
-		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;
 	}
-	return {
-		options: [],
-		severity: entry ?? "warn"
+	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 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/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 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()
 		};
-	});
-}
-/** 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])
+		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"
 		});
-		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
-	});
+		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);
+		}
+	};
 }
-/** 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
-	}));
+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 unregisteredLanguageSeverity(linterOptions) {
-	const value = linterOptions.reportUnregisteredLanguages;
-	return value === "error" || value === "off" ? value : "warn";
+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/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 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 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 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;
 }
-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);
+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;
 }
-//#endregion
-//#region package.json
-var version = "0.5.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 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));
+function isJsonValue(input) {
+	return isJsonValueAt(input, /* @__PURE__ */ new WeakSet());
 }
-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 alintVersion = options.alintVersion ?? version;
-	const header = `${CACHE_MAGIC} 2 ${alintVersion}`;
-	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 {
-		beginOwner: (owner) => beginOwner(body, owner, options.cwd),
-		location,
-		reconcile: async () => {
-			await collectMissingFileOwners(body, options.cwd, fileExists);
-			body.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-			await persistCacheBody(location, header, body, writeFile$1);
+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 {
+		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 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);
+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;
 	}
-	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);
+}
+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 (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}`;
-	};
+	return entries;
 }
-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 ownerKey(owner, cwd) {
+	return stableHash({
+		kind: owner.kind,
+		path: normalizeCachePath(cwd, owner.path)
+	});
 }
-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 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;
+	}
 }
-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);
+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 {
-		if (statSync(resolved).isDirectory()) return join(resolved, DEFAULT_CACHE_FILE_NAME);
-	} catch {}
-	return resolved;
+		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 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();
+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 {
-		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)
+		body: parse(CacheFileBodySchema, body),
+		metadata
 	};
 }
-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 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;
 	}
 }
-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;
+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 createEmptyCacheBody() {
-	const now = (/* @__PURE__ */ new Date()).toISOString();
+//#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 {
-		createdAt: now,
-		entries: {},
-		owners: {},
-		updatedAt: now
+		byExtension: /* @__PURE__ */ new Map(),
+		languages: /* @__PURE__ */ new Map()
 	};
 }
-function createNoopCacheStore(location) {
-	const transaction = {
-		commit: () => {},
-		discard: () => {},
-		lookup: () => void 0,
-		put: () => {}
-	};
+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 {
-		beginOwner: () => transaction,
-		location,
-		reconcile: async () => {}
+		enabledRules,
+		rules
 	};
 }
-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: () => {}
-	});
+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 {
-		beginOwner: transaction,
-		location,
-		reconcile: async () => {}
+		options: [],
+		severity: entry ?? "warn"
 	};
 }
-async function defaultFileExists(path) {
-	try {
-		await access(path);
-		return true;
-	} catch (error) {
-		if (isMissingFileError(error)) return false;
-		throw error;
+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 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;
+function parseRuleOptions(id, schema, options) {
+	if (!schema) {
+		if (options.length > 0) throw new TypeError(`Rule "${id}" does not accept options.`);
+		return [];
 	}
-	return arrayLength !== void 0 && indexCount === arrayLength;
+	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 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;
+/** 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;
 	}
-	return true;
+	existing.ruleIds.add(ruleId);
+	if (path < existing.filePath) existing.filePath = path;
 }
-function isCanonicalArrayIndex(key) {
-	const index = Number(key);
-	return Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === key;
+/**
+* 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
+	});
 }
-function isJsonValue(input) {
-	return isJsonValueAt(input, /* @__PURE__ */ new WeakSet());
+/** 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 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 {
-		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 unregisteredLanguageSeverity(linterOptions) {
+	const value = linterOptions.reportUnregisteredLanguages;
+	return value === "error" || value === "off" ? value : "warn";
 }
-function isMissingFileError(error) {
-	return isNodeErrorCode(error, "ENOENT") || isNodeErrorCode(error, "ENOTDIR");
+//#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 isNodeErrorCode(error, code) {
-	return error instanceof Error && "code" in error && error.code === code;
+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
+	};
 }
-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();
-	}
+//#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 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 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
+		});
 	}
-	return entries;
-}
-function ownerKey(owner, cwd) {
-	return stableHash({
-		kind: owner.kind,
-		path: normalizeCachePath(cwd, owner.path)
-	});
+	for (const directoryPath of options.directories ?? []) {
+		const path = resolve(cwd$2, directoryPath);
+		const resolvedConfig = resolveConfigForDirectory(path, config, { cwd: cwd$2 });
+		if (resolvedConfig.ignored) continue;
+		const effectiveConfig = resolvedConfig.config;
+		directories.push({
+			agent: effectiveConfig.agent,
+			configHash: stableHash({ settings: effectiveConfig.settings }),
+			directoryIndex: directories.length,
+			rules: prepareRules(effectiveConfig),
+			settings: effectiveConfig.settings,
+			target: {
+				kind: "directory",
+				path
+			}
+		});
+	}
+	return {
+		directories,
+		files,
+		missingLanguages,
+		project: options.projectTargets === false ? void 0 : prepareProject(cwd$2, config),
+		unregisteredLanguages
+	};
 }
-function parseCacheBody(text) {
-	const value = JSON.parse(text);
-	return parse(CacheFileBodySchema, value);
+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 persistCacheBody(location, header, body, writeFile) {
-	const validatedBody = parse(CacheFileBodySchema, body);
-	await mkdir(dirname(location), { recursive: true });
-	const tempPath = join(dirname(location), `.${basename$1(location)}.${process.pid}.${randomUUID()}.tmp`);
-	try {
-		await writeFile(tempPath, `${header}\n${JSON.stringify(validatedBody)}\n`);
-		await rename(tempPath, location);
-	} catch (error) {
-		await rm(tempPath, { force: true }).catch(() => {});
-		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 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 prepareRules(config) {
+	return buildRuleRegistry(config).enabledRules.map((enabledRule, ruleIndex) => ({
+		enabledRule,
+		ruleIndex
+	}));
 }
-function slotKey(owner, slot, cwd) {
-	return stableHash({
-		owner: ownerKey(owner, cwd),
-		...slot
-	});
+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 src/core/execution/records.ts
@@ -1112,9 +1419,10 @@ async function executeRuleJob(job, options) {
 		failure: failure(handlerCause, job, handlerCause instanceof SourceChangedError ? "source-changed" : "handler"),
 		state: "failed"
 	});
-	if (slot && fingerprint) try {
+	if (slot && fingerprint) {
 		job.target.cacheOwner?.put(slot, createCacheEntry(job, fingerprint, bucket));
-	} catch {}
+		await job.target.cacheOwner?.checkpoint();
+	}
 	return finish(job, bucket, {
 		cache: "miss",
 		state: "completed"
@@ -2097,7 +2405,7 @@ async function planSource(input, options) {
 		cacheOwner = options.cacheStore.beginOwner({
 			kind: "file",
 			path: file.path
-		});
+		}, { contentHash });
 		const baseFile = {
 			contentHash,
 			language: file.language,
@@ -2112,10 +2420,7 @@ async function planSource(input, options) {
 		};
 	}
 	if (options.signal?.aborted) {
-		cacheOwner.commit({
-			contentHash,
-			mode: "merge"
-		});
+		cacheOwner.commit({ mode: "merge" });
 		return {
 			outcomes: Promise.resolve([]),
 			project
@@ -2124,11 +2429,9 @@ async function planSource(input, options) {
 	const batch = options.scheduler.schedule(jobs);
 	reportFilePlanningComplete(input, batch.jobsAdded, options);
 	return {
-		outcomes: batch.outcomes.then((settled) => {
-			cacheOwner.commit(options.signal?.aborted ? {
-				contentHash,
-				mode: "merge"
-			} : { contentHash });
+		outcomes: batch.outcomes.then(async (settled) => {
+			cacheOwner.commit(options.signal?.aborted ? { mode: "merge" } : void 0);
+			await options.cacheStore.flush();
 			return settled;
 		}),
 		project
@@ -2405,6 +2708,14 @@ var AlintAbortError = class extends AlintRunCancelledError {
 		this.name = "AlintAbortError";
 	}
 };
+var AlintCachePersistenceError = class extends Error {
+	result;
+	constructor(result, cause) {
+		super("Failed to persist the alint cache.", { cause });
+		this.name = "AlintCachePersistenceError";
+		this.result = result;
+	}
+};
 var AlintRunError = class extends Error {
 	failures;
 	result;
@@ -2482,6 +2793,7 @@ async function runAlint(options = {}) {
 	const outcomes = [];
 	const fileFailures = [];
 	let infrastructureError;
+	let cachePersistenceError;
 	let infrastructureFailed = false;
 	let admissionFailed = false;
 	try {
@@ -2545,7 +2857,9 @@ async function runAlint(options = {}) {
 		}
 		if (!admissionFailed && !options.cacheOnly) try {
 			await cacheStore.reconcile();
-		} catch {}
+		} catch (error) {
+			cachePersistenceError = error;
+		}
 	}
 	runProgress.finalize();
 	if (admissionFailed) throw infrastructureError;
@@ -2574,6 +2888,7 @@ async function runAlint(options = {}) {
 		usage: snapshotRunUsage(result.usage)
 	});
 	if (infrastructureFailed) throw infrastructureError;
+	if (cachePersistenceError !== void 0) throw new AlintCachePersistenceError(result, cachePersistenceError);
 	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."),
@@ -2805,6 +3120,7 @@ async function measureModel({ model, prompt, signal }) {
 	}];
 	const startedAt = performance.now();
 	let firstOutputAt;
+	let outputDeltaCount = 0;
 	const result = streamText({
 		...model.params,
 		abortSignal: signal,
@@ -2824,7 +3140,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;
 	}
@@ -2833,7 +3152,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
 	};
 }
@@ -2930,4 +3249,4 @@ function sampleCorpus(seed) {
 	].map((section) => `--- corpus section ${section} ---\n${rotated}`).join("\n\n");
 }
 //#endregion
-export { AlintAbortError, AlintRunCancelledError, AlintRunError, benchmarkModels, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceExtractor, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange, targetIdentity, withLanguage, withStableIdentities };
+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 };