@alint-js/core 0.0.28 → 0.0.30

package/dist/{retry-C4sGjSE5.mjs → agent-weXkvGkc.mjs}

@@ -47,4 +47,23 @@ function withAgentRetry(adapter, retries = 2) {
 	};
 }
 //#endregion
-export { isRetryableAgentError as n, withAgentRetry as r, RetryableAgentError as t };
+//#region src/agent/index.ts
+function combineAbortSignals(...candidates) {
+	const signals = candidates.filter((signal) => signal !== void 0);
+	if (signals.length === 0) return void 0;
+	if (signals.length === 1) return signals[0];
+	return AbortSignal.any(signals);
+}
+function defineTool(tool) {
+	return tool;
+}
+function requireAgent(context) {
+	if (!context.agent) throw new TypeError(`Rule "${context.id}" requires an agent, but none is configured. Set "agent" in alint config (e.g. agent: createApeiraAdapter()).`);
+	const agent = context.agent;
+	return async (request) => agent({
+		...request,
+		signal: request.signal ?? context.signal
+	});
+}
+//#endregion
+export { isRetryableAgentError as a, RetryableAgentError as i, defineTool as n, withAgentRetry as o, requireAgent as r, combineAbortSignals as t };

package/dist/agent.d.mts

@@ -1,4 +1,4 @@
-import { J as AgentResult, K as AgentAdapter, X as AgentUsage, Y as AgentTool, q as AgentRequest, v as RuleContext } from "./types-BM_nUu_Z.mjs";
+import { A as AgentTool, D as AgentAdapter, O as AgentRequest, j as AgentUsage, k as AgentResult, v as RuleContext } from "./types-CR_Grd6q.mjs";
 //#region src/agent/retry.d.ts
 /**
  * Declares that the complete adapter invocation can be safely replayed.
@@ -10,7 +10,8 @@ declare class RetryableAgentError extends Error {
 declare function isRetryableAgentError(error: unknown): error is RetryableAgentError;
 //#endregion
 //#region src/agent/index.d.ts
+declare function combineAbortSignals(...candidates: Array<AbortSignal | undefined>): AbortSignal | undefined;
 declare function defineTool(tool: AgentTool): AgentTool;
 declare function requireAgent(context: Pick<RuleContext, 'agent' | 'id' | 'signal'>): AgentAdapter;
 //#endregion
-export { type AgentAdapter, type AgentRequest, type AgentResult, type AgentTool, type AgentUsage, RetryableAgentError, defineTool, isRetryableAgentError, requireAgent };
+export { type AgentAdapter, type AgentRequest, type AgentResult, type AgentTool, type AgentUsage, RetryableAgentError, combineAbortSignals, defineTool, isRetryableAgentError, requireAgent };

package/dist/agent.mjs

@@ -1,15 +1,2 @@
-import { n as isRetryableAgentError, t as RetryableAgentError } from "./retry-C4sGjSE5.mjs";
-//#region src/agent/index.ts
-function defineTool(tool) {
-	return tool;
-}
-function requireAgent(context) {
-	if (!context.agent) throw new TypeError(`Rule "${context.id}" requires an agent, but none is configured. Set "agent" in alint config (e.g. agent: createApeiraAdapter()).`);
-	const agent = context.agent;
-	return async (request) => agent({
-		...request,
-		signal: request.signal ?? context.signal
-	});
-}
-//#endregion
-export { RetryableAgentError, defineTool, isRetryableAgentError, requireAgent };
+import { a as isRetryableAgentError, i as RetryableAgentError, n as defineTool, r as requireAgent, t as combineAbortSignals } from "./agent-weXkvGkc.mjs";
+export { RetryableAgentError, combineAbortSignals, defineTool, isRetryableAgentError, requireAgent };

package/dist/extract-CIWssxNK.mjs

@@ -0,0 +1,358 @@
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { clamp } from "es-toolkit";
+import { parseSync } from "oxc-parser";
+//#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,
+		readFile: async (filePath) => createSourceFile(filePath, await readFile(filePath, "utf8")),
+		sliceLines,
+		sliceRange
+	};
+}
+function getText(target) {
+	return target.text;
+}
+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/languages/js/parser.ts
+function parseSync$1(filename, sourceText, options) {
+	return parseSync(filename, sourceText, options);
+}
+//#endregion
+//#region src/core/languages/js/extract.ts
+function extractJsSourceTargets(file) {
+	const result = parseSync$1(file.path, file.text, { sourceType: "module" });
+	const state = {
+		bindingNodes: /* @__PURE__ */ new Map(),
+		exportedNodes: /* @__PURE__ */ new Set(),
+		file,
+		inferredNames: /* @__PURE__ */ new Map(),
+		seenClasses: /* @__PURE__ */ new Set(),
+		seenFunctions: /* @__PURE__ */ new Set(),
+		targets: [],
+		visited: /* @__PURE__ */ new Set()
+	};
+	collectModuleBindings(result.program, state);
+	collectExportedBindings(result.program, state);
+	visit(result.program, state);
+	const sortedTargets = [...state.targets].sort((left, right) => (left.range?.start ?? 0) - (right.range?.start ?? 0));
+	return [createFileTarget(file), ...withStableIdentities(sortedTargets)];
+}
+function addClassTarget(node, state) {
+	if (state.seenClasses.has(node)) return;
+	const target = createClassTarget(node, state);
+	if (!target) return;
+	state.seenClasses.add(node);
+	state.targets.push(target);
+}
+function addFunctionTarget(node, state) {
+	if (state.seenFunctions.has(node)) return;
+	const target = createFunctionTarget(node, state);
+	if (!target) return;
+	state.seenFunctions.add(node);
+	state.targets.push(target);
+}
+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 createClassTarget(node, state) {
+	const range = getRange(node);
+	if (!range) return;
+	const source = sliceRange(state.file, range);
+	const name = getNodeName(node) ?? state.inferredNames.get(node);
+	return {
+		file: state.file,
+		identity: createRangeIdentity("class", name, range),
+		kind: "class",
+		language: state.file.language,
+		loc: source.loc,
+		metadata: { exported: isExportedTarget(node, state) },
+		name,
+		origin: {
+			physicalPath: state.file.path,
+			range
+		},
+		range,
+		text: source.text
+	};
+}
+function createFileTarget(file) {
+	return {
+		file,
+		identity: "file",
+		kind: "file",
+		language: file.language,
+		origin: { physicalPath: file.path },
+		text: file.text
+	};
+}
+function createFunctionTarget(node, state) {
+	const range = getRange(node);
+	if (!range) return;
+	const source = sliceRange(state.file, range);
+	const functionNode = node.type === "MethodDefinition" ? asAstNode(node.value) : node;
+	const name = getNodeName(node) ?? getNodeName(functionNode) ?? state.inferredNames.get(node);
+	return {
+		file: state.file,
+		identity: createRangeIdentity("function", name, range),
+		kind: "function",
+		language: state.file.language,
+		loc: source.loc,
+		metadata: {
+			async: functionNode?.async === true,
+			exported: isExportedTarget(node, state)
+		},
+		name,
+		origin: {
+			physicalPath: state.file.path,
+			range
+		},
+		range,
+		text: source.text
+	};
+}
+function createRangeIdentity(kind, name, range) {
+	return `${kind}:${name ?? "anonymous"}:${range.start}:${range.end}`;
+}
+function createSemanticIdentity(target) {
+	if (target.kind !== "class" && target.kind !== "function" || !target.name) return;
+	return `${target.kind}:${target.name}`;
+}
+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 isExportedTarget(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)) addClassTarget(node, state);
+	else if (isFunctionNode(node) || node.type === "MethodDefinition") {
+		addFunctionTarget(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);
+		}
+	}
+}
+function withStableIdentities(targets) {
+	const semanticIdentityCounts = /* @__PURE__ */ new Map();
+	for (const target of targets) {
+		const semanticIdentity = createSemanticIdentity(target);
+		if (semanticIdentity) semanticIdentityCounts.set(semanticIdentity, (semanticIdentityCounts.get(semanticIdentity) ?? 0) + 1);
+	}
+	return targets.map((target) => {
+		const semanticIdentity = createSemanticIdentity(target);
+		if (!semanticIdentity || semanticIdentityCounts.get(semanticIdentity) !== 1) return target;
+		return {
+			...target,
+			identity: semanticIdentity
+		};
+	});
+}
+//#endregion
+export { sliceRange as a, sliceLines as i, createSourceFile as n, createSourceRuntime as r, extractJsSourceTargets as t };

package/dist/index.d.mts

@@ -1,4 +1,5 @@
-import { $ as ResolvedModel, A as LanguageContext, B as SourceRuntime, C as RuleSeverity, D as ClassTarget, E as Target, F as ProcessorPostprocessContext, G as SourceText, H as SourceTargetKind, I as SourceFile, L as SourceLocation, M as ProcessedSource, N as ProcessedSourceOrigin, O as FileTarget, P as ProcessorContext, Q as ResolveModelOptions, R as SourcePosition, S as RuleRegistry, T as RuleWithHandler, U as SourceTargetOfKind, V as SourceTarget, W as SourceTargetOrigin, Z as ModelRequirement, _ as RuleConfigEntry, a as AlintLinterOptions, at as RunnerStatsConfig, b as RuleHandlers, c as DiagnosticLocation, d as IgnoreConfig, et as ResolvedProvider, f as LanguageDefinition, g as RuleCacheConfig, h as ProjectTarget, i as AlintConfigItem, it as RunnerConfig, j as LineRange, k as FunctionTarget, l as DirectoryTarget, m as ProcessorDefinition, n as AlintConfigExtends, nt as ProviderDefinition, o as Awaitable, ot as SetupConfig, p as PluginDefinition, r as AlintConfigInput, rt as ProviderType, s as DiagnosticDescriptor, st as SetupModelDefinition, t as AlintConfig, tt as ModelSize, u as EnabledRule, v as RuleContext, w as RuleSpecializedHandlers, x as RuleInferenceUsageRecord, y as RuleDefinition, z as SourceRange } from "./types-BM_nUu_Z.mjs";
+import { B as RunnerStatsConfig, C as RuleSeverity, E as Target, F as ResolvedProvider, H as SetupModelDefinition, I as ModelSize, L as ProviderDefinition, M as ModelRequirement, N as ResolveModelOptions, P as ResolvedModel, R as ProviderType, S as RuleRegistry, T as RuleWithHandler, V as SetupConfig, _ as RuleConfigEntry, a as AlintLinterOptions, b as RuleHandlers, c as DiagnosticLocation, d as IgnoreConfig, f as LanguageDefinition, g as RuleCacheConfig, h as ProjectTarget, i as AlintConfigItem, l as DirectoryTarget, m as ProcessorDefinition, n as AlintConfigExtends, o as Awaitable, p as PluginDefinition, r as AlintConfigInput, s as DiagnosticDescriptor, t as AlintConfig, u as EnabledRule, v as RuleContext, w as RuleSpecializedHandlers, x as RuleInferenceUsageRecord, y as RuleDefinition, z as RunnerConfig } from "./types-CR_Grd6q.mjs";
+import { _ as SourceTargetOfKind, a as LineRange, c as ProcessorContext, d as SourceLocation, f as SourcePosition, g as SourceTargetKind, h as SourceTarget, i as LanguageContext, l as ProcessorPostprocessContext, m as SourceRuntime, n as FileTarget, o as ProcessedSource, p as SourceRange, r as FunctionTarget, s as ProcessedSourceOrigin, t as ClassTarget, u as SourceFile, v as SourceTargetOrigin, y as SourceText } from "./types-DSvXUVZ7.mjs";
 //#region src/config/config-array.d.ts
 interface EffectiveAlintConfig {
   agent?: AlintConfigItem['agent'];
@@ -47,18 +48,11 @@ declare function resolveLanguage(file: SourceFile, registry: LanguageRegistry, o
 //#region src/core/languages/index.d.ts
 declare function createBuiltInLanguageRegistry(): LanguageRegistry;
 //#endregion
-//#region src/core/languages/js/extract.d.ts
-declare function extractJsSourceTargets(file: SourceFile): SourceTarget[];
-//#endregion
 //#region src/core/types.d.ts
 interface AlintRunFailure {
-  filePath?: string;
+  job: ProgressJob;
+  kind: 'cache-replay' | 'handler' | 'timeout';
   message: string;
-  ruleId?: string;
-  target?: {
-    kind: ProgressTargetKind;
-    name?: string;
-  };
 }
 interface Diagnostic {
   cached?: boolean;
@@ -76,96 +70,70 @@ interface Diagnostic {
 }
 interface DiagnosticProgressPayload {
   diagnostic: Diagnostic;
-  diagnostics: Diagnostic[];
-  path?: ProgressPath;
+  job: ProgressJob;
 }
-interface FileProgressPayload {
-  endedAt?: number;
-  file: ProgressFilePath;
-  startedAt?: number;
+interface ExecutionCounts {
+  cached: number;
+  cancelled: number;
+  completed: number;
+  failed: number;
+  planned: number;
+  queued: number;
+  running: number;
+  /** Rules left unexecuted because they missed the cache under {@link RunOptions.cacheOnly}. */
+  skipped: number;
 }
 type InferenceUsageRecord = Omit<RuleInferenceUsageRecord, 'ruleId'> & {
   ruleId: string;
 };
-interface ProgressFilePath {
-  index: number;
-  path: string;
-  planned?: number;
-  total: number;
+interface JobEndPayload extends JobStartPayload {
+  cache: 'hit' | 'miss';
+  endedAt?: number;
+  failure?: AlintRunFailure;
+  state: 'cached' | 'cancelled' | 'completed' | 'failed' | 'skipped';
 }
-interface ProgressPath {
-  file: ProgressFilePath;
-  rule: {
-    id: string;
-    index: number;
-    total: number;
-  };
+interface JobQueuedPayload {
+  job: ProgressJob;
+}
+interface JobStartPayload {
+  job: ProgressJob;
+  startedAt?: number;
+}
+interface ProgressJob {
+  id: string;
+  index: number;
+  inputPath: string;
+  ruleId: string;
   target: {
-    index: number;
+    identity: string;
     kind: ProgressTargetKind;
     name?: string;
-    total: number;
   };
+  total: number;
 }
 interface ProgressReporter {
   onDiagnostic?: (payload: DiagnosticProgressPayload) => void;
-  onFileEnd?: (payload: FileProgressPayload) => void;
-  onFileStart?: (payload: FileProgressPayload) => void;
-  onRuleEnd?: (payload: RuleEndPayload) => void;
-  onRuleStart?: (payload: RuleStartPayload) => void;
+  onJobEnd?: (payload: JobEndPayload) => void;
+  onJobQueued?: (payload: JobQueuedPayload) => void;
+  onJobStart?: (payload: JobStartPayload) => void;
   onRunEnd?: (payload: RunEndPayload) => void;
   onRunStart?: (payload: RunStartPayload) => void;
-  onTargetEnd?: (payload: TargetProgressPayload) => void;
-  onTargetStart?: (payload: TargetProgressPayload) => void;
   onUsage?: (payload: UsageProgressPayload) => void;
 }
 type ProgressTargetKind = SourceTargetKind;
-interface RuleEndPayload {
-  cache: 'hit' | 'miss';
-  endedAt?: number;
-  path: ProgressPath;
-  startedAt?: number;
-  /**
-   * `skipped` only occurs under {@link RunOptions.cacheOnly}: the rule missed the cache and was
-   * never executed, so it produced no diagnostics. `cache` is still `'miss'` in that case.
-   */
-  state: 'completed' | 'errored' | 'skipped';
-}
-interface RuleStartPayload {
-  path: ProgressPath;
-  startedAt?: number;
-}
 interface RunEndPayload {
-  cached: number;
-  completed: number;
   diagnostics: Diagnostic[];
   endedAt?: number;
-  errored: number;
-  planned: number;
-  /** Rules left unexecuted because they missed the cache under {@link RunOptions.cacheOnly}. Always 0 otherwise. */
-  skipped: number;
+  execution: ExecutionCounts;
   startedAt?: number;
   usage: RunUsage;
 }
-interface RunExecution {
-  cached: number;
-  completed: number;
-  errored: number;
-  planned: number;
-  /** Rules left unexecuted because they missed the cache under {@link RunOptions.cacheOnly}. Always 0 otherwise. */
-  skipped: number;
-}
+type RunExecution = ExecutionCounts;
 type RunnerOptions = RunnerConfig;
 interface RunOptions {
   /**
    * Return only diagnostics that are already cached, without calling any model.
-   *
-   * Rules that miss the cache are skipped instead of executed, and the run leaves the cache
-   * file untouched. Read {@link RunExecution.skipped} to see how many rules a full run would
-   * still have to execute.
-   *
-   * Intended for callers that want to show known results for free, such as an editor
-   * displaying diagnostics on file open.
+   * Rules that miss the cache are skipped, and the cache remains read-only.
    */
   cacheOnly?: boolean;
   config?: AlintConfig;
@@ -189,14 +157,11 @@ interface RunOptions {
 }
 interface RunResult {
   diagnostics: Diagnostic[];
-  execution?: RunExecution;
+  execution: ExecutionCounts;
   usage: RunUsage;
 }
 interface RunStartPayload {
-  files?: ProgressFilePath[];
-  filesTotal: number;
-  planned: number;
-  rulesTotal: number;
+  jobsTotal: number;
   startedAt?: number;
 }
 interface RunUsage {
@@ -212,24 +177,28 @@ interface RunUsageTotals {
   records: InferenceUsageRecord[];
   totalTokens: number;
 }
-interface TargetProgressPayload {
-  endedAt?: number;
-  path: ProgressPath;
-  startedAt?: number;
-}
 interface UsageProgressPayload {
-  path?: ProgressPath;
+  job: ProgressJob;
   record: InferenceUsageRecord;
-  total: RunUsage;
 }
 //#endregion
 //#region src/core/run.d.ts
+declare class AlintRunCancelledError extends Error {
+  readonly result: RunResult;
+  constructor(result: RunResult, cause?: unknown);
+}
+/** Cancellation error carrying the partial result gathered before the abort. */
+declare class AlintAbortError extends AlintRunCancelledError {
+  constructor(result: RunResult, options?: {
+    cause?: unknown;
+  });
+}
 declare class AlintRunError extends Error {
-  readonly failure?: AlintRunFailure;
+  readonly failures: AlintRunFailure[];
   readonly result: RunResult;
   constructor(message: string, result: RunResult, options?: {
     cause?: unknown;
-    failure?: AlintRunFailure;
+    failures?: AlintRunFailure[];
   });
 }
 declare function runAlint(options?: RunOptions): Promise<RunResult>;
@@ -251,4 +220,4 @@ declare function buildRuleRegistry(config: Pick<EffectiveAlintConfig, 'plugins'
 //#region src/models/resolve.d.ts
 declare function resolveModel(registry: SetupConfig, options?: ResolveModelOptions): ResolvedModel;
 //#endregion
-export { type AlintConfig, type AlintConfigExtends, type AlintConfigInput, type AlintConfigItem, type AlintLinterOptions, AlintRunError, type AlintRunFailure, type Awaitable, type ClassTarget, type Diagnostic, type DiagnosticDescriptor, type DiagnosticLocation, type DiagnosticProgressPayload, type DirectoryTarget, type EffectiveAlintConfig, type EnabledRule, type FileProgressPayload, type FileTarget, type FunctionTarget, type IgnoreConfig, type InferenceUsageRecord, type LanguageContext, type LanguageDefinition, type LanguageRegistry, type LineRange, type ModelRequirement, type ModelSize, type PluginDefinition, type ProcessedSource, type ProcessedSourceOrigin, type ProcessorContext, type ProcessorDefinition, type ProcessorPostprocessContext, type ProgressFilePath, type ProgressPath, type ProgressReporter, type ProgressTargetKind, type ProjectTarget, type ProviderDefinition, type ProviderType, type ResolveConfigResult, type ResolveLanguageOptions, type ResolveModelOptions, type ResolvedModel, type ResolvedProvider, type RuleCacheConfig, type RuleConfigEntry, type RuleContext, type RuleDefinition, type RuleEndPayload, type RuleHandlers, type RuleInferenceUsageRecord, type RuleRegistry, type RuleSeverity, type RuleSpecializedHandlers, type RuleStartPayload, type RuleWithHandler, type RunEndPayload, type RunExecution, type RunOptions, type RunResult, type RunStartPayload, type RunUsage, type RunUsageTotals, type RunnerConfig, type RunnerStatsConfig, type SetupConfig, type SetupModelDefinition, type SourceFile, type SourceLocation, type SourcePosition, type SourceRange, type SourceRuntime, type SourceTarget, type SourceTargetKind, type SourceTargetOfKind, type SourceTargetOrigin, type SourceText, type Target, type TargetProgressPayload, type UsageProgressPayload, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, extractJsSourceTargets, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange };
+export { AlintAbortError, type AlintConfig, type AlintConfigExtends, type AlintConfigInput, type AlintConfigItem, type AlintLinterOptions, AlintRunCancelledError, AlintRunError, type AlintRunFailure, type Awaitable, type ClassTarget, type Diagnostic, type DiagnosticDescriptor, type DiagnosticLocation, type DiagnosticProgressPayload, type DirectoryTarget, type EffectiveAlintConfig, type EnabledRule, type ExecutionCounts, type FileTarget, type FunctionTarget, type IgnoreConfig, type InferenceUsageRecord, type JobEndPayload, type JobQueuedPayload, type JobStartPayload, type LanguageContext, type LanguageDefinition, type LanguageRegistry, type LineRange, type ModelRequirement, type ModelSize, type PluginDefinition, type ProcessedSource, type ProcessedSourceOrigin, type ProcessorContext, type ProcessorDefinition, type ProcessorPostprocessContext, type ProgressJob, type ProgressReporter, type ProgressTargetKind, type ProjectTarget, type ProviderDefinition, type ProviderType, type ResolveConfigResult, type ResolveLanguageOptions, type ResolveModelOptions, type ResolvedModel, type ResolvedProvider, type RuleCacheConfig, type RuleConfigEntry, type RuleContext, type RuleDefinition, type RuleHandlers, type RuleInferenceUsageRecord, type RuleRegistry, type RuleSeverity, type RuleSpecializedHandlers, type RuleWithHandler, type RunEndPayload, type RunExecution, type RunOptions, type RunResult, type RunStartPayload, type RunUsage, type RunUsageTotals, type RunnerConfig, type RunnerStatsConfig, type SetupConfig, type SetupModelDefinition, type SourceFile, type SourceLocation, type SourcePosition, type SourceRange, type SourceRuntime, type SourceTarget, type SourceTargetKind, type SourceTargetOfKind, type SourceTargetOrigin, type SourceText, type Target, type UsageProgressPayload, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange };