@alint-js/core 0.0.4

package/dist/index.mjs

@@ -0,0 +1,1210 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import process, { cwd } from "node:process";
+import { errorCauseFrom, errorMessageFrom } from "@moeru/std/error";
+import { resolve } from "pathe";
+import { createHash, randomUUID } from "node:crypto";
+import { statSync } from "node:fs";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, extname, isAbsolute, join, relative, resolve as resolve$1, sep } from "node:path";
+import { array, check, description, is, literal, number, object, optional, pipe, record, string, union, unknown } from "valibot";
+import { parseSync } from "oxc-parser";
+import { clamp } from "es-toolkit";
+//#region package.json
+var version = "0.0.4";
+//#endregion
+//#region src/dsl/registry.ts
+function buildRuleRegistry(config) {
+	const rules = /* @__PURE__ */ new Map();
+	const enabledRules = [];
+	for (const plugin of config.plugins ?? []) for (const [localId, rule] of Object.entries(plugin.rules)) {
+		const id = `${plugin.scope}/${localId}`;
+		if (rules.has(id)) throw new Error(`Duplicate rule id "${id}".`);
+		rules.set(id, rule);
+		const severity = normalizeSeverity(config.rules?.[id]);
+		if (severity !== "off") enabledRules.push({
+			id,
+			localId,
+			rule,
+			scope: plugin.scope,
+			severity
+		});
+	}
+	for (const id of Object.keys(config.rules ?? {})) if (!rules.has(id)) throw new Error(`Unknown rule "${id}".`);
+	return {
+		enabledRules,
+		rules
+	};
+}
+function normalizeSeverity(entry) {
+	if (Array.isArray(entry)) return entry[0] ?? "warn";
+	return entry ?? "warn";
+}
+//#endregion
+//#region src/models/resolve.ts
+function resolveModel(registry, options = {}) {
+	const candidates = flattenModels(registry);
+	const ruleId = options.ruleId ?? "<unknown>";
+	if (options.request !== void 0) {
+		const request = options.request;
+		const candidate = candidates.find(({ model }) => matchesRequest(model, request));
+		if (candidate === void 0) throw new Error(`Unknown model "${request}".`);
+		if (!satisfiesHardRequirements(candidate.model, options.requirement)) throw new Error(`Model "${request}" does not satisfy requirement for rule "${ruleId}".`);
+		return toResolvedModel(candidate, options.requirement);
+	}
+	const candidate = preferSize(candidates.filter(({ model }) => satisfiesHardRequirements(model, options.requirement)), options.requirement);
+	if (candidate === void 0) throw new Error(`No model satisfies requirement for rule "${ruleId}".`);
+	return toResolvedModel(candidate, options.requirement);
+}
+function flattenModels(registry) {
+	return registry.providers.flatMap((provider) => provider.models.map((model) => ({
+		model,
+		provider
+	})));
+}
+function matchesRequest(model, request) {
+	return model.id === request || model.name === request || (model.aliases ?? []).includes(request);
+}
+function preferSize(candidates, requirement) {
+	if (requirement?.size === void 0) return candidates[0];
+	return candidates.find(({ model }) => model.size === requirement.size) ?? candidates[0];
+}
+function satisfiesHardRequirements(model, requirement) {
+	if (requirement === void 0) return true;
+	if (requirement.capabilities !== void 0 && !requirement.capabilities.every((capability) => (model.capabilities ?? []).includes(capability))) return false;
+	if (requirement.minContextWindow !== void 0 && (model.contextWindow === void 0 || model.contextWindow < requirement.minContextWindow)) return false;
+	return true;
+}
+function toResolvedModel(candidate, requirement) {
+	const { model, provider } = candidate;
+	return {
+		aliases: [...model.aliases ?? []],
+		capabilities: [...model.capabilities ?? []],
+		contextWindow: model.contextWindow,
+		id: model.id,
+		name: model.name ?? model.id,
+		params: {
+			...model.defaultParams ?? {},
+			...requirement?.params ?? {}
+		},
+		provider: {
+			endpoint: provider.endpoint,
+			headers: { ...provider.headers ?? {} },
+			id: provider.id,
+			type: provider.type
+		},
+		size: model.size
+	};
+}
+//#endregion
+//#region src/core/cache.ts
+const CACHE_SCHEMA_VERSION = 1;
+const DEFAULT_CACHE_FILE_NAME = ".alintcache";
+const CacheFileSchema = pipe(object({
+	createdAt: pipe(string(), description("Cache file creation timestamp.")),
+	entries: pipe(unknown(), check((value) => typeof value === "object" && value !== null && !Array.isArray(value)), record(string(), object({
+		diagnostics: pipe(array(object({
+			filePath: pipe(string(), description("Diagnostic file path.")),
+			message: pipe(string(), description("Diagnostic message.")),
+			ruleId: pipe(string(), description("Diagnostic rule id.")),
+			severity: pipe(union([literal("error"), literal("warn")]), description("Diagnostic severity."))
+		})), description("Diagnostics produced for the cached target.")),
+		filePath: pipe(string(), description("Cache entry file path.")),
+		fingerprint: pipe(object({
+			alintVersion: pipe(string(), description("Alint version used to create the cache entry.")),
+			configHash: pipe(string(), description("Runner config hash used to create the cache entry.")),
+			modelHash: pipe(string(), description("Model configuration hash used to create the cache entry.")),
+			ruleHash: pipe(string(), description("Rule configuration hash used to create the cache entry."))
+		}), description("Cache entry fingerprint.")),
+		target: pipe(object({
+			hash: pipe(string(), description("Cached target hash.")),
+			identity: pipe(string(), description("Stable cached target identity.")),
+			kind: pipe(union([
+				literal("file"),
+				literal("class"),
+				literal("function")
+			]), description("Cached target kind."))
+		}), description("Cached target metadata.")),
+		usage: pipe(array(object({
+			inputTokens: pipe(optional(number()), description("Optional input token count.")),
+			modelId: pipe(string(), description("Usage model id.")),
+			outputTokens: pipe(optional(number()), description("Optional output token count.")),
+			providerId: pipe(string(), description("Usage provider id.")),
+			ruleId: pipe(string(), description("Usage rule id.")),
+			totalTokens: pipe(optional(number()), description("Optional total token count."))
+		})), description("Inference usage records for the cache entry."))
+	})), description("Cache entries keyed by cache key.")),
+	files: pipe(unknown(), check((value) => typeof value === "object" && value !== null && !Array.isArray(value)), record(string(), object({
+		contentHash: pipe(string(), description("Cached file content hash.")),
+		entries: pipe(array(string()), description("Cache entry keys associated with the file.")),
+		path: pipe(string(), description("Normalized cached file path."))
+	})), description("Cached files keyed by normalized file path.")),
+	schemaVersion: pipe(literal(CACHE_SCHEMA_VERSION), description("Cache schema version.")),
+	updatedAt: pipe(string(), description("Cache file update timestamp."))
+}), description("Alint cache file."));
+function createCacheKey(input) {
+	return stableHash(input);
+}
+async function createCacheStore(options) {
+	const location = resolveCacheLocation(options.cwd, options.location);
+	if (!options.enabled) return createNoopCacheStore(location);
+	const cacheFile = await readCacheFile(location);
+	return {
+		get: (key) => cacheFile.entries[key],
+		location,
+		markFile: (filePath, contentHash, entries) => {
+			const path = normalizeCachePath(options.cwd, filePath);
+			cacheFile.files[path] = {
+				contentHash,
+				entries,
+				path
+			};
+		},
+		reconcile: async () => {
+			await mkdir(dirname(location), { recursive: true });
+			cacheFile.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+			const tempPath = join(dirname(location), `.${DEFAULT_CACHE_FILE_NAME}.${process.pid}.${randomUUID()}.tmp`);
+			await writeFile(tempPath, `${JSON.stringify(cacheFile, null, 2)}\n`);
+			await rename(tempPath, location);
+		},
+		set: (key, entry) => {
+			cacheFile.entries[key] = entry;
+		}
+	};
+}
+function createTargetIdentityResolver(targets) {
+	const baseCounts = /* @__PURE__ */ new Map();
+	for (const target of targets) {
+		const base = createBaseTargetIdentity(target);
+		baseCounts.set(base, (baseCounts.get(base) ?? 0) + 1);
+	}
+	return (target) => {
+		const base = createBaseTargetIdentity(target);
+		if ((baseCounts.get(base) ?? 0) <= 1) return base;
+		if (target.range) return `${base}:${target.range.start}:${target.range.end}`;
+		return base;
+	};
+}
+function hashText(text) {
+	return createHash("sha256").update(text).digest("hex");
+}
+function normalizeCachePath(cwd, filePath) {
+	return relative(cwd, isAbsolute(filePath) ? resolve$1(filePath) : resolve$1(cwd, filePath)).split(sep).join("/");
+}
+function normalizeRunnerCacheConfig(cache, cwd) {
+	if (cache === false) return {
+		enabled: false,
+		location: resolveCacheLocation(cwd)
+	};
+	if (cache === true || cache === void 0) return {
+		enabled: true,
+		location: resolveCacheLocation(cwd)
+	};
+	return {
+		enabled: cache.enabled ?? true,
+		location: resolveCacheLocation(cwd, cache.location)
+	};
+}
+function resolveCacheLocation(cwd, location) {
+	if (!location) return join(cwd, DEFAULT_CACHE_FILE_NAME);
+	const resolved = isAbsolute(location) ? resolve$1(location) : resolve$1(cwd, location);
+	if (location.endsWith("/") || location.endsWith("\\")) return join(resolved, DEFAULT_CACHE_FILE_NAME);
+	try {
+		if (statSyncIsDirectory(resolved)) return join(resolved, DEFAULT_CACHE_FILE_NAME);
+	} catch {}
+	return resolved;
+}
+function stableHash(value) {
+	return hashText(stableStringify(value));
+}
+function createBaseTargetIdentity(target) {
+	if (target.kind === "file") return target.filePath ? `file:${target.filePath}` : "file";
+	if (target.name) return `${target.kind}:${target.name}`;
+	if (target.range) return `${target.kind}:${target.range.start}:${target.range.end}`;
+	return target.kind;
+}
+function createEmptyCacheFile() {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		createdAt: now,
+		entries: {},
+		files: {},
+		schemaVersion: CACHE_SCHEMA_VERSION,
+		updatedAt: now
+	};
+}
+function createNoopCacheStore(location) {
+	return {
+		get: () => void 0,
+		location,
+		markFile: () => {},
+		reconcile: async () => {},
+		set: () => {}
+	};
+}
+function isCacheFile(value) {
+	return is(CacheFileSchema, value);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readCacheFile(location) {
+	try {
+		const parsed = JSON.parse(await readFile(location, "utf8"));
+		if (isCacheFile(parsed)) return parsed;
+	} catch {}
+	return createEmptyCacheFile();
+}
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+	if (isRecord(value)) return `{${Object.keys(value).sort().map((key) => {
+		const property = value[key];
+		if (property === void 0) return;
+		return `${JSON.stringify(key)}:${stableStringify(property)}`;
+	}).filter((entry) => entry !== void 0).join(",")}}`;
+	return JSON.stringify(value);
+}
+function statSyncIsDirectory(path) {
+	return statSync(path).isDirectory();
+}
+//#endregion
+//#region src/core/source/runtime.ts
+function createSourceFile(path, text) {
+	return {
+		language: inferLanguage(path),
+		lines: text.split(/\r?\n/),
+		path,
+		text
+	};
+}
+function createSourceRuntime() {
+	return {
+		getText: (target) => target.text,
+		readFile: async (filePath) => createSourceFile(filePath, await readFile(filePath, "utf8")),
+		sliceLines,
+		sliceRange
+	};
+}
+function sliceLines(file, range) {
+	const startLine = clampLine(range.startLine, file.lines.length);
+	const endLine = clampLine(range.endLine, file.lines.length);
+	const orderedStartLine = Math.min(startLine, endLine);
+	const orderedEndLine = Math.max(startLine, endLine);
+	const text = file.lines.slice(orderedStartLine - 1, orderedEndLine).join("\n");
+	return {
+		filePath: file.path,
+		loc: {
+			end: {
+				column: file.lines[orderedEndLine - 1]?.length ?? 0,
+				line: orderedEndLine
+			},
+			start: {
+				column: 0,
+				line: orderedStartLine
+			}
+		},
+		text
+	};
+}
+function sliceRange(file, range) {
+	const start = clampOffset(range.start, file.text.length);
+	const end = clampOffset(range.end, file.text.length);
+	const orderedStart = Math.min(start, end);
+	const orderedEnd = Math.max(start, end);
+	return {
+		filePath: file.path,
+		loc: {
+			end: getPosition(file.text, orderedEnd),
+			start: getPosition(file.text, orderedStart)
+		},
+		text: file.text.slice(orderedStart, orderedEnd)
+	};
+}
+function clampLine(line, lineCount) {
+	if (lineCount === 0) return 1;
+	return clamp(Math.trunc(line), 1, lineCount);
+}
+function clampOffset(offset, textLength) {
+	return clamp(Math.trunc(offset), 0, textLength);
+}
+function getPosition(text, offset) {
+	let line = 1;
+	let column = 0;
+	let index = 0;
+	while (index < offset) {
+		const character = text[index];
+		if (character === "\r") {
+			if (text[index + 1] === "\n" && index + 1 < offset) index += 1;
+			line += 1;
+			column = 0;
+		} else if (character === "\n") {
+			line += 1;
+			column = 0;
+		} else column += 1;
+		index += 1;
+	}
+	return {
+		column,
+		line
+	};
+}
+function inferLanguage(path) {
+	switch (extname(path)) {
+		case ".cjs":
+		case ".js":
+		case ".jsx":
+		case ".mjs": return "javascript";
+		case ".cts":
+		case ".mts":
+		case ".ts":
+		case ".tsx": return "typescript";
+		default: return "unknown";
+	}
+}
+//#endregion
+//#region src/core/source/js.ts
+function extractJsSourceUnits(file) {
+	const result = parseSync(file.path, file.text, { sourceType: "module" });
+	const state = {
+		bindingNodes: /* @__PURE__ */ new Map(),
+		classes: [],
+		exportedNodes: /* @__PURE__ */ new Set(),
+		file,
+		functions: [],
+		inferredNames: /* @__PURE__ */ new Map(),
+		seenClasses: /* @__PURE__ */ new Set(),
+		seenFunctions: /* @__PURE__ */ new Set(),
+		visited: /* @__PURE__ */ new Set()
+	};
+	collectModuleBindings(result.program, state);
+	collectExportedBindings(result.program, state);
+	visit(result.program, state);
+	return {
+		classes: state.classes,
+		functions: state.functions
+	};
+}
+function addClassUnit(node, state) {
+	if (state.seenClasses.has(node)) return;
+	const unit = createClassUnit(node, state);
+	if (!unit) return;
+	state.seenClasses.add(node);
+	state.classes.push(unit);
+}
+function addFunctionUnit(node, state) {
+	if (state.seenFunctions.has(node)) return;
+	const unit = createFunctionUnit(node, state);
+	if (!unit) return;
+	state.seenFunctions.add(node);
+	state.functions.push(unit);
+}
+function asAstNode(value) {
+	return isAstNode(value) ? value : void 0;
+}
+function collectDeclarationBindings(node, state) {
+	const name = getNodeName(node);
+	if (name && (isClassNode(node) || isFunctionNode(node))) {
+		state.bindingNodes.set(name, node);
+		return;
+	}
+	if (node.type !== "VariableDeclaration" || !Array.isArray(node.declarations)) return;
+	for (const declarator of node.declarations) {
+		if (!isAstNode(declarator)) continue;
+		const id = asAstNode(declarator.id);
+		const initializer = asAstNode(declarator.init);
+		if (typeof id?.name === "string" && initializer && (isClassNode(initializer) || isFunctionNode(initializer))) state.bindingNodes.set(id.name, initializer);
+	}
+}
+function collectExportedBindings(node, state) {
+	if (!node) return;
+	if (Array.isArray(node)) {
+		for (const child of node) collectExportedBindings(child, state);
+		return;
+	}
+	if (node.type === "ExportNamedDeclaration" && !node.source && Array.isArray(node.specifiers)) for (const specifier of node.specifiers) {
+		if (!isAstNode(specifier) || specifier.type !== "ExportSpecifier") continue;
+		const local = asAstNode(specifier.local);
+		if (typeof local?.name === "string") markExportedBinding(local.name, state);
+	}
+	else if (node.type === "ExportDefaultDeclaration") {
+		const declaration = asAstNode(node.declaration);
+		if (typeof declaration?.name === "string") markExportedBinding(declaration.name, state);
+	}
+	for (const value of Object.values(node)) if (Array.isArray(value)) collectExportedBindings(value.filter(isAstNode), state);
+	else if (isAstNode(value)) collectExportedBindings(value, state);
+}
+function collectModuleBindings(program, state) {
+	if (!Array.isArray(program.body)) return;
+	for (const statement of program.body) {
+		if (!isAstNode(statement)) continue;
+		const declaration = isExportDeclaration(statement) ? asAstNode(statement.declaration) : statement;
+		if (declaration) collectDeclarationBindings(declaration, state);
+	}
+}
+function createClassUnit(node, state) {
+	const range = getRange(node);
+	if (!range) return;
+	const source = sliceRange(state.file, range);
+	return {
+		exported: isExportedUnit(node, state),
+		file: state.file,
+		kind: "class",
+		loc: source.loc,
+		name: getNodeName(node) ?? state.inferredNames.get(node),
+		range,
+		text: source.text
+	};
+}
+function createFunctionUnit(node, state) {
+	const range = getRange(node);
+	if (!range) return;
+	const source = sliceRange(state.file, range);
+	const functionNode = node.type === "MethodDefinition" ? asAstNode(node.value) : node;
+	return {
+		async: functionNode?.async === true,
+		exported: isExportedUnit(node, state),
+		file: state.file,
+		kind: "function",
+		loc: source.loc,
+		name: getNodeName(node) ?? getNodeName(functionNode) ?? state.inferredNames.get(node),
+		range,
+		text: source.text
+	};
+}
+function getNodeName(node) {
+	if (!node) return;
+	if (typeof node.name === "string") return node.name;
+	const id = asAstNode(node.id);
+	if (typeof id?.name === "string") return id.name;
+	const key = asAstNode(node.key);
+	if (typeof key?.name === "string") return key.name;
+	if (typeof key?.value === "string" || typeof key?.value === "number") return String(key.value);
+}
+function getRange(node) {
+	if (typeof node.start === "number" && typeof node.end === "number") return {
+		end: node.end,
+		start: node.start
+	};
+	if (Array.isArray(node.range) && node.range.length === 2) return {
+		end: node.range[1],
+		start: node.range[0]
+	};
+}
+function inferChildName(parent, key, child, state) {
+	if (state.inferredNames.has(child)) return;
+	if (parent.type === "VariableDeclarator" && key === "init") {
+		const id = asAstNode(parent.id);
+		if (typeof id?.name === "string") state.inferredNames.set(child, id.name);
+	}
+	if (parent.type === "Property" && key === "value") {
+		const name = getNodeName(parent);
+		if (name) state.inferredNames.set(child, name);
+	}
+}
+function isAstNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function isClassNode(node) {
+	return node.type === "ClassDeclaration" || node.type === "ClassExpression";
+}
+function isExportDeclaration(node) {
+	return node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration";
+}
+function isExportedUnit(node, state) {
+	return state.exportedNodes.has(node);
+}
+function isFunctionNode(node) {
+	return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
+}
+function markExportedBinding(name, state) {
+	const bindingNode = state.bindingNodes.get(name);
+	if (bindingNode) state.exportedNodes.add(bindingNode);
+}
+function markExportedDeclaration(node, state) {
+	state.exportedNodes.add(node);
+	if (node.type !== "VariableDeclaration" || !Array.isArray(node.declarations)) return;
+	for (const declarator of node.declarations) {
+		if (!isAstNode(declarator)) continue;
+		const initializer = asAstNode(declarator.init);
+		if (initializer && (isClassNode(initializer) || isFunctionNode(initializer))) state.exportedNodes.add(initializer);
+	}
+}
+function visit(node, state) {
+	if (!node) return;
+	if (Array.isArray(node)) {
+		for (const child of node) visit(child, state);
+		return;
+	}
+	if (state.visited.has(node)) return;
+	state.visited.add(node);
+	if (node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration") {
+		if (node.declaration) {
+			markExportedDeclaration(node.declaration, state);
+			visit(node.declaration, state);
+		}
+		visitChildren(node, state, /* @__PURE__ */ new Set(["declaration"]));
+		return;
+	}
+	if (isClassNode(node)) addClassUnit(node, state);
+	else if (isFunctionNode(node) || node.type === "MethodDefinition") {
+		addFunctionUnit(node, state);
+		const methodValue = node.type === "MethodDefinition" ? asAstNode(node.value) : void 0;
+		if (methodValue) state.seenFunctions.add(methodValue);
+	}
+	visitChildren(node, state);
+}
+function visitChildren(node, state, skippedKeys = /* @__PURE__ */ new Set()) {
+	for (const [key, value] of Object.entries(node)) {
+		if (skippedKeys.has(key) || key === "type" || key === "start" || key === "end" || key === "range") continue;
+		if (Array.isArray(value)) {
+			for (const child of value) if (isAstNode(child)) {
+				inferChildName(node, key, child, state);
+				visit(child, state);
+			}
+		} else if (isAstNode(value)) {
+			inferChildName(node, key, value, state);
+			visit(value, state);
+		}
+	}
+}
+//#endregion
+//#region src/core/run.ts
+var AlintRuleExecutionError = class extends Error {
+	failure;
+	constructor(error, path) {
+		const message = errorMessageFrom(error) ?? String(error);
+		super(message, { cause: error });
+		this.name = "AlintRuleExecutionError";
+		this.failure = {
+			filePath: path.file.path,
+			message,
+			ruleId: path.rule.id,
+			target: {
+				kind: path.target.kind,
+				name: path.target.name
+			}
+		};
+	}
+};
+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 registry = buildRuleRegistry(config);
+	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 = {
+		configHash: stableHash({ rules: config.rules ?? {} }),
+		cwd: cwd$1,
+		enabled: normalizedCacheConfig.enabled,
+		fileEntryKeys: /* @__PURE__ */ new Map(),
+		modelHash: stableHash({
+			modelOverride: options.modelOverride,
+			setupConfig
+		}),
+		store: cacheStore
+	};
+	const files = await Promise.all((options.files ?? []).map(async (filePath) => {
+		const file = await src.readFile(resolve(cwd$1, filePath));
+		return {
+			file,
+			units: file.language === "javascript" || file.language === "typescript" ? extractJsSourceUnits(file) : void 0
+		};
+	}));
+	let planned = 0;
+	const counters = createRuleEndCounters();
+	const primaryError = createPrimaryErrorState();
+	let filePlans = [];
+	let runStartedAt;
+	let runError;
+	try {
+		filePlans = createPreparedFileExecutionPlans(registry.enabledRules.map((enabledRule) => {
+			const executionState = new AsyncLocalStorage();
+			const context = {
+				cwd: cwd$1,
+				id: enabledRule.id,
+				localId: enabledRule.localId,
+				logger: { debug: () => {} },
+				metering: { recordUsage: (record) => {
+					const usageRecord = usage.record({
+						...record,
+						ruleId: record.ruleId ?? enabledRule.id
+					});
+					const state = executionState.getStore();
+					state?.cacheUsage?.push(usageRecord);
+					options.progress?.onUsage?.({
+						path: state?.progressPath,
+						record: usageRecord,
+						total: usage.toJSON()
+					});
+				} },
+				model: async (selector) => {
+					const request = options.modelOverride ?? (typeof selector === "string" ? selector : void 0);
+					const resolvedModel = resolveModel(setupConfig, {
+						request,
+						requirement: mergeModelRequirement(enabledRule.rule.model, typeof selector === "string" ? void 0 : selector),
+						ruleId: enabledRule.id
+					});
+					const state = executionState.getStore();
+					if (state) state.currentModel = toDiagnosticModel(resolvedModel, request);
+					return resolvedModel;
+				},
+				report: (descriptor) => {
+					const state = executionState.getStore();
+					const filePath = descriptor.filePath ?? state?.activeFilePath;
+					if (!filePath) throw new Error(`Diagnostic for rule "${enabledRule.id}" is missing filePath.`);
+					const diagnosticModel = state?.currentModel ? { ...state.currentModel } : void 0;
+					if (state) state.currentModel = void 0;
+					const diagnostic = {
+						evidence: descriptor.evidence,
+						filePath,
+						loc: descriptor.loc,
+						message: descriptor.message,
+						model: diagnosticModel,
+						ruleId: enabledRule.id,
+						severity: enabledRule.severity
+					};
+					diagnostics.push(diagnostic);
+					state?.cacheDiagnostics?.push(diagnostic);
+					options.progress?.onDiagnostic?.({
+						diagnostic,
+						diagnostics: [...diagnostics],
+						path: state?.progressPath
+					});
+				},
+				scope: enabledRule.scope,
+				src
+			};
+			return {
+				cacheable: enabledRule.rule.cache !== false,
+				enabledRule,
+				executionState,
+				handlers: enabledRule.rule.create(context),
+				ruleHash: stableHash({
+					cache: enabledRule.rule.cache ?? true,
+					create: String(enabledRule.rule.create),
+					id: enabledRule.id,
+					localId: enabledRule.localId,
+					model: enabledRule.rule.model,
+					scope: enabledRule.scope,
+					severity: enabledRule.severity
+				})
+			};
+		}), files, cwd$1);
+		planned = calculatePlannedExecutions(filePlans);
+		runStartedAt = clock();
+		options.progress?.onRunStart?.({
+			files: filePlans.map((filePlan) => toProgressFilePath(filePlan, files.length)),
+			filesTotal: files.length,
+			planned,
+			rulesTotal: registry.enabledRules.length,
+			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(ruleRuntimes, preparedFile) {
+	const targets = [];
+	const fileExecutions = ruleRuntimes.map((runtime) => {
+		if (!runtime.handlers.onFile) return void 0;
+		return {
+			run: () => runtime.handlers.onFile?.(preparedFile.file),
+			runtime
+		};
+	}).filter((execution) => execution !== void 0);
+	if (fileExecutions.length > 0) targets.push({
+		executions: fileExecutions,
+		identity: "",
+		kind: "file",
+		text: preparedFile.file.text
+	});
+	if (preparedFile.units) {
+		for (const classNode of preparedFile.units.classes) {
+			const executions = ruleRuntimes.map((runtime) => {
+				if (!runtime.handlers.onClass) return void 0;
+				return {
+					run: () => runtime.handlers.onClass?.(classNode),
+					runtime
+				};
+			}).filter((execution) => execution !== void 0);
+			if (executions.length > 0) targets.push({
+				executions,
+				identity: "",
+				kind: "class",
+				loc: classNode.loc,
+				name: classNode.name,
+				range: classNode.range,
+				text: classNode.text
+			});
+		}
+		for (const functionNode of preparedFile.units.functions) {
+			const executions = ruleRuntimes.map((runtime) => {
+				if (!runtime.handlers.onFunction) return void 0;
+				return {
+					run: () => runtime.handlers.onFunction?.(functionNode),
+					runtime
+				};
+			}).filter((execution) => execution !== void 0);
+			if (executions.length > 0) targets.push({
+				executions,
+				identity: "",
+				kind: "function",
+				loc: functionNode.loc,
+				name: functionNode.name,
+				range: functionNode.range,
+				text: functionNode.text
+			});
+		}
+	}
+	return targets;
+}
+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 createExecutionCacheKey(runtime, target, path, cacheContext) {
+	if (!cacheContext.enabled || !runtime.cacheable) return;
+	return createCacheKey({
+		alintVersion: version,
+		configHash: cacheContext.configHash,
+		filePath: normalizeCachePath(cacheContext.cwd, path.file.path),
+		modelHash: cacheContext.modelHash,
+		ruleHash: runtime.ruleHash,
+		schemaVersion: 1,
+		targetHash: hashText(target.text),
+		targetIdentity: target.identity,
+		targetKind: target.kind
+	});
+}
+function createPreparedFileExecutionPlans(ruleRuntimes, files, cwd) {
+	return files.map((preparedFile, fileOffset) => {
+		const targets = collectExecutionTargets(ruleRuntimes, 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: {
+			index: entry.fileIndex,
+			path: filePath,
+			planned: entry.filePlanned,
+			total: entry.fileTotal
+		},
+		rule: {
+			id: ruleId,
+			index: entry.ruleIndex,
+			total: entry.ruleTotal
+		},
+		target: {
+			index: entry.targetIndex,
+			kind: entry.targetKind,
+			name: entry.targetName,
+			total: entry.targetTotal
+		}
+	};
+}
+function createRuleEndCounters() {
+	let cached = 0;
+	let completed = 0;
+	let errored = 0;
+	return {
+		cache() {
+			cached += 1;
+		},
+		complete() {
+			completed += 1;
+		},
+		error() {
+			errored += 1;
+		},
+		snapshot(planned) {
+			return {
+				cached,
+				completed,
+				errored,
+				planned
+			};
+		}
+	};
+}
+function createUsageAccumulator() {
+	const records = [];
+	let inputTokens = 0;
+	let outputTokens = 0;
+	let totalTokens = 0;
+	return {
+		record(record) {
+			records.push(record);
+			inputTokens = addTokenCount(inputTokens, record.inputTokens);
+			outputTokens = addTokenCount(outputTokens, record.outputTokens);
+			totalTokens = addTokenCount(totalTokens, record.totalTokens);
+			return record;
+		},
+		toJSON() {
+			return {
+				inputTokens,
+				outputTokens,
+				records,
+				totalTokens
+			};
+		}
+	};
+}
+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: cacheContext.configHash,
+					modelHash: cacheContext.modelHash,
+					ruleHash: execution.runtime.ruleHash
+				},
+				target: {
+					hash: hashText(target.text),
+					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 ?? []])];
+}
+function mergeMinContextWindow(base, extra) {
+	if (base === void 0) return extra;
+	if (extra === void 0) return base;
+	return Math.max(base, extra);
+}
+function mergeModelRequirement(base, extra) {
+	if (!base && !extra) return;
+	const capabilities = mergeCapabilities(base?.capabilities, extra?.capabilities);
+	const params = {
+		...base?.params ?? {},
+		...extra?.params ?? {}
+	};
+	return {
+		capabilities,
+		minContextWindow: mergeMinContextWindow(base?.minContextWindow, extra?.minContextWindow),
+		params: Object.keys(params).length > 0 ? params : void 0,
+		size: extra?.size ?? base?.size
+	};
+}
+async function reconcileCache(filePlans, cacheContext) {
+	try {
+		for (const filePlan of filePlans) {
+			const file = filePlan.preparedFile.file;
+			const normalizedPath = normalizeCachePath(cacheContext.cwd, file.path);
+			const entries = [...cacheContext.fileEntryKeys.get(normalizedPath) ?? []];
+			cacheContext.store.markFile(file.path, hashText(file.text), entries);
+		}
+		await cacheContext.store.reconcile();
+	} catch {}
+}
+function 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;
+}
+async function runConcurrently(items, concurrency, runItem) {
+	let firstError;
+	let nextIndex = 0;
+	const workerCount = Math.min(Math.max(concurrency, 1), items.length);
+	async function runWorker() {
+		while (firstError === void 0) {
+			const currentIndex = nextIndex;
+			nextIndex += 1;
+			if (currentIndex >= items.length) return;
+			try {
+				await runItem(items[currentIndex]);
+			} catch (error) {
+				firstError ??= error;
+				return;
+			}
+		}
+	}
+	await Promise.all(Array.from({ length: workerCount }, () => runWorker()));
+	if (firstError !== void 0) throw firstError;
+}
+function toDiagnosticModel(model, request) {
+	return {
+		providerId: model.provider.id,
+		requested: request,
+		resolvedId: model.id
+	};
+}
+function toProgressFilePath(filePlan, filesTotal) {
+	return {
+		index: filePlan.fileIndex,
+		path: filePlan.preparedFile.file.path,
+		planned: filePlan.planned,
+		total: filesTotal
+	};
+}
+function toTargetIdentityInput(cwd, filePath, target) {
+	return {
+		filePath: target.kind === "file" ? normalizeCachePath(cwd, filePath) : void 0,
+		kind: target.kind,
+		name: target.name,
+		range: target.range
+	};
+}
+//#endregion
+//#region src/dsl/define.ts
+function defineConfig(config) {
+	return config;
+}
+function definePlugin(plugin) {
+	return plugin;
+}
+function defineRule(rule) {
+	return rule;
+}
+//#endregion
+export { AlintRunError, buildRuleRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, extractJsSourceUnits, resolveModel, runAlint, sliceLines, sliceRange };