@alint-js/core 0.6.0 → 0.7.0

package/dist/index.mjs

@@ -4,12 +4,12 @@ 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";
@@ -269,553 +269,185 @@ 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.0";
 //#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;
-}
-//#endregion
-//#region src/dsl/registry.ts
-function buildRuleRegistry(config) {
-	const rules = /* @__PURE__ */ new Map();
-	const localIds = /* @__PURE__ */ new Map();
-	const enabledRules = [];
-	for (const [alias, plugin] of Object.entries(config.plugins)) for (const [localId, rule] of Object.entries(plugin.rules ?? {})) {
-		const id = `${alias}/${localId}`;
-		if (rules.has(id)) throw new Error(`Duplicate rule id "${id}".`);
-		rules.set(id, rule);
-		localIds.set(id, localId);
-	}
-	for (const [id, entry] of Object.entries(config.rules)) {
-		const rule = rules.get(id);
-		if (!rule) throw new Error(`Unknown rule "${id}".`);
-		const normalizedEntry = normalizeRuleConfigEntry(entry);
-		const severity = normalizedEntry.severity;
-		if (severity === "off") continue;
-		enabledRules.push({
-			id,
-			localId: localIds.get(id) ?? id,
-			options: parseRuleOptions(id, rule.options, normalizedEntry.options),
-			rule,
-			severity
-		});
-	}
-	return {
-		enabledRules,
-		rules
-	};
-}
-function formatRuleOptionIssues(index, issues) {
-	return issues.map((issue) => {
-		const path = getDotPath(issue);
-		return path === null ? `"${index}": ${issue.message}` : `"${index}.${path}": ${issue.message}`;
-	}).join("; ");
-}
-function isRuleConfigTuple(entry) {
-	return Array.isArray(entry);
-}
-function normalizeRuleConfigEntry(entry) {
-	if (isRuleConfigTuple(entry)) {
-		const [severity = "warn", ...options] = entry;
-		return {
-			options,
-			severity
-		};
-	}
-	return {
-		options: [],
-		severity: entry ?? "warn"
-	};
-}
-function parseRuleOption(id, index, schema, value) {
-	const result = safeParse(schema, value);
-	if (result.success) return result.output;
-	if (value === void 0) {
-		const emptyObjectResult = safeParse(schema, {});
-		if (emptyObjectResult.success) return emptyObjectResult.output;
-	}
-	throw new TypeError(`Invalid options for rule "${id}": ${formatRuleOptionIssues(index, result.issues)}`);
-}
-function parseRuleOptions(id, schema, options) {
-	if (!schema) {
-		if (options.length > 0) throw new TypeError(`Rule "${id}" does not accept options.`);
-		return [];
-	}
-	if (options.length > schema.length) throw new TypeError(`Invalid options for rule "${id}": Unexpected option at index ${schema.length}.`);
-	return schema.map((optionSchema, index) => parseRuleOption(id, index, optionSchema, options[index]));
-}
-//#endregion
-//#region src/core/languages/diagnostics.ts
-/** A rule named a language and nothing registered it. This is a builtin rule. Not a real rule. */
-const MISSING_LANGUAGE_RULE = "alint/missing-language";
-/** A linted file's extension belongs to no registered language. This is a builtin rule. Not a real rule either. */
-const UNREGISTERED_LANGUAGE_RULE = "alint/unregistered-language";
-/**
-* One diagnostic per missing language, always an error: a rule scoped to a language nothing provides
-* matches no file, so leaving it at a warning would let a run pass having silently checked nothing.
-*/
-function missingLanguageDiagnostics(missing) {
-	return [...missing.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([languageId, entry]) => {
-		const ruleIds = [...entry.ruleIds].sort();
-		const subject = ruleIds.length === 1 ? `Rule "${ruleIds[0]}" needs` : `Rules ${ruleIds.map((id) => `"${id}"`).join(", ")} need`;
-		return {
-			filePath: entry.filePath,
-			message: `${subject} the "${languageId}" language, which no plugin registered. Add a plugin that provides "${languageId}", or turn the rule off.`,
-			ruleId: MISSING_LANGUAGE_RULE,
-			severity: "error"
-		};
-	});
-}
-/** Records one rule that named a language the config never registered, grouped by language id. */
-function recordMissingLanguage(into, languageId, ruleId, path) {
-	const existing = into.get(languageId);
-	if (existing === void 0) {
-		into.set(languageId, {
-			filePath: path,
-			ruleIds: /* @__PURE__ */ new Set([ruleId])
-		});
-		return;
-	}
-	existing.ruleIds.add(ruleId);
-	if (path < existing.filePath) existing.filePath = path;
-}
-/**
-* Records one linted file no language claimed, grouped by extension so a missing pack is one
-* diagnostic, not one per file. `'off'` records nothing.
-*/
-function recordUnregistered(into, path, severity) {
-	if (severity === "off") return;
-	const key = extname(path) || basename(path);
-	const existing = into.get(key);
-	into.set(key, {
-		count: (existing?.count ?? 0) + 1,
-		filePath: existing !== void 0 && existing.filePath < path ? existing.filePath : path,
-		severity: existing?.severity === "error" ? "error" : severity
-	});
-}
-/** One diagnostic per extension, sorted, for the run to prepend to its results. */
-function unregisteredLanguageDiagnostics(unregistered) {
-	return [...unregistered.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([extension, entry]) => ({
-		filePath: entry.filePath,
-		message: `No language is registered for "${extension}": ${entry.count} ${entry.count === 1 ? "file was" : "files were"} handled as plain text. Register one through a plugin's "languages", or pin \`language: 'plaintext'\` to accept plain text.`,
-		ruleId: UNREGISTERED_LANGUAGE_RULE,
-		severity: entry.severity
-	}));
-}
-function unregisteredLanguageSeverity(linterOptions) {
-	const value = linterOptions.reportUnregisteredLanguages;
-	return value === "error" || value === "off" ? value : "warn";
-}
-//#endregion
-//#region src/core/languages/rule-languages.ts
-/**
-* The language a file falls back to when no registered language claims its extension. Not a real
-* language, which is why `'any'` excludes it.
-*/
-const PLAIN_TEXT = "plaintext";
-/**
-* Whether a rule reads this target.
-*
-* A rule with language off still reads file targets, because reading raw text, or asking a model about a
-* whole file, needs no language. However, it never reads the function and class targets extraction produces.
-* `'file'` is the one kind every language yields, plain text included, so it is the dividing line.
-*
-* `'any'` means any real language, so a file that fell back to plain text because nothing claimed
-* its extension is withheld: the rule asked for structure and there is none to give. The run says so
-* once per extension through `alint/unregistered-language` rather than letting each rule report an
-* empty file.
-*/
-function isTargetLanguageAccepted(languages, targetKind, targetLanguage) {
-	if (languages.kind === "off") return targetKind === "file";
-	if (languages.kind === "any") return targetLanguage !== PLAIN_TEXT;
-	return languages.ids.includes(targetLanguage);
-}
-function resolveRuleLanguages(languages) {
-	if (languages === void 0) return { kind: "off" };
-	if (languages === "any") return { kind: "any" };
-	if ("ids" in languages) return {
-		ids: languages.ids,
-		kind: "list",
-		skipMissing: languages.skipMissing ?? false
-	};
-	return {
-		ids: languages,
-		kind: "list",
-		skipMissing: false
-	};
-}
-//#endregion
-//#region src/core/preparation.ts
-/**
-* The `ctx.src.extract` a run hands to rules, for parsing files it was never asked to lint, which
-* an index builder sweeping the workspace needs.
-*
-* It resolves each file's OWN config rather than a caller's, because the language a file resolves to
-* is a config decision and two config groups may register different plugins. It extracts on demand
-* and holds nothing: source planning releases rich extractor values after compact jobs are admitted,
-* and a run-wide parse memo here would put that retention back. A caller keeps only what it derives.
-*
-* `getSrc` defers reading the runtime because the runtime is built around this closure. It is assigned
-* before any rule runs, so by the first call it is present.
-*/
-function createSourceExtractor(cwd, config, getSrc) {
-	return async (filePath, options = {}) => {
-		const path = resolve(cwd, filePath);
-		const resolvedConfig = resolveConfigForFile(path, config, { cwd });
-		if (resolvedConfig.ignored) return [];
-		const effectiveConfig = resolvedConfig.config;
-		const language = resolveLanguageForPath(path, createLanguageRegistry(effectiveConfig), { language: options.language ?? effectiveConfig.language });
-		const src = getSrc();
-		const file = await src.readFile(path);
-		return language.extract(file, {
-			cwd,
-			languageOptions: effectiveConfig.languageOptions,
-			src
-		});
-	};
-}
-function prepareRun(options = {}) {
-	const cwd$2 = options.cwd ?? cwd();
-	const config = options.config ?? [];
-	const files = [];
-	const directories = [];
-	const missingLanguages = /* @__PURE__ */ new Map();
-	const unregisteredLanguages = /* @__PURE__ */ new Map();
-	for (const filePath of options.files ?? []) {
-		const path = resolve(cwd$2, filePath);
-		const resolvedConfig = resolveConfigForFile(path, config, { cwd: cwd$2 });
-		if (resolvedConfig.ignored) continue;
-		const effectiveConfig = resolvedConfig.config;
-		const languageRegistry = createLanguageRegistry(effectiveConfig);
-		const language = resolveLanguageForPath(path, languageRegistry, { language: effectiveConfig.language });
-		const rules = prepareRules(effectiveConfig);
-		recordMissingLanguages(missingLanguages, rules, languageRegistry, path);
-		if (effectiveConfig.language === void 0 && language.name === "plaintext" && rules.some(({ enabledRule }) => !isTargetLanguageAccepted(resolveRuleLanguages(enabledRule.rule.languages), "file", "plaintext"))) recordUnregistered(unregisteredLanguages, path, unregisteredLanguageSeverity(effectiveConfig.linterOptions));
-		files.push({
-			agent: effectiveConfig.agent,
-			configHash: stableHash({
-				language: effectiveConfig.language,
-				languageOptions: effectiveConfig.languageOptions,
-				processor: effectiveConfig.processor,
-				resolvedLanguage: language.name,
-				settings: effectiveConfig.settings
-			}),
-			fileIndex: files.length,
-			language,
-			languageOptions: effectiveConfig.languageOptions,
-			path,
-			rules,
-			settings: effectiveConfig.settings
-		});
-	}
-	for (const directoryPath of options.directories ?? []) {
-		const path = resolve(cwd$2, directoryPath);
-		const resolvedConfig = resolveConfigForDirectory(path, config, { cwd: cwd$2 });
-		if (resolvedConfig.ignored) continue;
-		const effectiveConfig = resolvedConfig.config;
-		directories.push({
-			agent: effectiveConfig.agent,
-			configHash: stableHash({ settings: effectiveConfig.settings }),
-			directoryIndex: directories.length,
-			rules: prepareRules(effectiveConfig),
-			settings: effectiveConfig.settings,
-			target: {
-				kind: "directory",
-				path
-			}
-		});
-	}
-	return {
-		directories,
-		files,
-		missingLanguages,
-		project: options.projectTargets === false ? void 0 : prepareProject(cwd$2, config),
-		unregisteredLanguages
-	};
-}
-function createLanguageRegistry(config) {
-	const registry = createBuiltInLanguageRegistry();
-	for (const plugin of Object.values(config.plugins)) for (const language of Object.values(plugin.languages ?? {})) registerLanguage(registry, language);
-	return registry;
-}
-function prepareProject(root, config) {
-	const resolvedConfig = resolveConfigForProject(root, config, { cwd: root });
-	if (resolvedConfig.ignored) return void 0;
-	const effectiveConfig = resolvedConfig.config;
-	return {
-		agent: effectiveConfig.agent,
-		configHash: stableHash({ settings: effectiveConfig.settings }),
-		root,
-		rules: prepareRules(effectiveConfig),
-		settings: effectiveConfig.settings
-	};
-}
-function prepareRules(config) {
-	return buildRuleRegistry(config).enabledRules.map((enabledRule, ruleIndex) => ({
-		enabledRule,
-		ruleIndex
-	}));
-}
-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 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 {
@@ -1055,231 +687,599 @@ function createReadOnlyCacheStore(location, body, cwd) {
 		reconcile: async () => {}
 	};
 }
-async function defaultFileExists(path) {
-	try {
-		await access(path);
-		return true;
-	} catch (error) {
-		if (isMissingFileError(error)) return false;
-		throw error;
+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;
+	}
+	return arrayLength !== void 0 && indexCount === arrayLength;
+}
+function hasJsonObjectProperties(input, ancestors) {
+	for (const key of Reflect.ownKeys(input)) {
+		if (typeof key !== "string") return false;
+		const descriptor = Object.getOwnPropertyDescriptor(input, key);
+		if (!descriptor || !descriptor.enumerable || !("value" in descriptor)) return false;
+		if (!isJsonValueAt(descriptor.value, ancestors)) return false;
+	}
+	return true;
+}
+function isJsonValue(input) {
+	return isJsonValueAt(input, /* @__PURE__ */ new WeakSet());
+}
+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 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);
 }
-function emptyLoadedLog(alintVersion) {
-	const metadata = {
-		alintVersion,
-		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-		magic: CACHE_MAGIC,
-		schemaVersion: 2,
-		type: "metadata"
-	};
+//#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 {
-		body: createEmptyCacheBody(metadata.createdAt),
-		metadata
+		enabledRules,
+		rules
 	};
 }
-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 formatRuleOptionIssues(index, issues) {
+	return issues.map((issue) => {
+		const path = getDotPath(issue);
+		return path === null ? `"${index}": ${issue.message}` : `"${index}.${path}": ${issue.message}`;
+	}).join("; ");
 }
-function fingerprintsEqual(left, right) {
-	return left.configHash === right.configHash && left.modelHash === right.modelHash && left.ruleHash === right.ruleHash && left.targetHash === right.targetHash;
+function isRuleConfigTuple(entry) {
+	return Array.isArray(entry);
 }
-function getCacheLockOptions(retries) {
+function normalizeRuleConfigEntry(entry) {
+	if (isRuleConfigTuple(entry)) {
+		const [severity = "warn", ...options] = entry;
+		return {
+			options,
+			severity
+		};
+	}
 	return {
-		realpath: false,
-		retries,
-		stale: LOCK_STALE_MS,
-		update: LOCK_UPDATE_MS
+		options: [],
+		severity: entry ?? "warn"
 	};
 }
-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 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 arrayLength !== void 0 && indexCount === arrayLength;
+	throw new TypeError(`Invalid options for rule "${id}": ${formatRuleOptionIssues(index, result.issues)}`);
 }
-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;
+function parseRuleOptions(id, schema, options) {
+	if (!schema) {
+		if (options.length > 0) throw new TypeError(`Rule "${id}" does not accept options.`);
+		return [];
 	}
-	return true;
+	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 isJsonValue(input) {
-	return isJsonValueAt(input, /* @__PURE__ */ new WeakSet());
+//#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 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);
+/** 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;
 }
-function isMissingFileError(error) {
-	return isNodeErrorCode(error, "ENOENT") || isNodeErrorCode(error, "ENOTDIR");
+/**
+* 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 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;
-	}
+/** 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";
 }
-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;
+//#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 ownerKey(owner, cwd) {
-	return stableHash({
-		kind: owner.kind,
-		path: normalizeCachePath(cwd, owner.path)
-	});
+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
+	};
 }
-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;
-	}
+//#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
+		});
+	};
 }
-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;
+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
+		});
 	}
-}
-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();
+	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 removeOwner(body, key) {
-	for (const slot of body.owners[key]?.slots ?? []) delete body.entries[slot];
-	delete body.owners[key];
+function createLanguageRegistry(config) {
+	const registry = createBuiltInLanguageRegistry();
+	for (const plugin of Object.values(config.plugins)) for (const language of Object.values(plugin.languages ?? {})) registerLanguage(registry, language);
+	return registry;
 }
-function 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 {}
-	}
+function prepareProject(root, config) {
+	const resolvedConfig = resolveConfigForProject(root, config, { cwd: root });
+	if (resolvedConfig.ignored) return void 0;
+	const effectiveConfig = resolvedConfig.config;
 	return {
-		body: parse(CacheFileBodySchema, body),
-		metadata
+		agent: effectiveConfig.agent,
+		configHash: stableHash({ settings: effectiveConfig.settings }),
+		root,
+		rules: prepareRules(effectiveConfig),
+		settings: effectiveConfig.settings
 	};
 }
-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 prepareRules(config) {
+	return buildRuleRegistry(config).enabledRules.map((enabledRule, ruleIndex) => ({
+		enabledRule,
+		ruleIndex
+	}));
 }
-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 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
@@ -3120,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,
@@ -3139,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;
 	}
@@ -3148,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
 	};
 }
@@ -3245,4 +3249,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 };