@alint-js/core 0.0.22 → 0.0.23

package/dist/index.mjs

@@ -24,41 +24,14 @@ function matchesDiscoveryFile(filePath, input, options) {
 function normalizeConfig(input) {
 	return normalizeConfigItems(input, []);
 }
+function resolveConfigForDirectory(directoryPath, input, options) {
+	return resolveConfig(directoryPath, input, options, "directory");
+}
 function resolveConfigForFile(filePath, input, options) {
-	const items = expandConfig(input);
-	const matched = [];
-	const skipped = [];
-	const config = createEmptyConfig();
-	for (const item of items) {
-		if (isGlobalIgnoreItem(item)) {
-			if (matchesInheritedScopes(filePath, item, options.cwd) && matchesAny(filePath, item.ignores ?? [], options.cwd, getEffectiveBasePath(item))) return {
-				config: createEmptyConfig(),
-				ignored: true,
-				matched: [],
-				skipped
-			};
-			skipped.push({
-				item,
-				reason: "global ignores did not match"
-			});
-			continue;
-		}
-		if (!matchesConfigItem(filePath, item, options.cwd)) {
-			skipped.push({
-				item,
-				reason: "files or ignores did not match"
-			});
-			continue;
-		}
-		matched.push(item);
-		mergeConfig(config, item);
-	}
-	return {
-		config,
-		ignored: false,
-		matched,
-		skipped
-	};
+	return resolveConfig(filePath, input, options, "file");
+}
+function resolveConfigForProject(projectPath, input, options) {
+	return resolveConfig(projectPath, input, options, "project");
 }
 function createEmptyConfig() {
 	return {
@@ -70,9 +43,10 @@ function createEmptyConfig() {
 	};
 }
 function createMatcherScope(item, basePath) {
-	if (!item.files && !item.ignores) return;
+	if (!item.directories && !item.files && !item.ignores) return;
 	return {
 		basePath,
+		directories: item.directories,
 		files: item.files,
 		ignores: item.ignores
 	};
@@ -131,6 +105,10 @@ function getInheritedMatcherScopes(item) {
 function hasDiscoveryMatcher(item) {
 	return hasPositiveFilePattern(item.files) || getInheritedMatcherScopes(item).some((scope) => hasPositiveFilePattern(scope.files));
 }
+function hasOtherTargetPatterns(item, targetKind) {
+	if (targetKind === "project") return item.files !== void 0 || item.directories !== void 0;
+	return targetKind === "directory" ? item.files !== void 0 : item.directories !== void 0;
+}
 function hasPositiveFilePattern(files) {
 	return files?.some((pattern) => isPatternList(pattern) ? pattern.some(isPositivePattern) : isPositivePattern(pattern)) ?? false;
 }
@@ -147,28 +125,30 @@ function isPatternList(pattern) {
 function isPositivePattern(pattern) {
 	return !pattern.startsWith("!");
 }
-function matchesAny(filePath, patterns, cwd, basePath) {
-	return patterns.some((pattern) => matchesPattern(filePath, pattern, cwd, basePath));
-}
-function matchesConfigItem(filePath, item, cwd) {
+function matchesConfigItem(filePath, item, cwd, targetKind) {
 	const basePath = getEffectiveBasePath(item);
-	if (!matchesInheritedScopes(filePath, item, cwd)) return false;
-	if (matchesAny(filePath, item.ignores ?? [], cwd, basePath)) return false;
-	if (!item.files || item.files.length === 0) return true;
-	return item.files.some((pattern) => matchesPattern(filePath, pattern, cwd, basePath));
+	if (!matchesInheritedScopes(filePath, item, cwd, targetKind)) return false;
+	if (matchesIgnores(filePath, item.ignores ?? [], cwd, basePath, targetKind)) return false;
+	const patterns = targetPatterns(item, targetKind);
+	if (patterns !== void 0) return patterns.length === 0 || patterns.some((pattern) => matchesPattern(filePath, pattern, cwd, basePath));
+	return !hasOtherTargetPatterns(item, targetKind);
+}
+function matchesIgnores(targetPath, patterns, cwd, basePath, targetKind) {
+	return patterns.some((pattern) => matchesPattern(targetPath, pattern, cwd, basePath, targetKind === "project"));
 }
-function matchesInheritedScopes(filePath, item, cwd) {
+function matchesInheritedScopes(filePath, item, cwd, targetKind) {
 	return getInheritedMatcherScopes(item).every((scope) => {
-		if (matchesAny(filePath, scope.ignores ?? [], cwd, scope.basePath)) return false;
-		if (!scope.files || scope.files.length === 0) return true;
-		return scope.files.some((pattern) => matchesPattern(filePath, pattern, cwd, scope.basePath));
+		if (matchesIgnores(filePath, scope.ignores ?? [], cwd, scope.basePath, targetKind)) return false;
+		const patterns = targetPatterns(scope, targetKind);
+		if (patterns !== void 0) return patterns.length === 0 || patterns.some((pattern) => matchesPattern(filePath, pattern, cwd, scope.basePath));
+		return !hasOtherTargetPatterns(scope, targetKind);
 	});
 }
-function matchesPattern(filePath, pattern, cwd, basePath) {
-	if (isPatternList(pattern)) return pattern.every((entry) => matchesPattern(filePath, entry, cwd, basePath));
+function matchesPattern(filePath, pattern, cwd, basePath, matchDirectoryRoot = false) {
+	if (isPatternList(pattern)) return pattern.every((entry) => matchesPattern(filePath, entry, cwd, basePath, matchDirectoryRoot));
 	const relativePath = relative(basePath ? resolve(cwd, basePath) : cwd, isAbsolute(filePath) ? filePath : resolve(cwd, filePath)).replaceAll("\\", "/");
 	if (relativePath === ".." || relativePath.startsWith("../")) return false;
-	return minimatch(relativePath, pattern, { dot: true });
+	return minimatch(relativePath, pattern, { dot: true }) || matchDirectoryRoot && minimatch(`${relativePath}/`, pattern, { dot: true });
 }
 function mergeConfig(config, item) {
 	if (item.plugins) for (const [alias, plugin] of Object.entries(item.plugins)) {
@@ -192,6 +172,42 @@ function normalizeConfigItems(input, arrayStack) {
 	if (arrayStack.includes(input)) throw new Error("Circular config array.");
 	return input.flatMap((item) => isConfigArrayInput(item) ? normalizeConfigItems(item, [...arrayStack, input]) : [item]);
 }
+function resolveConfig(targetPath, input, options, targetKind) {
+	const items = expandConfig(input);
+	const matched = [];
+	const skipped = [];
+	const config = createEmptyConfig();
+	for (const item of items) {
+		if (isGlobalIgnoreItem(item)) {
+			if (matchesInheritedScopes(targetPath, item, options.cwd, targetKind) && matchesIgnores(targetPath, item.ignores ?? [], options.cwd, getEffectiveBasePath(item), targetKind)) return {
+				config: createEmptyConfig(),
+				ignored: true,
+				matched: [],
+				skipped
+			};
+			skipped.push({
+				item,
+				reason: "global ignores did not match"
+			});
+			continue;
+		}
+		if (!matchesConfigItem(targetPath, item, options.cwd, targetKind)) {
+			skipped.push({
+				item,
+				reason: "target patterns or ignores did not match"
+			});
+			continue;
+		}
+		matched.push(item);
+		mergeConfig(config, item);
+	}
+	return {
+		config,
+		ignored: false,
+		matched,
+		skipped
+	};
+}
 function resolvePluginConfig(reference, state) {
 	if (state.stringStack.includes(reference)) throw new Error(`Circular config extends: ${[...state.stringStack, reference].join(" -> ")}`);
 	const separator = reference.indexOf("/");
@@ -204,6 +220,10 @@ function resolvePluginConfig(reference, state) {
 		stringStack: [...state.stringStack, reference]
 	});
 }
+function targetPatterns(item, targetKind) {
+	if (targetKind === "directory") return item.directories;
+	if (targetKind === "file") return item.files;
+}
 function withExpansionMetadata(item, inheritedMatcherScopes, effectiveBasePath) {
 	Object.defineProperties(item, {
 		[effectiveBasePathSymbol]: { value: effectiveBasePath },
@@ -652,9 +672,6 @@ function createBuiltInLanguageRegistry() {
 	return registry;
 }
 //#endregion
-//#region package.json
-var version = "0.0.22";
-//#endregion
 //#region src/dsl/registry.ts
 function buildRuleRegistry(config) {
 	const rules = /* @__PURE__ */ new Map();
@@ -694,7 +711,7 @@ function resolveModel(registry, options = {}) {
 	const ruleId = options.ruleId ?? "<unknown>";
 	if (options.request !== void 0) {
 		const request = options.request;
-		const candidate = candidates.find(({ model }) => matchesRequest(model, request));
+		const candidate = candidates.find((candidate) => matchesRequest(candidate, request));
 		if (candidate === void 0) throw new Error(`Unknown model "${request}".`);
 		if (!satisfiesHardRequirements(candidate.model, options.requirement)) throw new Error(`Model "${request}" does not satisfy requirement for rule "${ruleId}".`);
 		return toResolvedModel(candidate, options.requirement);
@@ -709,8 +726,12 @@ function flattenModels(registry) {
 		provider
 	})));
 }
-function matchesRequest(model, request) {
-	return model.id === request || model.name === request || (model.aliases ?? []).includes(request);
+function matchesRequest(candidate, request) {
+	return [
+		candidate.model.id,
+		candidate.model.name,
+		...candidate.model.aliases ?? []
+	].filter((name) => name !== void 0).some((name) => name === request || `${candidate.provider.id}/${name}` === request);
 }
 function preferSize(candidates, requirement) {
 	if (requirement?.size === void 0) return candidates[0];
@@ -912,7 +933,43 @@ function statSyncIsDirectory(path) {
 	return statSync(path).isDirectory();
 }
 //#endregion
-//#region src/core/run.ts
+//#region src/core/targets/directory.ts
+function createDirectoryExecutionPlans(directories, fileOffset) {
+	return directories.map((directory, directoryOffset) => {
+		const executions = directory.ruleRuntimes.map((runtime) => {
+			if (runtime.handlers.onTargetWith) return {
+				run: () => runtime.handlers.onTargetWith?.(directory.target),
+				runtime
+			};
+			if (runtime.handlers.onTargetDirectory) return {
+				run: () => runtime.handlers.onTargetDirectory?.(directory.target),
+				runtime
+			};
+		}).filter((execution) => execution !== void 0);
+		const targets = executions.length === 0 ? [] : [{
+			activeFilePath: directory.target.path,
+			cacheFilePaths: [],
+			configHash: directory.configHash,
+			executions,
+			identity: directory.target.path,
+			kind: "directory",
+			language: "directory",
+			text: directory.target.path
+		}];
+		return {
+			emitFileProgress: true,
+			fileIndex: fileOffset + directoryOffset + 1,
+			path: directory.target.path,
+			planned: executions.length,
+			targets
+		};
+	});
+}
+//#endregion
+//#region package.json
+var version = "0.0.23";
+//#endregion
+//#region src/core/targets/execution.ts
 var AlintRuleExecutionError = class extends Error {
 	failure;
 	constructor(error, path) {
@@ -930,177 +987,16 @@ var AlintRuleExecutionError = class extends Error {
 		};
 	}
 };
-var AlintRunError = class extends Error {
-	failure;
-	result;
-	constructor(message, result, options = {}) {
-		super(message, { cause: options.cause });
-		this.name = "AlintRunError";
-		this.failure = options.failure;
-		this.result = result;
-	}
-};
-async function runAlint(options = {}) {
-	const cwd$1 = options.cwd ?? cwd();
-	const config = options.config ?? [];
-	const setupConfig = options.setupConfig ?? {
-		providers: [],
-		version: 1
-	};
-	const clock = options.runner?.clock ?? Date.now;
-	const diagnostics = [];
-	const usage = createUsageAccumulator();
-	const src = createSourceRuntime();
-	const normalizedCacheConfig = normalizeRunnerCacheConfig(options.runner?.cache, cwd$1);
-	const cacheStore = await createCacheStore({
-		cwd: cwd$1,
-		enabled: normalizedCacheConfig.enabled,
-		location: normalizedCacheConfig.location
-	});
-	const cacheContext = {
-		cwd: cwd$1,
-		enabled: normalizedCacheConfig.enabled,
-		fileEntryKeys: /* @__PURE__ */ new Map(),
-		modelHash: stableHash({
-			modelOverride: options.modelOverride,
-			outputLanguage: options.outputLanguage,
-			setupConfig
-		}),
-		store: cacheStore
-	};
-	const files = (await Promise.all((options.files ?? []).map(async (filePath) => {
-		const file = await src.readFile(resolve(cwd$1, filePath));
-		const resolvedConfig = resolveConfigForFile(file.path, config, { cwd: cwd$1 });
-		if (resolvedConfig.ignored) return;
-		const effectiveConfig = resolvedConfig.config;
-		const languageRegistry = createBuiltInLanguageRegistry();
-		for (const plugin of Object.values(effectiveConfig.plugins)) for (const language of Object.values(plugin.languages ?? {})) registerLanguage(languageRegistry, language);
-		const language = resolveLanguage(file, languageRegistry, { language: effectiveConfig.language });
-		const targets = await language.extract(file, {
-			cwd: cwd$1,
-			languageOptions: effectiveConfig.languageOptions,
-			src
-		});
-		const registry = buildRuleRegistry(effectiveConfig);
-		const ruleRuntimes = createRuleRuntimes({
-			cwd: cwd$1,
-			diagnostics,
-			effectiveAgent: effectiveConfig.agent,
-			effectiveSettings: effectiveConfig.settings,
-			options,
-			registry,
-			setupConfig,
-			src,
-			usage
-		});
-		return {
-			configHash: stableHash({
-				language: effectiveConfig.language,
-				languageOptions: effectiveConfig.languageOptions,
-				processor: effectiveConfig.processor,
-				resolvedLanguage: language.name,
-				rules: effectiveConfig.rules,
-				settings: effectiveConfig.settings
-			}),
-			file,
-			ruleRuntimes,
-			targets
-		};
-	}))).filter((file) => file !== void 0);
-	let planned = 0;
-	const counters = createRuleEndCounters();
-	const primaryError = createPrimaryErrorState();
-	let filePlans = [];
-	let runStartedAt;
-	let runError;
-	try {
-		filePlans = createPreparedFileExecutionPlans(files, cwd$1);
-		planned = calculatePlannedExecutions(filePlans);
-		runStartedAt = clock();
-		options.progress?.onRunStart?.({
-			files: filePlans.map((filePlan) => toProgressFilePath(filePlan, files.length)),
-			filesTotal: files.length,
-			planned,
-			rulesTotal: countEnabledRuleIds(files),
-			startedAt: runStartedAt
-		});
-		await runConcurrently(filePlans.filter((filePlan) => filePlan.targets.length > 0), resolveFileConcurrency(options.runner?.fileConcurrency), (filePlan) => executeFilePlan(filePlan, files.length, clock, counters, diagnostics, usage, cacheContext, options));
-	} catch (error) {
-		primaryError.set();
-		runError = error;
-	} finally {
-		await reconcileCache(filePlans, cacheContext);
-		emitCleanupProgress(() => options.progress?.onRunEnd?.({
-			...counters.snapshot(planned),
-			diagnostics,
-			endedAt: clock(),
-			startedAt: runStartedAt ?? clock(),
-			usage: usage.toJSON()
-		}), primaryError);
-	}
-	const result = {
-		diagnostics,
-		usage: usage.toJSON()
-	};
-	if (runError) throw createAlintRunError(runError, result);
-	return result;
-}
-function addTokenCount(base, value) {
-	return typeof value === "number" && Number.isFinite(value) ? base + value : base;
-}
-function calculateFilePlanExecutions(filePlan) {
-	return filePlan.targets.reduce((total, target) => total + target.executions.length, 0);
-}
-function calculatePlannedExecutions(filePlans) {
-	return filePlans.reduce((total, filePlan) => total + filePlan.planned, 0);
-}
-function collectExecutionTargets(preparedFile) {
-	const targets = [];
-	for (const sourceTarget of preparedFile.targets) {
-		const executions = preparedFile.ruleRuntimes.map((runtime) => {
-			if (!runtime.handlers.onTarget) return;
-			return {
-				run: () => runtime.handlers.onTarget?.(sourceTarget),
-				runtime
-			};
-		}).filter((execution) => execution !== void 0);
-		if (executions.length === 0) continue;
-		targets.push({
-			configHash: preparedFile.configHash,
-			executions,
-			identity: sourceTarget.identity,
-			kind: sourceTarget.kind,
-			language: sourceTarget.language,
-			loc: sourceTarget.loc,
-			metadata: sourceTarget.metadata,
-			name: sourceTarget.name,
-			origin: sourceTarget.origin,
-			range: sourceTarget.range,
-			text: sourceTarget.text
-		});
-	}
-	return targets;
-}
-function countEnabledRuleIds(files) {
-	const ids = /* @__PURE__ */ new Set();
-	for (const file of files) for (const runtime of file.ruleRuntimes) ids.add(runtime.enabledRule.id);
-	return ids.size;
-}
-function createAlintRunError(error, result) {
-	if (error instanceof AlintRunError) return error;
-	if (error instanceof AlintRuleExecutionError) return new AlintRunError(error.message, result, {
-		cause: errorCauseFrom(error),
-		failure: error.failure
-	});
-	return new AlintRunError(errorMessageFrom(error) ?? String(error), result, { cause: error });
+async function executeTargetPlans(options) {
+	for (const plan of options.plans) await executeTargetPlan(plan, options);
 }
-function createExecutionCacheKey(runtime, target, path, cacheContext) {
-	if (!cacheContext.enabled || !runtime.cacheable) return;
+function createExecutionCacheKey(runtime, target, path, cache) {
+	if (!cache.enabled || !runtime.cacheable || target.cacheFilePaths.length === 0) return;
 	return createCacheKey({
 		alintVersion: version,
 		configHash: target.configHash,
-		filePath: normalizeCachePath(cacheContext.cwd, path.file.path),
-		modelHash: cacheContext.modelHash,
+		filePath: normalizeCachePath(cache.cwd, path.file.path),
+		modelHash: cache.modelHash,
 		ruleHash: runtime.ruleHash,
 		schemaVersion: 1,
 		targetHash: createTargetHash(target),
@@ -1108,32 +1004,6 @@ function createExecutionCacheKey(runtime, target, path, cacheContext) {
 		targetKind: target.kind
 	});
 }
-function createPreparedFileExecutionPlans(files, cwd) {
-	return files.map((preparedFile, fileOffset) => {
-		const targets = collectExecutionTargets(preparedFile);
-		const resolveTargetIdentity = createTargetIdentityResolver(targets.map((target) => toTargetIdentityInput(cwd, preparedFile.file.path, target)));
-		for (const target of targets) target.identity = resolveTargetIdentity(toTargetIdentityInput(cwd, preparedFile.file.path, target));
-		const filePlan = {
-			fileIndex: fileOffset + 1,
-			planned: 0,
-			preparedFile,
-			targets
-		};
-		filePlan.planned = calculateFilePlanExecutions(filePlan);
-		return filePlan;
-	});
-}
-function createPrimaryErrorState() {
-	let hasError = false;
-	return {
-		get hasError() {
-			return hasError;
-		},
-		set() {
-			hasError = true;
-		}
-	};
-}
 function createProgressPath(filePath, ruleId, entry) {
 	return {
 		file: {
@@ -1155,13 +1025,596 @@ function createProgressPath(filePath, ruleId, entry) {
 		}
 	};
 }
-function createRuleEndCounters() {
-	let cached = 0;
-	let completed = 0;
-	let errored = 0;
-	return {
-		cache() {
-			cached += 1;
+function createTargetHash(target) {
+	return stableHash({
+		language: target.language,
+		loc: target.loc,
+		metadata: target.metadata,
+		name: target.name,
+		origin: target.origin,
+		range: target.range,
+		text: target.text
+	});
+}
+function emitErroredRuleEnd(progress, clock, path, startedAt, cache) {
+	try {
+		progress?.onRuleEnd?.({
+			cache,
+			endedAt: clock(),
+			path,
+			startedAt,
+			state: "errored"
+		});
+	} catch {}
+}
+async function executeRule(execution, path, target, options) {
+	const { cache, clock, counters, diagnostics, progress, usage } = options;
+	const startedAt = clock();
+	const cacheKey = createExecutionCacheKey(execution.runtime, target, path, cache);
+	const cachedEntry = cacheKey ? cache.store.get(cacheKey) : void 0;
+	progress?.onRuleStart?.({
+		path,
+		startedAt
+	});
+	if (cacheKey && cachedEntry) {
+		rememberCacheEntry(cache, target.cacheFilePaths, cacheKey);
+		try {
+			replayCachedEntry(cachedEntry, path, diagnostics, usage, progress);
+		} catch (error) {
+			counters.error();
+			emitErroredRuleEnd(progress, clock, path, startedAt, "hit");
+			throw new AlintRuleExecutionError(error, path);
+		}
+		counters.cache();
+		progress?.onRuleEnd?.({
+			cache: "hit",
+			endedAt: clock(),
+			path,
+			startedAt,
+			state: "completed"
+		});
+		return;
+	}
+	let handlerError;
+	let handlerFailed = false;
+	const cacheDiagnostics = cacheKey ? [] : void 0;
+	const cacheUsage = cacheKey ? [] : void 0;
+	try {
+		await execution.runtime.executionState.run({
+			activeFilePath: target.activeFilePath,
+			cacheDiagnostics,
+			cacheUsage,
+			progressPath: path
+		}, execution.run);
+	} catch (error) {
+		handlerError = error;
+		handlerFailed = true;
+	}
+	if (handlerFailed) {
+		counters.error();
+		emitErroredRuleEnd(progress, clock, path, startedAt, "miss");
+		throw new AlintRuleExecutionError(handlerError, path);
+	}
+	if (cacheKey) {
+		cache.store.set(cacheKey, {
+			diagnostics: cacheDiagnostics ?? [],
+			filePath: normalizeCachePath(cache.cwd, path.file.path),
+			fingerprint: {
+				alintVersion: version,
+				configHash: target.configHash,
+				modelHash: cache.modelHash,
+				ruleHash: execution.runtime.ruleHash
+			},
+			target: {
+				hash: createTargetHash(target),
+				identity: target.identity,
+				kind: target.kind,
+				loc: target.loc,
+				name: target.name,
+				range: target.range
+			},
+			usage: cacheUsage ?? []
+		});
+		rememberCacheEntry(cache, target.cacheFilePaths, cacheKey);
+	}
+	counters.complete();
+	progress?.onRuleEnd?.({
+		cache: "miss",
+		endedAt: clock(),
+		path,
+		startedAt,
+		state: "completed"
+	});
+}
+async function executeTargetPlan(plan, options) {
+	const { clock, filesTotal, progress } = options;
+	const fileStartedAt = clock();
+	const fileProgress = {
+		index: plan.fileIndex,
+		path: plan.path,
+		planned: plan.planned,
+		total: filesTotal
+	};
+	if (plan.emitFileProgress) progress?.onFileStart?.({
+		file: fileProgress,
+		startedAt: fileStartedAt
+	});
+	let planError;
+	let planFailed = false;
+	try {
+		for (const [targetOffset, target] of plan.targets.entries()) {
+			const targetPath = createProgressPath(plan.path, target.executions[0]?.runtime.enabledRule.id ?? "", {
+				fileIndex: plan.fileIndex,
+				filePlanned: plan.planned,
+				fileTotal: filesTotal,
+				ruleIndex: 1,
+				ruleTotal: target.executions.length,
+				targetIndex: targetOffset + 1,
+				targetKind: target.kind,
+				targetName: target.name,
+				targetTotal: plan.targets.length
+			});
+			const targetStartedAt = clock();
+			progress?.onTargetStart?.({
+				path: targetPath,
+				startedAt: targetStartedAt
+			});
+			let targetError;
+			let targetFailed = false;
+			try {
+				for (const [executionOffset, execution] of target.executions.entries()) await executeRule(execution, createProgressPath(plan.path, execution.runtime.enabledRule.id, {
+					fileIndex: plan.fileIndex,
+					filePlanned: plan.planned,
+					fileTotal: filesTotal,
+					ruleIndex: executionOffset + 1,
+					ruleTotal: target.executions.length,
+					targetIndex: targetOffset + 1,
+					targetKind: target.kind,
+					targetName: target.name,
+					targetTotal: plan.targets.length
+				}), target, options);
+			} catch (error) {
+				targetError = error;
+				targetFailed = true;
+			}
+			try {
+				progress?.onTargetEnd?.({
+					endedAt: clock(),
+					path: targetPath,
+					startedAt: targetStartedAt
+				});
+			} catch (error) {
+				if (!targetFailed) {
+					targetError = error;
+					targetFailed = true;
+				}
+			}
+			if (targetFailed) throw targetError;
+		}
+	} catch (error) {
+		planError = error;
+		planFailed = true;
+	}
+	if (plan.emitFileProgress) try {
+		progress?.onFileEnd?.({
+			endedAt: clock(),
+			file: fileProgress,
+			startedAt: fileStartedAt
+		});
+	} catch (error) {
+		if (!planFailed) {
+			planError = error;
+			planFailed = true;
+		}
+	}
+	if (planFailed) throw planError;
+}
+function rememberCacheEntry(cache, filePaths, cacheKey) {
+	for (const filePath of filePaths) {
+		const normalizedPath = normalizeCachePath(cache.cwd, filePath);
+		const entries = cache.fileEntryKeys.get(normalizedPath) ?? /* @__PURE__ */ new Set();
+		entries.add(cacheKey);
+		cache.fileEntryKeys.set(normalizedPath, entries);
+	}
+}
+function replayCachedEntry(entry, path, diagnostics, usage, progress) {
+	for (const cachedDiagnostic of entry.diagnostics) {
+		const diagnostic = {
+			...cachedDiagnostic,
+			cached: true
+		};
+		diagnostics.push(diagnostic);
+		progress?.onDiagnostic?.({
+			diagnostic,
+			diagnostics: [...diagnostics],
+			path
+		});
+	}
+	for (const cachedUsage of entry.usage) {
+		const record = usage.recordCached({ ...cachedUsage });
+		progress?.onUsage?.({
+			path,
+			record,
+			total: usage.toJSON()
+		});
+	}
+}
+//#endregion
+//#region src/core/targets/project.ts
+function createProjectExecutionPlan(options) {
+	const project = createProjectTarget(options.root, options.files);
+	const executions = options.ruleRuntimes.map((runtime) => {
+		if (runtime.handlers.onTargetWith) return {
+			run: () => runtime.handlers.onTargetWith?.(project),
+			runtime
+		};
+		if (runtime.handlers.onTargetProject) return {
+			run: () => runtime.handlers.onTargetProject?.(project),
+			runtime
+		};
+	}).filter((execution) => execution !== void 0);
+	if (executions.length === 0) return;
+	const target = {
+		cacheFilePaths: options.files.map((file) => file.file.path),
+		configHash: options.configHash,
+		executions,
+		identity: "project",
+		kind: "project",
+		language: "project",
+		text: stableHash({
+			files: options.files.map((file) => ({
+				configHash: file.configHash,
+				contentHash: hashText(file.file.text),
+				path: normalizeCachePath(options.root, file.file.path)
+			})).sort((left, right) => left.path.localeCompare(right.path)),
+			targets: project.targets.map((target) => ({
+				filePath: normalizeCachePath(options.root, target.file.path),
+				identity: target.identity,
+				kind: target.kind,
+				language: target.language,
+				loc: target.loc,
+				metadata: target.metadata,
+				name: target.name,
+				origin: target.origin,
+				range: target.range,
+				text: target.text
+			})),
+			tree: createProjectTreeShape(options.files, options.root)
+		})
+	};
+	return {
+		emitFileProgress: false,
+		fileIndex: 0,
+		path: options.root,
+		planned: executions.length,
+		targets: [target]
+	};
+}
+function createProjectTarget(root, files) {
+	const preparedFiles = [...files].sort((left, right) => left.file.path.localeCompare(right.file.path));
+	return {
+		files: preparedFiles.map((file) => file.file),
+		kind: "project",
+		root,
+		targets: preparedFiles.flatMap((file) => file.targets)
+	};
+}
+function createProjectTreeShape(files, root) {
+	const directories = /* @__PURE__ */ new Set();
+	const paths = files.map((file) => normalizeCachePath(root, file.file.path)).sort();
+	for (const path of paths) {
+		const parts = path.split("/");
+		for (let index = 1; index < parts.length; index += 1) directories.add(parts.slice(0, index).join("/"));
+	}
+	return {
+		directories: [...directories].sort(),
+		files: paths
+	};
+}
+//#endregion
+//#region src/core/targets/source.ts
+function createSourceExecutionPlans(files, cwd) {
+	return files.map((preparedFile, fileOffset) => {
+		const targets = collectExecutionTargets(preparedFile);
+		const resolveTargetIdentity = createTargetIdentityResolver(targets.map((target) => toTargetIdentityInput(cwd, preparedFile.file.path, target)));
+		for (const target of targets) target.identity = resolveTargetIdentity(toTargetIdentityInput(cwd, preparedFile.file.path, target));
+		const filePlan = {
+			emitFileProgress: true,
+			fileIndex: fileOffset + 1,
+			path: preparedFile.file.path,
+			planned: 0,
+			preparedFile,
+			targets
+		};
+		filePlan.planned = calculateFilePlanExecutions(filePlan);
+		return filePlan;
+	});
+}
+function calculateFilePlanExecutions(filePlan) {
+	return filePlan.targets.reduce((total, target) => total + target.executions.length, 0);
+}
+function collectExecutionTargets(preparedFile) {
+	const targets = [];
+	for (const sourceTarget of preparedFile.targets) {
+		const executions = preparedFile.ruleRuntimes.map((runtime) => {
+			return createSourceTargetExecution(runtime, sourceTarget);
+		}).filter((execution) => execution !== void 0);
+		if (executions.length === 0) continue;
+		targets.push({
+			activeFilePath: preparedFile.file.path,
+			cacheFilePaths: [preparedFile.file.path],
+			configHash: preparedFile.configHash,
+			executions,
+			identity: sourceTarget.identity,
+			kind: sourceTarget.kind,
+			language: sourceTarget.language,
+			loc: sourceTarget.loc,
+			metadata: sourceTarget.metadata,
+			name: sourceTarget.name,
+			origin: sourceTarget.origin,
+			range: sourceTarget.range,
+			text: sourceTarget.text
+		});
+	}
+	return targets;
+}
+function createSourceTargetExecution(runtime, target) {
+	if (runtime.handlers.onTargetWith) return {
+		run: () => runtime.handlers.onTargetWith?.(target),
+		runtime
+	};
+	if (target.kind === "class" && runtime.handlers.onTargetClass) return {
+		run: () => runtime.handlers.onTargetClass?.(target),
+		runtime
+	};
+	if (target.kind === "file" && runtime.handlers.onTargetFile) return {
+		run: () => runtime.handlers.onTargetFile?.(target),
+		runtime
+	};
+	if (target.kind === "function" && runtime.handlers.onTargetFunction) return {
+		run: () => runtime.handlers.onTargetFunction?.(target),
+		runtime
+	};
+}
+function toTargetIdentityInput(cwd, filePath, target) {
+	return {
+		filePath: target.kind === "file" ? normalizeCachePath(cwd, filePath) : void 0,
+		identity: target.identity,
+		kind: target.kind,
+		name: target.name,
+		range: target.range
+	};
+}
+//#endregion
+//#region src/core/run.ts
+var AlintRunError = class extends Error {
+	failure;
+	result;
+	constructor(message, result, options = {}) {
+		super(message, { cause: options.cause });
+		this.name = "AlintRunError";
+		this.failure = options.failure;
+		this.result = result;
+	}
+};
+async function runAlint(options = {}) {
+	const cwd$1 = options.cwd ?? cwd();
+	const config = options.config ?? [];
+	const setupConfig = options.setupConfig ?? {
+		providers: [],
+		version: 1
+	};
+	const clock = Date.now;
+	const diagnostics = [];
+	const usage = createUsageAccumulator();
+	const src = createSourceRuntime();
+	const normalizedCacheConfig = normalizeRunnerCacheConfig(options.runner?.cache, cwd$1);
+	const cacheStore = await createCacheStore({
+		cwd: cwd$1,
+		enabled: normalizedCacheConfig.enabled,
+		location: normalizedCacheConfig.location
+	});
+	const cacheContext = {
+		cwd: cwd$1,
+		enabled: normalizedCacheConfig.enabled,
+		fileEntryKeys: /* @__PURE__ */ new Map(),
+		modelHash: stableHash({
+			modelOverride: options.modelOverride,
+			outputLanguage: options.outputLanguage,
+			setupConfig
+		}),
+		store: cacheStore
+	};
+	const pendingFiles = [...options.files ?? []];
+	const pendingDirectories = [...options.directories ?? []];
+	const files = (await Promise.all(pendingFiles.map(async (filePath) => {
+		const file = await src.readFile(resolve(cwd$1, filePath));
+		const resolvedConfig = resolveConfigForFile(file.path, config, { cwd: cwd$1 });
+		if (resolvedConfig.ignored) return;
+		const effectiveConfig = resolvedConfig.config;
+		const languageRegistry = createBuiltInLanguageRegistry();
+		for (const plugin of Object.values(effectiveConfig.plugins)) for (const language of Object.values(plugin.languages ?? {})) registerLanguage(languageRegistry, language);
+		const language = resolveLanguage(file, languageRegistry, { language: effectiveConfig.language });
+		const targets = await language.extract(file, {
+			cwd: cwd$1,
+			languageOptions: effectiveConfig.languageOptions,
+			src
+		});
+		const registry = buildRuleRegistry(effectiveConfig);
+		const ruleRuntimes = createRuleRuntimes({
+			cwd: cwd$1,
+			diagnostics,
+			effectiveAgent: effectiveConfig.agent,
+			effectiveSettings: effectiveConfig.settings,
+			options,
+			registry,
+			setupConfig,
+			src,
+			usage
+		});
+		return {
+			configHash: stableHash({
+				language: effectiveConfig.language,
+				languageOptions: effectiveConfig.languageOptions,
+				processor: effectiveConfig.processor,
+				resolvedLanguage: language.name,
+				settings: effectiveConfig.settings
+			}),
+			file,
+			ruleRuntimes,
+			targets
+		};
+	}))).filter((file) => file !== void 0);
+	const directories = pendingDirectories.map((directoryPath) => {
+		const target = {
+			kind: "directory",
+			path: resolve(cwd$1, directoryPath)
+		};
+		const resolvedConfig = resolveConfigForDirectory(target.path, config, { cwd: cwd$1 });
+		if (resolvedConfig.ignored) return;
+		const effectiveConfig = resolvedConfig.config;
+		const registry = buildRuleRegistry(effectiveConfig);
+		return {
+			configHash: stableHash({ settings: effectiveConfig.settings }),
+			ruleRuntimes: createRuleRuntimes({
+				cwd: cwd$1,
+				diagnostics,
+				effectiveAgent: effectiveConfig.agent,
+				effectiveSettings: effectiveConfig.settings,
+				options,
+				registry,
+				setupConfig,
+				src,
+				usage
+			}),
+			target
+		};
+	}).filter((directory) => directory !== void 0);
+	const resolvedProjectConfig = resolveConfigForProject(cwd$1, config, { cwd: cwd$1 });
+	const projectConfig = resolvedProjectConfig.config;
+	const projectRuleRuntimes = resolvedProjectConfig.ignored ? [] : createRuleRuntimes({
+		cwd: cwd$1,
+		diagnostics,
+		effectiveAgent: projectConfig.agent,
+		effectiveSettings: projectConfig.settings,
+		options,
+		registry: buildRuleRegistry(projectConfig),
+		setupConfig,
+		src,
+		usage
+	});
+	let planned = 0;
+	const counters = createRuleEndCounters();
+	let filePlans = [];
+	let directoryPlans = [];
+	let projectPlan;
+	let runStartedAt;
+	let runError;
+	try {
+		filePlans = createSourceExecutionPlans(files, cwd$1);
+		directoryPlans = createDirectoryExecutionPlans(directories, filePlans.length);
+		projectPlan = resolvedProjectConfig.ignored ? void 0 : createProjectExecutionPlan({
+			configHash: stableHash({ settings: projectConfig.settings }),
+			files,
+			root: cwd$1,
+			ruleRuntimes: projectRuleRuntimes
+		});
+		const activeDirectoryPlans = directoryPlans.filter((plan) => plan.targets.length > 0).map((plan, directoryOffset) => ({
+			...plan,
+			fileIndex: filePlans.length + directoryOffset + 1
+		}));
+		const inputsTotal = files.length + activeDirectoryPlans.length;
+		planned = calculatePlannedExecutions([...filePlans, ...directoryPlans]) + (projectPlan?.planned ?? 0);
+		runStartedAt = clock();
+		options.progress?.onRunStart?.({
+			files: [...filePlans, ...activeDirectoryPlans].map((plan) => toProgressFilePath(plan, inputsTotal)),
+			filesTotal: inputsTotal,
+			planned,
+			rulesTotal: countEnabledRuleIds(files, directories, projectRuleRuntimes),
+			startedAt: runStartedAt
+		});
+		await runConcurrently(filePlans.filter((filePlan) => filePlan.targets.length > 0), resolveFileConcurrency(options.runner?.fileConcurrency), (filePlan) => executeTargetPlans({
+			cache: cacheContext,
+			clock,
+			counters,
+			diagnostics,
+			filesTotal: inputsTotal,
+			plans: [filePlan],
+			progress: options.progress,
+			usage
+		}));
+		await runConcurrently(activeDirectoryPlans, resolveFileConcurrency(options.runner?.fileConcurrency), (directoryPlan) => executeTargetPlans({
+			cache: cacheContext,
+			clock,
+			counters,
+			diagnostics,
+			filesTotal: inputsTotal,
+			plans: [directoryPlan],
+			progress: options.progress,
+			usage
+		}));
+		if (projectPlan) await executeTargetPlans({
+			cache: cacheContext,
+			clock,
+			counters,
+			diagnostics,
+			filesTotal: inputsTotal,
+			plans: [projectPlan],
+			progress: options.progress,
+			usage
+		});
+	} catch (error) {
+		runError = error;
+	} finally {
+		await reconcileCache(filePlans, cacheContext);
+		try {
+			options.progress?.onRunEnd?.({
+				...counters.snapshot(planned),
+				diagnostics,
+				endedAt: clock(),
+				startedAt: runStartedAt ?? clock(),
+				usage: usage.toJSON()
+			});
+		} catch (error) {
+			runError ??= error;
+		}
+	}
+	const result = {
+		diagnostics,
+		execution: counters.snapshot(planned),
+		usage: usage.toJSON()
+	};
+	if (runError) throw createAlintRunError(runError, result);
+	return result;
+}
+function addTokenCount(base, value) {
+	return typeof value === "number" && Number.isFinite(value) ? base + value : base;
+}
+function calculatePlannedExecutions(filePlans) {
+	return filePlans.reduce((total, filePlan) => total + filePlan.planned, 0);
+}
+function countEnabledRuleIds(files, directories, projectRuleRuntimes) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const file of files) for (const runtime of file.ruleRuntimes) ids.add(runtime.enabledRule.id);
+	for (const directory of directories) for (const runtime of directory.ruleRuntimes) ids.add(runtime.enabledRule.id);
+	for (const runtime of projectRuleRuntimes) ids.add(runtime.enabledRule.id);
+	return ids.size;
+}
+function createAlintRunError(error, result) {
+	if (error instanceof AlintRunError) return error;
+	if (error instanceof AlintRuleExecutionError) return new AlintRunError(error.message, result, {
+		cause: errorCauseFrom(error),
+		failure: error.failure
+	});
+	return new AlintRunError(errorMessageFrom(error) ?? String(error), result, { cause: error });
+}
+function createRuleEndCounters() {
+	let cached = 0;
+	let completed = 0;
+	let errored = 0;
+	return {
+		cache() {
+			cached += 1;
 		},
 		complete() {
 			completed += 1;
@@ -1247,6 +1700,7 @@ function createRuleRuntimes(options) {
 			handlers: enabledRule.rule.create(context),
 			ruleHash: stableHash({
 				cache: enabledRule.rule.cache ?? true,
+				cacheKey: enabledRule.rule.cacheKey,
 				create: String(enabledRule.rule.create),
 				id: enabledRule.id,
 				localId: enabledRule.localId,
@@ -1256,18 +1710,26 @@ function createRuleRuntimes(options) {
 		};
 	});
 }
-function createTargetHash(target) {
-	return stableHash({
-		language: target.language,
-		loc: target.loc,
-		metadata: target.metadata,
-		name: target.name,
-		origin: target.origin,
-		range: target.range,
-		text: target.text
-	});
-}
 function createUsageAccumulator() {
+	const live = createUsageTotals();
+	const cached = createUsageTotals();
+	return {
+		record(record) {
+			return live.record(record);
+		},
+		recordCached(record) {
+			return cached.record(record);
+		},
+		toJSON() {
+			const cachedUsage = cached.toJSON();
+			return {
+				...live.toJSON(),
+				...cachedUsage.records.length > 0 ? { cached: cachedUsage } : {}
+			};
+		}
+	};
+}
+function createUsageTotals() {
 	const records = [];
 	let inputTokens = 0;
 	let outputTokens = 0;
@@ -1290,175 +1752,6 @@ function createUsageAccumulator() {
 		}
 	};
 }
-function emitCleanupProgress(callback, primaryError) {
-	try {
-		callback();
-	} catch (error) {
-		if (!primaryError.hasError) throw error;
-	}
-}
-async function executeFilePlan(filePlan, filesTotal, clock, counters, diagnostics, usage, cacheContext, options) {
-	const preparedFile = filePlan.preparedFile;
-	const fileStartedAt = clock();
-	const fileProgress = {
-		index: filePlan.fileIndex,
-		path: preparedFile.file.path,
-		planned: filePlan.planned,
-		total: filesTotal
-	};
-	options.progress?.onFileStart?.({
-		file: fileProgress,
-		startedAt: fileStartedAt
-	});
-	const fileError = createPrimaryErrorState();
-	try {
-		for (const [targetOffset, target] of filePlan.targets.entries()) {
-			const targetPath = createProgressPath(preparedFile.file.path, target.executions[0]?.runtime.enabledRule.id ?? "", {
-				fileIndex: filePlan.fileIndex,
-				filePlanned: filePlan.planned,
-				fileTotal: filesTotal,
-				ruleIndex: 1,
-				ruleTotal: target.executions.length,
-				targetIndex: targetOffset + 1,
-				targetKind: target.kind,
-				targetName: target.name,
-				targetTotal: filePlan.targets.length
-			});
-			const targetError = createPrimaryErrorState();
-			const targetStartedAt = clock();
-			options.progress?.onTargetStart?.({
-				path: targetPath,
-				startedAt: targetStartedAt
-			});
-			try {
-				for (const [executionOffset, execution] of target.executions.entries()) await executeProgressTarget(execution, createProgressPath(preparedFile.file.path, execution.runtime.enabledRule.id, {
-					fileIndex: filePlan.fileIndex,
-					filePlanned: filePlan.planned,
-					fileTotal: filesTotal,
-					ruleIndex: executionOffset + 1,
-					ruleTotal: target.executions.length,
-					targetIndex: targetOffset + 1,
-					targetKind: target.kind,
-					targetName: target.name,
-					targetTotal: filePlan.targets.length
-				}), target, clock, counters, diagnostics, usage, cacheContext, options);
-			} catch (error) {
-				targetError.set();
-				throw error;
-			} finally {
-				emitCleanupProgress(() => options.progress?.onTargetEnd?.({
-					endedAt: clock(),
-					path: targetPath,
-					startedAt: targetStartedAt
-				}), targetError);
-			}
-		}
-	} catch (error) {
-		fileError.set();
-		throw error;
-	} finally {
-		emitCleanupProgress(() => options.progress?.onFileEnd?.({
-			endedAt: clock(),
-			file: fileProgress,
-			startedAt: fileStartedAt
-		}), fileError);
-	}
-}
-async function executeProgressTarget(execution, path, target, clock, counters, diagnostics, usage, cacheContext, options) {
-	const startedAt = clock();
-	const cacheKey = createExecutionCacheKey(execution.runtime, target, path, cacheContext);
-	const cachedEntry = cacheKey && cacheContext.enabled && execution.runtime.cacheable ? cacheContext.store.get(cacheKey) : void 0;
-	options.progress?.onRuleStart?.({
-		path,
-		startedAt
-	});
-	if (cacheKey && cachedEntry) {
-		rememberFileCacheEntry(cacheContext, path.file.path, cacheKey);
-		try {
-			replayCachedEntry(cachedEntry, path, diagnostics, usage, options);
-		} catch (error) {
-			counters.error();
-			try {
-				options.progress?.onRuleEnd?.({
-					cache: "hit",
-					endedAt: clock(),
-					path,
-					startedAt,
-					state: "errored"
-				});
-			} catch {}
-			throw new AlintRuleExecutionError(error, path);
-		}
-		counters.cache();
-		options.progress?.onRuleEnd?.({
-			cache: "hit",
-			endedAt: clock(),
-			path,
-			startedAt,
-			state: "completed"
-		});
-		return;
-	}
-	let handlerError;
-	let handlerSucceeded = false;
-	const cacheDiagnostics = cacheKey ? [] : void 0;
-	const cacheUsage = cacheKey ? [] : void 0;
-	try {
-		await execution.runtime.executionState.run({
-			activeFilePath: path.file.path,
-			cacheDiagnostics,
-			cacheUsage,
-			progressPath: path
-		}, execution.run);
-		handlerSucceeded = true;
-	} catch (error) {
-		handlerError = error;
-	}
-	if (handlerSucceeded) {
-		if (cacheKey && cacheContext.enabled && execution.runtime.cacheable) {
-			cacheContext.store.set(cacheKey, {
-				diagnostics: cacheDiagnostics ?? [],
-				filePath: normalizeCachePath(cacheContext.cwd, path.file.path),
-				fingerprint: {
-					alintVersion: version,
-					configHash: target.configHash,
-					modelHash: cacheContext.modelHash,
-					ruleHash: execution.runtime.ruleHash
-				},
-				target: {
-					hash: createTargetHash(target),
-					identity: target.identity,
-					kind: target.kind,
-					loc: target.loc,
-					name: target.name,
-					range: target.range
-				},
-				usage: cacheUsage ?? []
-			});
-			rememberFileCacheEntry(cacheContext, path.file.path, cacheKey);
-		}
-		counters.complete();
-		options.progress?.onRuleEnd?.({
-			cache: "miss",
-			endedAt: clock(),
-			path,
-			startedAt,
-			state: "completed"
-		});
-		return;
-	}
-	counters.error();
-	try {
-		options.progress?.onRuleEnd?.({
-			cache: "miss",
-			endedAt: clock(),
-			path,
-			startedAt,
-			state: "errored"
-		});
-	} catch {}
-	throw new AlintRuleExecutionError(handlerError, path);
-}
 function mergeCapabilities(base, extra) {
 	if (!base && !extra) return;
 	return [.../* @__PURE__ */ new Set([...base ?? [], ...extra ?? []])];
@@ -1493,31 +1786,6 @@ async function reconcileCache(filePlans, cacheContext) {
 		await cacheContext.store.reconcile();
 	} catch {}
 }
-function rememberFileCacheEntry(cacheContext, filePath, cacheKey) {
-	const normalizedPath = normalizeCachePath(cacheContext.cwd, filePath);
-	const entries = cacheContext.fileEntryKeys.get(normalizedPath) ?? /* @__PURE__ */ new Set();
-	entries.add(cacheKey);
-	cacheContext.fileEntryKeys.set(normalizedPath, entries);
-}
-function replayCachedEntry(entry, path, diagnostics, usage, options) {
-	for (const cachedDiagnostic of entry.diagnostics) {
-		const diagnostic = { ...cachedDiagnostic };
-		diagnostics.push(diagnostic);
-		options.progress?.onDiagnostic?.({
-			diagnostic,
-			diagnostics: [...diagnostics],
-			path
-		});
-	}
-	for (const cachedUsage of entry.usage) {
-		const record = usage.record({ ...cachedUsage });
-		options.progress?.onUsage?.({
-			path,
-			record,
-			total: usage.toJSON()
-		});
-	}
-}
 function resolveFileConcurrency(fileConcurrency) {
 	return fileConcurrency ?? 1;
 }
@@ -1551,20 +1819,11 @@ function toDiagnosticModel(model, request) {
 function toProgressFilePath(filePlan, filesTotal) {
 	return {
 		index: filePlan.fileIndex,
-		path: filePlan.preparedFile.file.path,
+		path: filePlan.path,
 		planned: filePlan.planned,
 		total: filesTotal
 	};
 }
-function toTargetIdentityInput(cwd, filePath, target) {
-	return {
-		filePath: target.kind === "file" ? normalizeCachePath(cwd, filePath) : void 0,
-		identity: target.identity,
-		kind: target.kind,
-		name: target.name,
-		range: target.range
-	};
-}
 //#endregion
 //#region src/dsl/define.ts
 function defineConfig(config) {
@@ -1577,4 +1836,4 @@ function defineRule(rule) {
 	return rule;
 }
 //#endregion
-export { AlintRunError, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, extractJsSourceTargets, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForFile, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange };
+export { AlintRunError, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, extractJsSourceTargets, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange };