@alint-js/core 0.5.0 → 0.6.0

package/README.md

@@ -182,3 +182,10 @@ source files retained by plugin code after `ctx.src.readFile()` returns.
 
 A valid cache written by the same `alint` version is still read from one monolithic JSON document.
 An extremely large cache may therefore exhaust available memory.
+
+After each cacheable rule job completes, `alint` writes a cache checkpoint before releasing its
+scheduler slot. Each checkpoint atomically replaces the monolithic cache file. An interrupted run
+can therefore reuse every result that had already become durable, but large caches can cause
+substantial disk writes during runs with many cache misses. Cache hits, skipped jobs, failed jobs,
+and rules that opt out of caching do not add checkpoint writes. A checkpoint or final cache write
+error is fatal and causes the run to fail.

package/dist/agent.d.mts

@@ -1,4 +1,4 @@
-import { F as AgentTool, I as AgentUsage, M as AgentAdapter, N as AgentRequest, P as AgentResult, b as RuleContext } from "./types-BK5CADYK.mjs";
+import { F as AgentAdapter, I as AgentRequest, L as AgentResult, R as AgentTool, x as RuleContext, z as AgentUsage } from "./types-Cm5Z7Fll.mjs";
 //#region src/agent/retry.d.ts
 /**
  * Declares that the complete adapter invocation can be safely replayed.

package/dist/{define-CNfm3wZW.d.mts → define-DO36VJ4W.d.mts}

@@ -1,4 +1,4 @@
-import { E as RuleOptionsSchema, i as AlintConfigItem, p as PluginDefinition, t as AlintConfig, w as RuleOptionsInput, x as RuleDefinition, y as RuleConfigEntry } from "./types-BK5CADYK.mjs";
+import { D as RuleOptionsSchema, S as RuleDefinition, T as RuleOptionsInput, b as RuleConfigEntry, i as AlintConfigItem, m as PluginDefinition, t as AlintConfig } from "./types-Cm5Z7Fll.mjs";
 //#region src/dsl/define.d.ts
 type AnyRuleDefinition = RuleDefinition<any>;
 type ConfigItemWithPluginRules<Plugins, Rules> = Omit<AlintConfigItem, 'plugins' | 'rules'> & {

package/dist/dsl.d.mts

@@ -1,3 +1,3 @@
-import { A as RuleWithHandler, C as RuleInferenceUsageRecord, D as RuleRegistry, E as RuleOptionsSchema, O as RuleSeverity, S as RuleHandlers, T as RuleOptionsOutput, _ as ProjectTargetEntry, a as AlintLinterOptions, b as RuleContext, c as DiagnosticLocation, d as IgnoreConfig, f as LanguageDefinition, g as ProjectTarget, h as ProjectFileEntry, i as AlintConfigItem, j as Target, k as RuleSpecializedHandlers, 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 RuleCacheConfig, w as RuleOptionsInput, x as RuleDefinition, y as RuleConfigEntry } from "./types-BK5CADYK.mjs";
-import { n as definePlugin, r as defineRule, t as defineConfig } from "./define-CNfm3wZW.mjs";
-export { type AlintConfig, type AlintConfigExtends, type AlintConfigInput, type AlintConfigItem, type AlintLinterOptions, type Awaitable, type DiagnosticDescriptor, type DiagnosticLocation, type DirectoryTarget, type EnabledRule, type IgnoreConfig, type LanguageDefinition, type PluginDefinition, type ProcessorDefinition, type ProjectFileEntry, type ProjectTarget, type ProjectTargetEntry, type RuleCacheConfig, type RuleConfigEntry, type RuleContext, type RuleDefinition, type RuleHandlers, type RuleInferenceUsageRecord, type RuleOptionsInput, type RuleOptionsOutput, type RuleOptionsSchema, type RuleRegistry, type RuleSeverity, type RuleSpecializedHandlers, type RuleWithHandler, type Target, defineConfig, definePlugin, defineRule };
+import { A as RuleSpecializedHandlers, C as RuleHandlers, D as RuleOptionsSchema, E as RuleOptionsOutput, M as StopGateConfig, N as StopGateTarget, O as RuleRegistry, P as Target, S as RuleDefinition, T as RuleOptionsInput, _ as ProjectTarget, a as AlintLinterOptions, b as RuleConfigEntry, c as DiagnosticLocation, d as IgnoreConfig, f as IntegrationsConfig, g as ProjectFileEntry, h as ProcessorDefinition, i as AlintConfigItem, j as RuleWithHandler, k as RuleSeverity, l as DirectoryTarget, m as PluginDefinition, n as AlintConfigExtends, o as Awaitable, p as LanguageDefinition, r as AlintConfigInput, s as DiagnosticDescriptor, t as AlintConfig, u as EnabledRule, v as ProjectTargetEntry, w as RuleInferenceUsageRecord, x as RuleContext, y as RuleCacheConfig } from "./types-Cm5Z7Fll.mjs";
+import { n as definePlugin, r as defineRule, t as defineConfig } from "./define-DO36VJ4W.mjs";
+export { type AlintConfig, type AlintConfigExtends, type AlintConfigInput, type AlintConfigItem, type AlintLinterOptions, type Awaitable, type DiagnosticDescriptor, type DiagnosticLocation, type DirectoryTarget, type EnabledRule, type IgnoreConfig, type IntegrationsConfig, type LanguageDefinition, type PluginDefinition, type ProcessorDefinition, type ProjectFileEntry, type ProjectTarget, type ProjectTargetEntry, type RuleCacheConfig, type RuleConfigEntry, type RuleContext, type RuleDefinition, type RuleHandlers, type RuleInferenceUsageRecord, type RuleOptionsInput, type RuleOptionsOutput, type RuleOptionsSchema, type RuleRegistry, type RuleSeverity, type RuleSpecializedHandlers, type RuleWithHandler, type StopGateConfig, type StopGateTarget, type Target, defineConfig, definePlugin, defineRule };

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { A as RuleWithHandler, B as ResolvedProvider, C as RuleInferenceUsageRecord, D as RuleRegistry, G as RunnerStatsConfig, H as ProviderDefinition, K as SetupConfig, L as ModelRequirement, O as RuleSeverity, R as ResolveModelOptions, S as RuleHandlers, U as ProviderType, V as ModelSize, W as RunnerConfig, _ as ProjectTargetEntry, a as AlintLinterOptions, b as RuleContext, c as DiagnosticLocation, d as IgnoreConfig, f as LanguageDefinition, g as ProjectTarget, h as ProjectFileEntry, i as AlintConfigItem, j as Target, k as RuleSpecializedHandlers, l as DirectoryTarget, m as ProcessorDefinition, n as AlintConfigExtends, o as Awaitable, p as PluginDefinition, q as SetupModelDefinition, r as AlintConfigInput, s as DiagnosticDescriptor, t as AlintConfig, u as EnabledRule, v as RuleCacheConfig, x as RuleDefinition, y as RuleConfigEntry, z as ResolvedModel } from "./types-BK5CADYK.mjs";
+import { A as RuleSpecializedHandlers, B as ModelRequirement, C as RuleHandlers, G as ProviderDefinition, H as ResolvedModel, J as RunnerStatsConfig, K as ProviderType, M as StopGateConfig, N as StopGateTarget, O as RuleRegistry, P as Target, S as RuleDefinition, U as ResolvedProvider, V as ResolveModelOptions, W as ModelSize, X as SetupModelDefinition, Y as SetupConfig, _ as ProjectTarget, a as AlintLinterOptions, b as RuleConfigEntry, c as DiagnosticLocation, d as IgnoreConfig, f as IntegrationsConfig, g as ProjectFileEntry, h as ProcessorDefinition, i as AlintConfigItem, j as RuleWithHandler, k as RuleSeverity, l as DirectoryTarget, m as PluginDefinition, n as AlintConfigExtends, o as Awaitable, p as LanguageDefinition, q as RunnerConfig, r as AlintConfigInput, s as DiagnosticDescriptor, t as AlintConfig, u as EnabledRule, v as ProjectTargetEntry, w as RuleInferenceUsageRecord, x as RuleContext, y as RuleCacheConfig } from "./types-Cm5Z7Fll.mjs";
 import { C as SourceTarget, D as SourceTargetOrigin, E as SourceTargetOfKind, O as SourceText, S as SourceRuntime, T as SourceTargetMetadata, _ as SourceLocation, a as FunctionInfo, b as SourcePosition, c as LineRange, d as ProcessedSource, f as ProcessedSourceOrigin, g as SourceFile, h as SourceExtractOptions, i as FileTarget, l as PlannedSourceTarget, m as ProcessorPostprocessContext, n as CallSite, o as FunctionTarget, p as ProcessorContext, r as ClassTarget, s as LanguageContext, t as BaseSourceFile, u as PlannedSourceTargetOfKind, v as SourceMetadataObject, w as SourceTargetKind, x as SourceRange, y as SourceMetadataValue } from "./types-DM4idR4w.mjs";
-import { n as definePlugin, r as defineRule, t as defineConfig } from "./define-CNfm3wZW.mjs";
+import { n as definePlugin, r as defineRule, t as defineConfig } from "./define-DO36VJ4W.mjs";
 //#region src/config/config-array.d.ts
 interface EffectiveAlintConfig {
   agent?: AlintConfigItem['agent'];
@@ -32,6 +32,19 @@ declare function resolveConfigForDirectory(directoryPath: string, input: AlintCo
 declare function resolveConfigForFile(filePath: string, input: AlintConfig, options: ResolveConfigOptions): ResolveConfigResult;
 declare function resolveConfigForProject(projectPath: string, input: AlintConfig, options: ResolveConfigOptions): ResolveConfigResult;
 //#endregion
+//#region src/config/stop-gate.d.ts
+interface ResolvedStopGateConfig {
+  enabled: boolean;
+  target: StopGateTarget;
+  timeoutMs: number;
+}
+declare const maximumStopGateTimeoutMs: number;
+declare const defaultStopGateConfig: Readonly<ResolvedStopGateConfig>;
+declare function resolveStopGateConfig(config: AlintConfig, cwd: string): ResolvedStopGateConfig;
+//#endregion
+//#region src/core/hash.d.ts
+declare function stableHash(value: unknown): string;
+//#endregion
 //#region src/core/languages/registry.d.ts
 interface LanguageRegistry {
   byExtension: Map<string, string>;
@@ -270,6 +283,10 @@ declare class AlintAbortError extends AlintRunCancelledError {
     cause?: unknown;
   });
 }
+declare class AlintCachePersistenceError extends Error {
+  readonly result: RunResult;
+  constructor(result: RunResult, cause: unknown);
+}
 declare class AlintRunError extends Error {
   readonly failures: AlintRunFailure[];
   readonly result: RunResult;
@@ -380,4 +397,4 @@ declare function benchmarkModels(config: SetupConfig, options?: BenchmarkModelsO
 //#region src/models/resolve.d.ts
 declare function resolveModel(registry: SetupConfig, options?: ResolveModelOptions): ResolvedModel;
 //#endregion
-export { AlintAbortError, type AlintConfig, type AlintConfigExtends, type AlintConfigInput, type AlintConfigItem, type AlintFailureCause, type AlintFileFailure, type AlintLinterOptions, type AlintRuleFailure, AlintRunCancelledError, AlintRunError, type AlintRunFailure, type Awaitable, type BaseSourceFile, type BenchmarkModelsOptions, type CallSite, type ClassTarget, type Diagnostic, type DiagnosticDescriptor, type DiagnosticLocation, type DiagnosticProgressPayload, type DirectoryTarget, type EffectiveAlintConfig, type EnabledRule, type ExecutionCounts, type ExecutionProgressPayload, type FileReadyPayload, type FileTarget, type FunctionInfo, type FunctionTarget, type IgnoreConfig, type InferenceUsageRecord, type JobEndPayload, type JobQueuedPayload, type JobRetryPayload, type JobStartPayload, type LanguageContext, type LanguageDefinition, type LanguageRegistry, type LineRange, type ModelBenchmarkActive, type ModelBenchmarkMeasurement, type ModelBenchmarkProgress, type ModelBenchmarkRequest, type ModelBenchmarkResult, type ModelRequirement, type ModelSize, type PlannedSourceTarget, type PlannedSourceTargetOfKind, type PluginDefinition, type PrepareEndPayload, type PrepareStartPayload, type ProcessedSource, type ProcessedSourceOrigin, type ProcessorContext, type ProcessorDefinition, type ProcessorPostprocessContext, type ProgressJobRef, type ProgressReporter, type ProgressSnapshot, type ProgressTargetKind, type ProjectFileEntry, type ProjectTarget, type ProjectTargetEntry, 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 RunUsage, type RunUsageTotals, type RunnerConfig, type RunnerStatsConfig, type SetupConfig, type SetupModelDefinition, type SourceExtractOptions, type SourceFile, type SourceLocation, type SourceMetadataObject, type SourceMetadataValue, type SourcePosition, type SourceRange, type SourceRuntime, type SourceRuntimeOptions, type SourceTarget, type SourceTargetKind, type SourceTargetMetadata, type SourceTargetOfKind, type SourceTargetOrigin, type SourceText, type Target, type UsageProgressPayload, benchmarkModels, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceExtractor, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange, targetIdentity, withLanguage, withStableIdentities };
+export { AlintAbortError, AlintCachePersistenceError, type AlintConfig, type AlintConfigExtends, type AlintConfigInput, type AlintConfigItem, type AlintFailureCause, type AlintFileFailure, type AlintLinterOptions, type AlintRuleFailure, AlintRunCancelledError, AlintRunError, type AlintRunFailure, type Awaitable, type BaseSourceFile, type BenchmarkModelsOptions, type CallSite, type ClassTarget, type Diagnostic, type DiagnosticDescriptor, type DiagnosticLocation, type DiagnosticProgressPayload, type DirectoryTarget, type EffectiveAlintConfig, type EnabledRule, type ExecutionCounts, type ExecutionProgressPayload, type FileReadyPayload, type FileTarget, type FunctionInfo, type FunctionTarget, type IgnoreConfig, type InferenceUsageRecord, type IntegrationsConfig, type JobEndPayload, type JobQueuedPayload, type JobRetryPayload, type JobStartPayload, type LanguageContext, type LanguageDefinition, type LanguageRegistry, type LineRange, type ModelBenchmarkActive, type ModelBenchmarkMeasurement, type ModelBenchmarkProgress, type ModelBenchmarkRequest, type ModelBenchmarkResult, type ModelRequirement, type ModelSize, type PlannedSourceTarget, type PlannedSourceTargetOfKind, type PluginDefinition, type PrepareEndPayload, type PrepareStartPayload, type ProcessedSource, type ProcessedSourceOrigin, type ProcessorContext, type ProcessorDefinition, type ProcessorPostprocessContext, type ProgressJobRef, type ProgressReporter, type ProgressSnapshot, type ProgressTargetKind, type ProjectFileEntry, type ProjectTarget, type ProjectTargetEntry, type ProviderDefinition, type ProviderType, type ResolveConfigResult, type ResolveLanguageOptions, type ResolveModelOptions, type ResolvedModel, type ResolvedProvider, type ResolvedStopGateConfig, 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 RunUsage, type RunUsageTotals, type RunnerConfig, type RunnerStatsConfig, type SetupConfig, type SetupModelDefinition, type SourceExtractOptions, type SourceFile, type SourceLocation, type SourceMetadataObject, type SourceMetadataValue, type SourcePosition, type SourceRange, type SourceRuntime, type SourceRuntimeOptions, type SourceTarget, type SourceTargetKind, type SourceTargetMetadata, type SourceTargetOfKind, type SourceTargetOrigin, type SourceText, type StopGateConfig, type StopGateTarget, type Target, type UsageProgressPayload, benchmarkModels, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceExtractor, createSourceFile, createSourceRuntime, defaultStopGateConfig, defineConfig, definePlugin, defineRule, hasDiscoveryFilePatterns, matchesDiscoveryFile, maximumStopGateTimeoutMs, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, resolveStopGateConfig, runAlint, sliceLines, sliceRange, stableHash, targetIdentity, withLanguage, withStableIdentities };

package/dist/index.mjs

@@ -1,15 +1,17 @@
 import { o as withAgentRetry, t as combineAbortSignals } from "./agent-B6GG68NX.mjs";
 import { n as definePlugin, r as defineRule, t as defineConfig } from "./define-Da342Fcx.mjs";
-import { a as createSourceFile, c as sliceRange, d as stableHash, i as SourceChangedError, l as withLanguage, n as targetIdentity, o as createSourceRuntime, r as withStableIdentities, s as sliceLines, t as extractJsSourceTargets, u as createStableHasher } from "./extract-CLXRRiJW.mjs";
+import { a as createSourceFile, c as sliceRange, d as stableHash, i as SourceChangedError, l as withLanguage, n as targetIdentity, o as createSourceRuntime, r as withStableIdentities, s as sliceLines, t as extractJsSourceTargets, u as createStableHasher } from "./extract-DhLFgRej.mjs";
 import { minimatch } from "minimatch";
 import { basename, extname, isAbsolute, relative, resolve } from "pathe";
-import { access, mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { basename as basename$1, dirname, extname as extname$1, isAbsolute as isAbsolute$1, join, relative as relative$1, resolve as resolve$1, sep } from "node:path";
+import { array, boolean, check, custom, finite, getDotPath, integer, literal, looseObject, maxValue, minValue, number, object, optional, parse, picklist, pipe, record, safeParse, string, union, unknown } from "valibot";
 import { randomUUID } from "node:crypto";
+import { access, appendFile, mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { basename as basename$1, dirname, extname as extname$1, isAbsolute as isAbsolute$1, join, relative as relative$1, resolve as resolve$1, sep } from "node:path";
 import process, { cwd } from "node:process";
-import { array, boolean, check, custom, finite, getDotPath, literal, number, object, optional, parse, pipe, record, safeParse, string, union, unknown } from "valibot";
 import { Buffer } from "node:buffer";
 import { statSync } from "node:fs";
+import lockfile from "proper-lockfile";
+import { isNodeErrorCode } from "@alint-js/utils/node";
 import { errorMessageFrom } from "@moeru/std/error";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { streamText } from "@xsai/stream-text";
@@ -236,6 +238,37 @@ function withExpansionMetadata(item, inheritedMatcherScopes, effectiveBasePath)
 	return item;
 }
 //#endregion
+//#region src/config/stop-gate.ts
+const maximumStopGateTimeoutMs = 861e5;
+const defaultStopGateConfig = {
+	enabled: false,
+	target: "dirty-files",
+	timeoutMs: 9e5
+};
+const stopGateConfigSchema = looseObject({
+	enabled: optional(boolean("integrations.stopGate.enabled must be a boolean.")),
+	target: optional(picklist(["all", "dirty-files"], "integrations.stopGate.target must be \"all\" or \"dirty-files\".")),
+	timeoutMs: optional(pipe(number(`integrations.stopGate.timeoutMs must be an integer from 1 to ${maximumStopGateTimeoutMs}.`), integer(`integrations.stopGate.timeoutMs must be an integer from 1 to ${maximumStopGateTimeoutMs}.`), minValue(1, `integrations.stopGate.timeoutMs must be an integer from 1 to ${maximumStopGateTimeoutMs}.`), maxValue(maximumStopGateTimeoutMs, `integrations.stopGate.timeoutMs must be an integer from 1 to ${maximumStopGateTimeoutMs}.`)))
+}, "integrations.stopGate must be an object.");
+function resolveStopGateConfig(config, cwd) {
+	const project = resolveConfigForProject(cwd, config, { cwd });
+	for (const skipped of project.skipped) if (skipped.item.integrations?.stopGate !== void 0) throw new Error("integrations.stopGate must be declared in a global config item without files, directories, or ignores.");
+	return project.matched.reduce((resolved, item) => mergeStopGateConfig(resolved, item), { ...defaultStopGateConfig });
+}
+function assertStopGateConfig(value) {
+	parse(stopGateConfigSchema, value);
+}
+function mergeStopGateConfig(resolved, item) {
+	const stopGate = item.integrations?.stopGate;
+	if (stopGate === void 0) return resolved;
+	assertStopGateConfig(stopGate);
+	return {
+		enabled: stopGate.enabled ?? resolved.enabled,
+		target: stopGate.target ?? resolved.target,
+		timeoutMs: stopGate.timeoutMs ?? resolved.timeoutMs
+	};
+}
+//#endregion
 //#region src/core/languages/js/index.ts
 const javascriptLanguage = {
 	extensions: [
@@ -605,13 +638,16 @@ function recordMissingLanguages(into, rules, registry, path) {
 }
 //#endregion
 //#region package.json
-var version = "0.5.0";
+var version = "0.6.0";
 //#endregion
 //#region src/core/cache/types.ts
 const CACHE_MAGIC = "ALINT_CACHE";
 //#endregion
 //#region src/core/cache/store.ts
 const DEFAULT_CACHE_FILE_NAME = ".alintcache";
+const LOCK_STALE_MS = 2e4;
+const LOCK_UPDATE_MS = 3e3;
+const METADATA_READ_LIMIT = 4096;
 const FiniteNumberSchema = pipe(number(), finite());
 const PositionSchema = object({
 	column: FiniteNumberSchema,
@@ -671,18 +707,19 @@ const CacheEntrySchema = object({
 	}),
 	usage: array(UsageSchema)
 });
+const CachedOwnerSchema = object({
+	contentHash: optional(string()),
+	kind: union([literal("file"), literal("project")]),
+	path: string(),
+	slots: array(string())
+});
 function objectRecord(value) {
 	return pipe(unknown(), check((input) => typeof input === "object" && input !== null && !Array.isArray(input)), record(string(), value));
 }
 const CacheFileBodySchema = pipe(object({
 	createdAt: string(),
 	entries: objectRecord(CacheEntrySchema),
-	owners: objectRecord(object({
-		contentHash: optional(string()),
-		kind: union([literal("file"), literal("project")]),
-		path: string(),
-		slots: array(string())
-	})),
+	owners: objectRecord(CachedOwnerSchema),
 	updatedAt: string()
 }), check((body) => {
 	const entryKeys = Object.keys(body.entries);
@@ -690,22 +727,68 @@ const CacheFileBodySchema = pipe(object({
 	const uniqueSlots = new Set(referencedSlots);
 	return uniqueSlots.size === referencedSlots.length && uniqueSlots.size === entryKeys.length && entryKeys.every((key) => uniqueSlots.has(key));
 }));
+const CacheMetadataSchema = object({
+	alintVersion: string(),
+	createdAt: string(),
+	magic: literal(CACHE_MAGIC),
+	schemaVersion: literal(2),
+	type: literal("metadata")
+});
+const PutEventSchema = object({
+	at: string(),
+	entry: CacheEntrySchema,
+	owner: CachedOwnerSchema,
+	ownerKey: string(),
+	slotKey: string(),
+	type: literal("put")
+});
+const ReplaceOwnerEventSchema = object({
+	at: string(),
+	entries: array(object({
+		entry: CacheEntrySchema,
+		slotKey: string()
+	})),
+	mode: union([literal("merge"), literal("replace")]),
+	owner: CachedOwnerSchema,
+	ownerKey: string(),
+	type: literal("replace-owner")
+});
+const RemoveOwnerEventSchema = object({
+	at: string(),
+	ownerKey: string(),
+	type: literal("remove-owner")
+});
+const CacheEventSchema = union([
+	PutEventSchema,
+	ReplaceOwnerEventSchema,
+	RemoveOwnerEventSchema
+]);
 async function createCacheStore(options) {
 	const location = resolveCacheLocation(options.cwd, options.location);
 	if (!options.enabled) return createNoopCacheStore(location);
 	const alintVersion = options.alintVersion ?? version;
-	const header = `${CACHE_MAGIC} 2 ${alintVersion}`;
-	const body = await loadCacheBody(location, header, options.readOnly === true);
-	if (options.readOnly) return createReadOnlyCacheStore(location, body, options.cwd);
+	const initial = await loadCacheLog(location, alintVersion);
+	if (options.readOnly) return createReadOnlyCacheStore(location, initial.body, options.cwd);
+	const dependencies = {
+		append: options.appendFile ?? appendFile,
+		lock: options.lock ?? { acquire: lockfile.lock },
+		write: options.writeFile ?? writeFile
+	};
+	const trimmed = await trimOnce(location, alintVersion, initial, dependencies);
+	const writer = createEventWriter(location, trimmed.metadata, dependencies);
 	const fileExists = options.fileExists ?? defaultFileExists;
-	const writeFile$1 = options.writeFile ?? writeFile;
 	return {
-		beginOwner: (owner) => beginOwner(body, owner, options.cwd),
+		beginOwner: (owner, metadata) => beginOwner(trimmed.body, owner, options.cwd, writer, metadata),
+		flush: () => writer.flush(false),
 		location,
 		reconcile: async () => {
-			await collectMissingFileOwners(body, options.cwd, fileExists);
-			body.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-			await persistCacheBody(location, header, body, writeFile$1);
+			const removedOwners = await collectMissingFileOwners(trimmed.body, options.cwd, fileExists);
+			for (const ownerKey of removedOwners) writer.enqueue({
+				at: (/* @__PURE__ */ new Date()).toISOString(),
+				ownerKey,
+				type: "remove-owner"
+			});
+			await writer.flush(true);
 		}
 	};
 }
@@ -757,7 +840,50 @@ function resolveCacheLocation(cwd, location) {
 	} catch {}
 	return resolved;
 }
-function beginOwner(body, owner, cwd) {
+async function appendBatch(location, payload, append) {
+	const handle = await open(location, "a+");
+	try {
+		const { size } = await handle.stat();
+		let separator = "";
+		if (size > 0) {
+			const finalByte = Buffer.alloc(1);
+			await handle.read(finalByte, 0, 1, size - 1);
+			separator = finalByte[0] === 10 ? "" : "\n";
+		}
+		await append(location, `${separator}${payload}`, "utf8");
+	} finally {
+		await handle.close();
+	}
+}
+function applyEvent(body, event) {
+	if (event.type === "remove-owner") {
+		removeOwner(body, event.ownerKey);
+		body.updatedAt = event.at;
+		return;
+	}
+	if (event.type === "put") {
+		const current = body.owners[event.ownerKey];
+		const slots = new Set(current?.slots ?? []);
+		slots.add(event.slotKey);
+		body.entries[event.slotKey] = event.entry;
+		body.owners[event.ownerKey] = {
+			...event.owner,
+			slots: [...slots].sort()
+		};
+		body.updatedAt = event.at;
+		return;
+	}
+	const entries = event.mode === "merge" ? ownerEntries(body, body.owners[event.ownerKey]) : /* @__PURE__ */ new Map();
+	for (const item of event.entries) entries.set(item.slotKey, item.entry);
+	for (const slot of body.owners[event.ownerKey]?.slots ?? []) delete body.entries[slot];
+	for (const [slotKey, entry] of entries) body.entries[slotKey] = entry;
+	body.owners[event.ownerKey] = {
+		...event.owner,
+		slots: [...entries.keys()].sort()
+	};
+	body.updatedAt = event.at;
+}
+function beginOwner(body, owner, cwd, writer, ownerMetadata = {}) {
 	const normalizedOwner = {
 		kind: owner.kind,
 		path: normalizeCachePath(cwd, owner.path)
@@ -765,22 +891,64 @@ function beginOwner(body, owner, cwd) {
 	const key = ownerKey(normalizedOwner, cwd);
 	const previousOwner = body.owners[key];
 	const nextEntries = /* @__PURE__ */ new Map();
+	const checkpointEntries = /* @__PURE__ */ new Map();
+	const commit = (metadata = {}) => {
+		const contentHash = metadata.contentHash ?? ownerMetadata.contentHash;
+		const committedEntries = metadata.mode === "merge" ? ownerEntries(body, body.owners[key]) : /* @__PURE__ */ new Map();
+		for (const [entryKey, cacheEntry] of nextEntries) committedEntries.set(entryKey, cacheEntry);
+		const replacedSlots = /* @__PURE__ */ new Set([...previousOwner?.slots ?? [], ...body.owners[key]?.slots ?? []]);
+		for (const replacedSlot of replacedSlots) delete body.entries[replacedSlot];
+		for (const [entryKey, cacheEntry] of committedEntries) body.entries[entryKey] = cacheEntry;
+		const cachedOwner = {
+			contentHash,
+			kind: normalizedOwner.kind,
+			path: normalizedOwner.path,
+			slots: [...committedEntries.keys()].sort()
+		};
+		body.owners[key] = cachedOwner;
+		body.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		writer.enqueue({
+			at: body.updatedAt,
+			entries: [...committedEntries].map(([slotKey, entry]) => ({
+				entry,
+				slotKey
+			})),
+			mode: metadata.mode ?? "replace",
+			owner: cachedOwner,
+			ownerKey: key,
+			type: "replace-owner"
+		});
+		checkpointEntries.clear();
+	};
 	return {
-		commit: (metadata = {}) => {
-			const committedEntries = metadata.mode === "merge" ? ownerEntries(body, body.owners[key]) : /* @__PURE__ */ new Map();
-			for (const [entryKey, cacheEntry] of nextEntries) committedEntries.set(entryKey, cacheEntry);
-			const replacedSlots = /* @__PURE__ */ new Set([...previousOwner?.slots ?? [], ...body.owners[key]?.slots ?? []]);
-			for (const replacedSlot of replacedSlots) delete body.entries[replacedSlot];
-			for (const [entryKey, cacheEntry] of committedEntries) body.entries[entryKey] = cacheEntry;
-			body.owners[key] = {
-				contentHash: metadata.contentHash,
+		checkpoint: async () => {
+			const cachedOwner = {
+				contentHash: ownerMetadata.contentHash,
 				kind: normalizedOwner.kind,
 				path: normalizedOwner.path,
-				slots: [...committedEntries.keys()].sort()
+				slots: []
 			};
-			body.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+			for (const [entryKey, cacheEntry] of checkpointEntries) {
+				const event = {
+					at: (/* @__PURE__ */ new Date()).toISOString(),
+					entry: cacheEntry,
+					owner: cachedOwner,
+					ownerKey: key,
+					slotKey: entryKey,
+					type: "put"
+				};
+				applyEvent(body, event);
+				writer.enqueue(event);
+			}
+			checkpointEntries.clear();
+			await writer.flush(false);
+		},
+		commit,
+		discard: (cacheSlot) => {
+			const entryKey = slotKey(normalizedOwner, cacheSlot, cwd);
+			nextEntries.delete(entryKey);
+			checkpointEntries.delete(entryKey);
 		},
-		discard: (cacheSlot) => nextEntries.delete(slotKey(normalizedOwner, cacheSlot, cwd)),
 		lookup: (cacheSlot, fingerprint) => {
 			const entryKey = slotKey(normalizedOwner, cacheSlot, cwd);
 			const cached = body.entries[entryKey];
@@ -788,15 +956,21 @@ function beginOwner(body, owner, cwd) {
 			nextEntries.set(entryKey, cached);
 			return cached;
 		},
-		put: (cacheSlot, cacheEntry) => nextEntries.set(slotKey(normalizedOwner, cacheSlot, cwd), cacheEntry)
+		put: (cacheSlot, cacheEntry) => {
+			const entryKey = slotKey(normalizedOwner, cacheSlot, cwd);
+			nextEntries.set(entryKey, cacheEntry);
+			checkpointEntries.set(entryKey, cacheEntry);
+		}
 	};
 }
 async function collectMissingFileOwners(body, cwd, fileExists) {
+	const removed = [];
 	for (const [key, owner] of Object.entries(body.owners)) {
 		if (owner.kind !== "file" || await fileExists(resolve$1(cwd, owner.path))) continue;
-		for (const entryKey of owner.slots) delete body.entries[entryKey];
-		delete body.owners[key];
+		removeOwner(body, key);
+		removed.push(key);
 	}
+	return removed;
 }
 function createBaseTargetIdentity(target) {
 	if (target.identity && (target.kind !== "file" || target.identity !== "file")) return target.filePath ? `${target.kind}:${target.filePath}:${target.identity}` : `${target.kind}:${target.identity}`;
@@ -805,17 +979,53 @@ function createBaseTargetIdentity(target) {
 	if (target.range) return `${target.kind}:${target.range.start}:${target.range.end}`;
 	return target.kind;
 }
-function createEmptyCacheBody() {
-	const now = (/* @__PURE__ */ new Date()).toISOString();
+function createEmptyCacheBody(createdAt = (/* @__PURE__ */ new Date()).toISOString()) {
 	return {
-		createdAt: now,
+		createdAt,
 		entries: {},
 		owners: {},
-		updatedAt: now
+		updatedAt: createdAt
+	};
+}
+function createEventWriter(location, metadata, dependencies) {
+	const backlog = [];
+	let validationError;
+	let previousWrite = Promise.resolve();
+	const persistBacklog = async () => {
+		if (validationError) throw validationError;
+		if (backlog.length === 0) return;
+		await mkdir(dirname(location), { recursive: true });
+		await withCacheLock(location, dependencies.lock, getCacheLockOptions({
+			factor: 2,
+			maxTimeout: 16e3,
+			minTimeout: 2e3,
+			retries: 4
+		}), async () => {
+			await ensureCompatibleMetadata(location, metadata, dependencies.write);
+			const batchSize = backlog.length;
+			await appendBatch(location, backlog.slice(0, batchSize).map((event) => `${JSON.stringify(event)}\n`).join(""), dependencies.append);
+			backlog.splice(0, batchSize);
+		});
+		validationError = void 0;
+	};
+	return {
+		enqueue: (event) => {
+			try {
+				backlog.push(parse(CacheEventSchema, event));
+			} catch (error) {
+				validationError ??= error;
+			}
+		},
+		flush: (finalAttempt) => {
+			const write = previousWrite.then(persistBacklog);
+			previousWrite = write.catch(() => {});
+			return finalAttempt ? write : write.catch(() => {});
+		}
 	};
 }
 function createNoopCacheStore(location) {
 	const transaction = {
+		checkpoint: async () => {},
 		commit: () => {},
 		discard: () => {},
 		lookup: () => void 0,
@@ -823,22 +1033,24 @@ function createNoopCacheStore(location) {
 	};
 	return {
 		beginOwner: () => transaction,
+		flush: async () => {},
 		location,
 		reconcile: async () => {}
 	};
 }
 function createReadOnlyCacheStore(location, body, cwd) {
-	const transaction = (owner) => ({
-		commit: () => {},
-		discard: () => {},
-		lookup: (slot, fingerprint) => {
-			const cached = body.entries[slotKey(owner, slot, cwd)];
-			return cached && fingerprintsEqual(cached.fingerprint, fingerprint) ? cached : void 0;
-		},
-		put: () => {}
-	});
 	return {
-		beginOwner: transaction,
+		beginOwner: (owner) => ({
+			checkpoint: async () => {},
+			commit: () => {},
+			discard: () => {},
+			lookup: (slot, fingerprint) => {
+				const cached = body.entries[slotKey(owner, slot, cwd)];
+				return cached && fingerprintsEqual(cached.fingerprint, fingerprint) ? cached : void 0;
+			},
+			put: () => {}
+		}),
+		flush: async () => {},
 		location,
 		reconcile: async () => {}
 	};
@@ -852,9 +1064,38 @@ async function defaultFileExists(path) {
 		throw error;
 	}
 }
+function emptyLoadedLog(alintVersion) {
+	const metadata = {
+		alintVersion,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		magic: CACHE_MAGIC,
+		schemaVersion: 2,
+		type: "metadata"
+	};
+	return {
+		body: createEmptyCacheBody(metadata.createdAt),
+		metadata
+	};
+}
+async function ensureCompatibleMetadata(location, metadata, write) {
+	try {
+		if (parseMetadataLine(await readMetadataLine(location), metadata.alintVersion)) return;
+	} catch (error) {
+		if (!isMissingFileError(error)) throw error;
+	}
+	await write(location, `${JSON.stringify(metadata)}\n`);
+}
 function fingerprintsEqual(left, right) {
 	return left.configHash === right.configHash && left.modelHash === right.modelHash && left.ruleHash === right.ruleHash && left.targetHash === right.targetHash;
 }
+function getCacheLockOptions(retries) {
+	return {
+		realpath: false,
+		retries,
+		stale: LOCK_STALE_MS,
+		update: LOCK_UPDATE_MS
+	};
+}
 function hasJsonArrayProperties(input, ancestors) {
 	let arrayLength;
 	let indexCount = 0;
@@ -866,7 +1107,8 @@ function hasJsonArrayProperties(input, ancestors) {
 			arrayLength = descriptor.value;
 			continue;
 		}
-		if (typeof key !== "string" || !isCanonicalArrayIndex(key) || !descriptor.enumerable) return false;
+		const index = typeof key === "string" ? Number(key) : NaN;
+		if (typeof key !== "string" || !Number.isInteger(index) || index < 0 || index >= 2 ** 32 - 1 || String(index) !== key || !descriptor.enumerable) return false;
 		if (!isJsonValueAt(descriptor.value, ancestors)) return false;
 		indexCount += 1;
 	}
@@ -881,10 +1123,6 @@ function hasJsonObjectProperties(input, ancestors) {
 	}
 	return true;
 }
-function isCanonicalArrayIndex(key) {
-	const index = Number(key);
-	return Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === key;
-}
 function isJsonValue(input) {
 	return isJsonValueAt(input, /* @__PURE__ */ new WeakSet());
 }
@@ -910,27 +1148,14 @@ function isJsonValueAt(input, ancestors) {
 function isMissingFileError(error) {
 	return isNodeErrorCode(error, "ENOENT") || isNodeErrorCode(error, "ENOTDIR");
 }
-function isNodeErrorCode(error, code) {
-	return error instanceof Error && "code" in error && error.code === code;
-}
-async function loadCacheBody(location, expectedHeader, readOnly) {
-	let handle;
+async function loadCacheLog(location, alintVersion) {
 	try {
-		handle = await open(location, "r");
-		const header = await readHeader(handle);
-		await handle.close();
-		handle = void 0;
-		if (header !== expectedHeader) {
-			if (!readOnly) await rm(location, { force: true });
-			return createEmptyCacheBody();
-		}
-		const text = await readFile(location, "utf8");
-		return parseCacheBody(text.slice(text.indexOf("\n") + 1));
+		const metadata = parseMetadataLine(await readMetadataLine(location), alintVersion);
+		if (!metadata) return emptyLoadedLog(alintVersion);
+		return replayLog(await readFile(location, "utf8"), metadata);
 	} catch (error) {
-		await handle?.close().catch(() => {});
-		if (isMissingFileError(error)) return createEmptyCacheBody();
-		if (!readOnly) await rm(location, { force: true }).catch(() => {});
-		return createEmptyCacheBody();
+		if (isMissingFileError(error)) return emptyLoadedLog(alintVersion);
+		throw error;
 	}
 }
 function ownerEntries(body, owner) {
@@ -947,27 +1172,72 @@ function ownerKey(owner, cwd) {
 		path: normalizeCachePath(cwd, owner.path)
 	});
 }
-function parseCacheBody(text) {
-	const value = JSON.parse(text);
-	return parse(CacheFileBodySchema, value);
+function parseMetadataLine(line, expectedAlintVersion) {
+	if (!line) return void 0;
+	try {
+		const value = JSON.parse(line);
+		const metadata = parse(CacheMetadataSchema, value);
+		if (expectedAlintVersion !== void 0 && metadata.alintVersion !== expectedAlintVersion) return void 0;
+		return metadata;
+	} catch {
+		return;
+	}
 }
-async function persistCacheBody(location, header, body, writeFile) {
-	const validatedBody = parse(CacheFileBodySchema, body);
-	await mkdir(dirname(location), { recursive: true });
+async function persistCompactedLog(location, loaded, write) {
+	const metadata = parse(CacheMetadataSchema, loaded.metadata);
+	const events = Object.entries(loaded.body.owners).map(([ownerKey, owner]) => ({
+		at: loaded.body.updatedAt,
+		entries: [...ownerEntries(loaded.body, owner)].map(([slotKey, entry]) => ({
+			entry,
+			slotKey
+		})),
+		mode: "replace",
+		owner,
+		ownerKey,
+		type: "replace-owner"
+	})).map((event) => parse(CacheEventSchema, event));
+	const contents = [`${JSON.stringify(metadata)}\n`, ...events.map((event) => `${JSON.stringify(event)}\n`)].join("");
 	const tempPath = join(dirname(location), `.${basename$1(location)}.${process.pid}.${randomUUID()}.tmp`);
 	try {
-		await writeFile(tempPath, `${header}\n${JSON.stringify(validatedBody)}\n`);
+		await write(tempPath, contents);
 		await rename(tempPath, location);
 	} catch (error) {
 		await rm(tempPath, { force: true }).catch(() => {});
 		throw error;
 	}
 }
-async function readHeader(handle) {
-	const buffer = Buffer.alloc(256);
-	const { bytesRead } = await handle.read(buffer, 0, 256, 0);
-	const newline = buffer.subarray(0, bytesRead).indexOf(10);
-	return newline < 0 ? void 0 : buffer.subarray(0, newline).toString("utf8");
+async function readMetadataLine(location) {
+	const handle = await open(location, "r");
+	try {
+		const buffer = Buffer.alloc(METADATA_READ_LIMIT);
+		const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+		const newlineIndex = buffer.subarray(0, bytesRead).indexOf(10);
+		if (newlineIndex < 0) return void 0;
+		const lineEnd = newlineIndex > 0 && buffer[newlineIndex - 1] === 13 ? newlineIndex - 1 : newlineIndex;
+		return buffer.toString("utf8", 0, lineEnd);
+	} finally {
+		await handle.close();
+	}
+}
+function removeOwner(body, key) {
+	for (const slot of body.owners[key]?.slots ?? []) delete body.entries[slot];
+	delete body.owners[key];
+}
+function replayLog(text, metadata) {
+	const body = createEmptyCacheBody(metadata.createdAt);
+	const lines = text.split(/\r?\n/);
+	for (let index = 1; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (!line) continue;
+		try {
+			const value = JSON.parse(line);
+			applyEvent(body, parse(CacheEventSchema, value));
+		} catch {}
+	}
+	return {
+		body: parse(CacheFileBodySchema, body),
+		metadata
+	};
 }
 function slotKey(owner, slot, cwd) {
 	return stableHash({
@@ -975,6 +1245,43 @@ function slotKey(owner, slot, cwd) {
 		...slot
 	});
 }
+async function trimOnce(location, alintVersion, fallback, dependencies) {
+	await mkdir(dirname(location), { recursive: true });
+	try {
+		return await withCacheLock(location, dependencies.lock, getCacheLockOptions(0), async () => {
+			const latest = await loadCacheLog(location, alintVersion);
+			await persistCompactedLog(location, latest, dependencies.write);
+			return latest;
+		});
+	} catch (error) {
+		if (isNodeErrorCode(error, "ELOCKED")) return fallback;
+		throw error;
+	}
+}
+async function withCacheLock(location, lock, options, operation) {
+	let compromised;
+	const release = await lock.acquire(location, {
+		...options,
+		onCompromised: (error) => {
+			compromised = error;
+		}
+	});
+	let operationError;
+	try {
+		const result = await operation();
+		if (compromised) throw compromised;
+		return result;
+	} catch (error) {
+		operationError = error;
+		throw error;
+	} finally {
+		try {
+			await release();
+		} catch (error) {
+			if (operationError === void 0) throw error;
+		}
+	}
+}
 //#endregion
 //#region src/core/execution/records.ts
 function snapshotDiagnostic(diagnostic) {
@@ -1112,9 +1419,10 @@ async function executeRuleJob(job, options) {
 		failure: failure(handlerCause, job, handlerCause instanceof SourceChangedError ? "source-changed" : "handler"),
 		state: "failed"
 	});
-	if (slot && fingerprint) try {
+	if (slot && fingerprint) {
 		job.target.cacheOwner?.put(slot, createCacheEntry(job, fingerprint, bucket));
-	} catch {}
+		await job.target.cacheOwner?.checkpoint();
+	}
 	return finish(job, bucket, {
 		cache: "miss",
 		state: "completed"
@@ -2097,7 +2405,7 @@ async function planSource(input, options) {
 		cacheOwner = options.cacheStore.beginOwner({
 			kind: "file",
 			path: file.path
-		});
+		}, { contentHash });
 		const baseFile = {
 			contentHash,
 			language: file.language,
@@ -2112,10 +2420,7 @@ async function planSource(input, options) {
 		};
 	}
 	if (options.signal?.aborted) {
-		cacheOwner.commit({
-			contentHash,
-			mode: "merge"
-		});
+		cacheOwner.commit({ mode: "merge" });
 		return {
 			outcomes: Promise.resolve([]),
 			project
@@ -2124,11 +2429,9 @@ async function planSource(input, options) {
 	const batch = options.scheduler.schedule(jobs);
 	reportFilePlanningComplete(input, batch.jobsAdded, options);
 	return {
-		outcomes: batch.outcomes.then((settled) => {
-			cacheOwner.commit(options.signal?.aborted ? {
-				contentHash,
-				mode: "merge"
-			} : { contentHash });
+		outcomes: batch.outcomes.then(async (settled) => {
+			cacheOwner.commit(options.signal?.aborted ? { mode: "merge" } : void 0);
+			await options.cacheStore.flush();
 			return settled;
 		}),
 		project
@@ -2405,6 +2708,14 @@ var AlintAbortError = class extends AlintRunCancelledError {
 		this.name = "AlintAbortError";
 	}
 };
+var AlintCachePersistenceError = class extends Error {
+	result;
+	constructor(result, cause) {
+		super("Failed to persist the alint cache.", { cause });
+		this.name = "AlintCachePersistenceError";
+		this.result = result;
+	}
+};
 var AlintRunError = class extends Error {
 	failures;
 	result;
@@ -2482,6 +2793,7 @@ async function runAlint(options = {}) {
 	const outcomes = [];
 	const fileFailures = [];
 	let infrastructureError;
+	let cachePersistenceError;
 	let infrastructureFailed = false;
 	let admissionFailed = false;
 	try {
@@ -2545,7 +2857,9 @@ async function runAlint(options = {}) {
 		}
 		if (!admissionFailed && !options.cacheOnly) try {
 			await cacheStore.reconcile();
-		} catch {}
+		} catch (error) {
+			cachePersistenceError = error;
+		}
 	}
 	runProgress.finalize();
 	if (admissionFailed) throw infrastructureError;
@@ -2574,6 +2888,7 @@ async function runAlint(options = {}) {
 		usage: snapshotRunUsage(result.usage)
 	});
 	if (infrastructureFailed) throw infrastructureError;
+	if (cachePersistenceError !== void 0) throw new AlintCachePersistenceError(result, cachePersistenceError);
 	if (options.signal?.aborted) throw new AlintAbortError(result, { cause: options.signal.reason });
 	if (failures.length > 0) throw new AlintRunError(fileFailures.length > 0 ? `${failures.length} alint execution${failures.length === 1 ? "" : "s"} failed.` : `${failures.length} rule execution${failures.length === 1 ? "" : "s"} failed.`, result, {
 		cause: new AggregateError(failures.map((failure) => new Error(failure.message)), "Alint execution failures."),
@@ -2930,4 +3245,4 @@ function sampleCorpus(seed) {
 	].map((section) => `--- corpus section ${section} ---\n${rotated}`).join("\n\n");
 }
 //#endregion
-export { AlintAbortError, AlintRunCancelledError, AlintRunError, benchmarkModels, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceExtractor, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange, targetIdentity, withLanguage, withStableIdentities };
+export { AlintAbortError, AlintCachePersistenceError, AlintRunCancelledError, AlintRunError, benchmarkModels, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceExtractor, createSourceFile, createSourceRuntime, defaultStopGateConfig, defineConfig, definePlugin, defineRule, hasDiscoveryFilePatterns, matchesDiscoveryFile, maximumStopGateTimeoutMs, normalizeConfig, registerLanguage, resolveConfigForDirectory, resolveConfigForFile, resolveConfigForProject, resolveLanguage, resolveModel, resolveStopGateConfig, runAlint, sliceLines, sliceRange, stableHash, targetIdentity, withLanguage, withStableIdentities };

package/dist/languages-js.mjs

@@ -1,2 +1,2 @@
-import { t as extractJsSourceTargets } from "./extract-CLXRRiJW.mjs";
+import { t as extractJsSourceTargets } from "./extract-DhLFgRej.mjs";
 export { extractJsSourceTargets };

package/dist/structured-output.d.mts

@@ -1,4 +1,4 @@
-import { b as RuleContext, z as ResolvedModel } from "./types-BK5CADYK.mjs";
+import { H as ResolvedModel, x as RuleContext } from "./types-Cm5Z7Fll.mjs";
 import { GenericSchema, InferOutput } from "valibot";
 import { JsonSchema } from "@valibot/to-json-schema";
 import { Message } from "@xsai/shared-chat";

package/dist/{types-BK5CADYK.d.mts → types-Cm5Z7Fll.d.mts}

@@ -109,6 +109,7 @@ interface AlintConfigItem {
   files?: readonly (readonly string[] | string)[];
   ignore?: IgnoreConfig;
   ignores?: readonly string[];
+  integrations?: IntegrationsConfig;
   language?: string;
   languageOptions?: Record<string, unknown>;
   linterOptions?: AlintLinterOptions;
@@ -160,6 +161,9 @@ interface EnabledRule {
 interface IgnoreConfig {
   gitignore?: boolean;
 }
+interface IntegrationsConfig {
+  stopGate?: StopGateConfig;
+}
 interface LanguageDefinition {
   extensions?: readonly string[];
   extract: (file: SourceFile, context: LanguageContext) => Awaitable<SourceTarget[]>;
@@ -305,6 +309,12 @@ interface RuleWithHandler {
   onTargetProject?: never;
   onTargetWith: (target: Target) => Awaitable<void>;
 }
+interface StopGateConfig {
+  enabled?: boolean;
+  target?: StopGateTarget;
+  timeoutMs?: number;
+}
+type StopGateTarget = 'all' | 'dirty-files';
 type Target = DirectoryTarget | PlannedSourceTarget | ProjectTarget;
 //#endregion
-export { RuleWithHandler as A, ResolvedProvider as B, RuleInferenceUsageRecord as C, RuleRegistry as D, RuleOptionsSchema as E, AgentTool as F, RunnerStatsConfig as G, ProviderDefinition as H, AgentUsage as I, SetupConfig as K, ModelRequirement as L, AgentAdapter as M, AgentRequest as N, RuleSeverity as O, AgentResult as P, ResolveModelOptions as R, RuleHandlers as S, RuleOptionsOutput as T, ProviderType as U, ModelSize as V, RunnerConfig as W, ProjectTargetEntry as _, AlintLinterOptions as a, RuleContext as b, DiagnosticLocation as c, IgnoreConfig as d, LanguageDefinition as f, ProjectTarget as g, ProjectFileEntry as h, AlintConfigItem as i, Target as j, RuleSpecializedHandlers as k, DirectoryTarget as l, ProcessorDefinition as m, AlintConfigExtends as n, Awaitable as o, PluginDefinition as p, SetupModelDefinition as q, AlintConfigInput as r, DiagnosticDescriptor as s, AlintConfig as t, EnabledRule as u, RuleCacheConfig as v, RuleOptionsInput as w, RuleDefinition as x, RuleConfigEntry as y, ResolvedModel as z };
+export { RuleSpecializedHandlers as A, ModelRequirement as B, RuleHandlers as C, RuleOptionsSchema as D, RuleOptionsOutput as E, AgentAdapter as F, ProviderDefinition as G, ResolvedModel as H, AgentRequest as I, RunnerStatsConfig as J, ProviderType as K, AgentResult as L, StopGateConfig as M, StopGateTarget as N, RuleRegistry as O, Target as P, AgentTool as R, RuleDefinition as S, RuleOptionsInput as T, ResolvedProvider as U, ResolveModelOptions as V, ModelSize as W, SetupModelDefinition as X, SetupConfig as Y, ProjectTarget as _, AlintLinterOptions as a, RuleConfigEntry as b, DiagnosticLocation as c, IgnoreConfig as d, IntegrationsConfig as f, ProjectFileEntry as g, ProcessorDefinition as h, AlintConfigItem as i, RuleWithHandler as j, RuleSeverity as k, DirectoryTarget as l, PluginDefinition as m, AlintConfigExtends as n, Awaitable as o, LanguageDefinition as p, RunnerConfig as q, AlintConfigInput as r, DiagnosticDescriptor as s, AlintConfig as t, EnabledRule as u, ProjectTargetEntry as v, RuleInferenceUsageRecord as w, RuleContext as x, RuleCacheConfig as y, AgentUsage as z };

package/package.json

@@ -1,7 +1,22 @@
 {
   "name": "@alint-js/core",
   "type": "module",
-  "version": "0.5.0",
+  "version": "0.6.0",
+  "description": "Public rule and plugin SDK and run engine for alint",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moeru-ai/alint.git",
+    "directory": "packages/core"
+  },
+  "keywords": [
+    "alint",
+    "lint",
+    "linter",
+    "ai",
+    "code-analysis",
+    "sdk"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
@@ -39,9 +54,12 @@
     "minimatch": "^10.2.6",
     "oxc-parser": "^0.142.0",
     "pathe": "^2.0.3",
-    "valibot": "^1.4.2"
+    "proper-lockfile": "4.1.2",
+    "valibot": "^1.4.2",
+    "@alint-js/utils": "0.6.0"
   },
   "devDependencies": {
+    "@types/proper-lockfile": "4.1.4",
     "effect": "^3.22.1",
     "sury": "^11.0.0-rc.0"
   },

package/dist/{extract-CLXRRiJW.mjs → extract-DhLFgRej.mjs}

@@ -1,7 +1,7 @@
+import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { extname } from "node:path";
 import { clamp } from "es-toolkit";
-import { createHash } from "node:crypto";
 import { parseSync } from "oxc-parser";
 //#region src/core/hash.ts
 function createStableHasher() {