@shivaedev/quality 0.23.0 → 0.25.0

package/src/config/decode.ts

@@ -3,15 +3,18 @@ import { type Decoded, decodeWith } from "#decoded.ts";
 import { ExceptionDeclaration } from "#exceptions/declaration.ts";
 import type { Rule } from "#rule.ts";
 
-const isRule = (value: unknown): value is Rule =>
-	typeof value === "object"
-	&& value !== null
-	&& "id" in value
-	&& typeof value.id === "string"
-	&& "description" in value
-	&& typeof value.description === "string"
-	&& "configure" in value
-	&& typeof value.configure === "function";
+function isRule(value: unknown): value is Rule {
+	return (
+		typeof value === "object"
+		&& value !== null
+		&& "id" in value
+		&& typeof value.id === "string"
+		&& "description" in value
+		&& typeof value.description === "string"
+		&& "configure" in value
+		&& typeof value.configure === "function"
+	);
+}
 
 const Level = Schema.Literal("error");
 
@@ -44,4 +47,6 @@ export type ConfigInput = typeof ConfigInput.Type;
 
 const standard = Schema.toStandardSchemaV1(ConfigInput, { parseOptions: { errors: "all", onExcessProperty: "error" } });
 
-export const decodeConfig = (value: unknown): Promise<Decoded<ConfigInput>> => decodeWith(standard, value);
+export function decodeConfig(value: unknown): Promise<Decoded<ConfigInput>> {
+	return decodeWith(standard, value);
+}

package/src/config/load.ts

@@ -22,10 +22,12 @@ export interface ResolvedConfig extends ResolvedRules, InventoryScope {
 	readonly root: string;
 }
 
-const messageOf = (cause: unknown): string => (cause instanceof Error ? cause.message : String(cause));
+function messageOf(cause: unknown): string {
+	return cause instanceof Error ? cause.message : String(cause);
+}
 
-const importDefault = (file: string): Effect.Effect<unknown, SetupFailure> =>
-	Effect.flatMap(
+function importDefault(file: string): Effect.Effect<unknown, SetupFailure> {
+	return Effect.flatMap(
 		Effect.tryPromise({
 			catch: (cause) => new SetupFailure({ message: `cannot load ${file}: ${messageOf(cause)}` }),
 			try: async (): Promise<unknown> => import(pathToFileURL(file).href),
@@ -35,6 +37,7 @@ const importDefault = (file: string): Effect.Effect<unknown, SetupFailure> =>
 				? Effect.succeed(loaded.default)
 				: Effect.fail(new SetupFailure({ message: `${file} has no default export. Export defineConfig({ ... }) as the default.` })),
 	);
+}
 
 const LegacyOptions = Schema.Struct({ declared: Schema.Array(ConsumerDeclaration) });
 function biomeDeclarations(config: ConfigInput): readonly Declaration[] {
@@ -43,38 +46,42 @@ function biomeDeclarations(config: ConfigInput): readonly Declaration[] {
 	return Schema.is(LegacyOptions)(options) ? options.declared : [];
 }
 
-const resolved = (root: string, file: string, config: ConfigInput, rules: ResolvedRules): ResolvedConfig => ({
-	...rules,
-	baseline: config.baseline ?? "quality/baseline.jsonl",
-	biomeDeclarations: biomeDeclarations(config),
-	exceptions: config.exceptions ?? [],
-	exclude: [],
-	extensions: config.extensions ?? DEFAULT_EXTENSIONS,
-	file,
-	registry: config.registry ?? "quality/registry.json",
-	root,
-	sources: config.sources ?? ["."],
-});
+function resolved(root: string, file: string, config: ConfigInput, rules: ResolvedRules): ResolvedConfig {
+	return {
+		...rules,
+		baseline: config.baseline ?? "quality/baseline.jsonl",
+		biomeDeclarations: biomeDeclarations(config),
+		exceptions: config.exceptions ?? [],
+		exclude: [],
+		extensions: config.extensions ?? DEFAULT_EXTENSIONS,
+		file,
+		registry: config.registry ?? "quality/registry.json",
+		root,
+		sources: config.sources ?? ["."],
+	};
+}
 
-export const loadConfig = (cwd: string, path: string | undefined): Effect.Effect<ResolvedConfig, SetupFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		const file = resolve(cwd, path ?? CONFIG_FILE);
-		const entries = yield* fs
-			.readDirectory(dirname(file))
-			.pipe(
-				Effect.catchTag("PlatformError", (error) =>
-					error.reason._tag === "NotFound"
-						? Effect.succeed<string[]>([])
-						: Effect.fail(new SetupFailure({ message: `cannot inspect ${file}: ${error.message}` })),
-				),
-			);
-		const present = entries.includes(basename(file));
-		if (!present && path !== undefined) {
-			return yield* new SetupFailure({ message: `no config at ${file}. Check the --config path.` });
-		}
-		const loaded = present ? yield* importDefault(file) : {};
-		const config = yield* validOrFail(file, yield* Effect.promise(() => decodeConfig(loaded)));
-		const rules = yield* validOrFail(file, yield* resolveRules(config));
-		return resolved(dirname(file), file, config, rules);
-	});
+export const loadConfig = Effect.fn("Config.loadConfig")(function* (
+	cwd: string,
+	path: string | undefined,
+): Effect.fn.Return<ResolvedConfig, SetupFailure, FileSystem.FileSystem> {
+	const fs = yield* FileSystem.FileSystem;
+	const file = resolve(cwd, path ?? CONFIG_FILE);
+	const entries = yield* fs
+		.readDirectory(dirname(file))
+		.pipe(
+			Effect.catchTag("PlatformError", (error) =>
+				error.reason._tag === "NotFound"
+					? Effect.succeed<string[]>([])
+					: Effect.fail(new SetupFailure({ message: `cannot inspect ${file}: ${error.message}` })),
+			),
+		);
+	const present = entries.includes(basename(file));
+	if (!present && path !== undefined) {
+		return yield* new SetupFailure({ message: `no config at ${file}. Check the --config path.` });
+	}
+	const loaded = present ? yield* importDefault(file) : {};
+	const config = yield* validOrFail(file, yield* Effect.promise(() => decodeConfig(loaded)));
+	const rules = yield* validOrFail(file, yield* resolveRules(config));
+	return resolved(dirname(file), file, config, rules);
+});

package/src/config/resolve.ts

@@ -1,9 +1,9 @@
 import { Effect } from "effect";
 import type { Decoded } from "#decoded.ts";
-import type { ActiveRule } from "#engine/run-rules.ts";
+import type { ActiveRule } from "#engine/runRules.ts";
 import type { RuleIndex } from "#engine/violation.ts";
 import type { Rule } from "#rule.ts";
-import { builtInRules } from "#rules/built-in.ts";
+import { builtInRules } from "#rules/builtIn.ts";
 import type { ConfigInput } from "./decode.ts";
 
 export interface ResolvedRules extends RuleIndex {
@@ -12,14 +12,19 @@ export interface ResolvedRules extends RuleIndex {
 
 type Setting = NonNullable<ConfigInput["rules"]>[string];
 
-const messageOf = (cause: unknown): string => (cause instanceof Error ? cause.message : String(cause));
+function messageOf(cause: unknown): string {
+	return cause instanceof Error ? cause.message : String(cause);
+}
 
-const optionsOf = (setting: Setting | undefined): unknown => (typeof setting === "object" ? setting.options : undefined);
+function optionsOf(setting: Setting | undefined): unknown {
+	return typeof setting === "object" ? setting.options : undefined;
+}
 
-const duplicateIssues = (rules: readonly Rule[]): readonly string[] =>
-	rules.flatMap((rule, index) =>
+function duplicateIssues(rules: readonly Rule[]): readonly string[] {
+	return rules.flatMap((rule, index) =>
 		rules.findIndex((other) => other.id === rule.id) === index ? [] : [`local: rule id "${rule.id}" is already defined`],
 	);
+}
 
 function activeRule(rule: Rule, check: ActiveRule["check"]): ActiveRule {
 	return {
@@ -32,8 +37,8 @@ function activeRule(rule: Rule, check: ActiveRule["check"]): ActiveRule {
 	};
 }
 
-const activate = (rule: Rule, setting: Setting | undefined): Effect.Effect<Decoded<ActiveRule>> =>
-	Effect.tryPromise({ catch: messageOf, try: () => rule.configure(optionsOf(setting)) }).pipe(
+function activate(rule: Rule, setting: Setting | undefined): Effect.Effect<Decoded<ActiveRule>> {
+	return Effect.tryPromise({ catch: messageOf, try: () => rule.configure(optionsOf(setting)) }).pipe(
 		Effect.map(
 			(configured): Decoded<ActiveRule> =>
 				configured._tag === "Invalid"
@@ -47,25 +52,25 @@ const activate = (rule: Rule, setting: Setting | undefined): Effect.Effect<Decod
 			Effect.succeed<Decoded<ActiveRule>>({ _tag: "Invalid", issues: [`rules.${rule.id}.options: validation threw: ${failure}`] }),
 		),
 	);
+}
 
-export const resolveRules = (config: ConfigInput): Effect.Effect<Decoded<ResolvedRules>> =>
-	Effect.gen(function* () {
-		const rules: readonly Rule[] = [...builtInRules, ...(config.local ?? [])];
-		const settings = config.rules ?? {};
-		const known = new Set(rules.map((rule) => rule.id));
-		const families = new Set(rules.filter((rule) => rule.family === true).map((rule) => rule.id));
-		const unknown = [
-			...Object.keys(settings)
-				.filter((id) => !known.has(id))
-				.map((id) => `rules.${id}`),
-		].map((path) => `${path}: no built-in or local rule has this id`);
-		const activated = yield* Effect.forEach(rules, (rule) => activate(rule, settings[rule.id]));
-		const issues = [...duplicateIssues(rules), ...unknown, ...activated.flatMap((result) => (result._tag === "Invalid" ? result.issues : []))];
-		if (issues.length > 0) {
-			return { _tag: "Invalid", issues };
-		}
-		const active = activated.flatMap((result) => (result._tag === "Valid" ? [result.value] : []));
-		const levels = new Map(rules.map((rule) => [rule.id, "error" as const]));
-		const unregistrable = new Set(rules.filter((rule) => rule.registrable === false).map((rule) => rule.id));
-		return { _tag: "Valid", value: { active, families, levels, unregistrable } };
-	});
+export const resolveRules = Effect.fn("Config.resolveRules")(function* (config: ConfigInput): Effect.fn.Return<Decoded<ResolvedRules>> {
+	const rules: readonly Rule[] = [...builtInRules, ...(config.local ?? [])];
+	const settings = config.rules ?? {};
+	const known = new Set(rules.map((rule) => rule.id));
+	const families = new Set(rules.filter((rule) => rule.family === true).map((rule) => rule.id));
+	const unknown = [
+		...Object.keys(settings)
+			.filter((id) => !known.has(id))
+			.map((id) => `rules.${id}`),
+	].map((path) => `${path}: no built-in or local rule has this id`);
+	const activated = yield* Effect.forEach(rules, (rule) => activate(rule, settings[rule.id]));
+	const issues = [...duplicateIssues(rules), ...unknown, ...activated.flatMap((result) => (result._tag === "Invalid" ? result.issues : []))];
+	if (issues.length > 0) {
+		return { _tag: "Invalid", issues };
+	}
+	const active = activated.flatMap((result) => (result._tag === "Valid" ? [result.value] : []));
+	const levels = new Map(rules.map((rule) => [rule.id, "error" as const]));
+	const unregistrable = new Set(rules.filter((rule) => rule.registrable === false).map((rule) => rule.id));
+	return { _tag: "Valid", value: { active, families, levels, unregistrable } };
+});

package/src/config.ts

@@ -1,8 +1,8 @@
 import type { ExceptionDeclaration } from "#exceptions/declaration.ts";
-import type { builtInRules } from "#rules/built-in.ts";
+import type { builtInRules } from "#rules/builtIn.ts";
 import type { Rule } from "./rule.ts";
 
-export type Level = "error" | "warn" | "off";
+export type Level = "error";
 
 export type RuleSetting<TInput> = "error" | { readonly level?: "error"; readonly options?: TInput };
 
@@ -24,4 +24,6 @@ export interface QualityConfig<TLocal extends readonly Rule[] = readonly Rule[]>
 	readonly sources?: readonly string[];
 }
 
-export const defineConfig = <const TLocal extends readonly Rule[] = readonly []>(config: QualityConfig<TLocal>): QualityConfig<TLocal> => config;
+export function defineConfig<const TLocal extends readonly Rule[] = readonly []>(config: QualityConfig<TLocal>): QualityConfig<TLocal> {
+	return config;
+}

package/src/decoded.ts

@@ -1,15 +1,16 @@
 import { Effect } from "effect";
 import { SetupFailure } from "./failure.ts";
-import { describeIssue, type StandardSchemaV1 } from "./standard-schema.ts";
+import { describeIssue, type StandardSchemaV1 } from "./standardSchema.ts";
 
 export type Decoded<TValue> = { readonly _tag: "Valid"; readonly value: TValue } | { readonly _tag: "Invalid"; readonly issues: readonly string[] };
 
-export const decodeWith = async <TOutput>(schema: StandardSchemaV1<unknown, TOutput>, value: unknown): Promise<Decoded<TOutput>> => {
+export async function decodeWith<TOutput>(schema: StandardSchemaV1<unknown, TOutput>, value: unknown): Promise<Decoded<TOutput>> {
 	const result = await schema["~standard"].validate(value);
 	return result.issues === undefined ? { _tag: "Valid", value: result.value } : { _tag: "Invalid", issues: result.issues.map(describeIssue) };
-};
+}
 
-export const validOrFail = <TValue>(file: string, decoded: Decoded<TValue>): Effect.Effect<TValue, SetupFailure> =>
-	decoded._tag === "Valid"
+export function validOrFail<TValue>(file: string, decoded: Decoded<TValue>): Effect.Effect<TValue, SetupFailure> {
+	return decoded._tag === "Valid"
 		? Effect.succeed(decoded.value)
 		: Effect.fail(new SetupFailure({ message: `${file} is invalid:\n${decoded.issues.map((issue) => `  - ${issue}`).join("\n")}` }));
+}

package/src/engine/baselineFile.ts

@@ -0,0 +1,29 @@
+import { join } from "node:path";
+import { Effect, type FileSystem } from "effect";
+import { type BaselineEntry, decodeBaseline } from "#baseline/format.ts";
+import { LEGACY_BASELINE } from "#baseline/legacy.ts";
+import type { ResolvedConfig } from "#config/load.ts";
+import { validOrFail } from "#decoded.ts";
+import { SetupFailure } from "#failure.ts";
+import { readOptionalText } from "#inventory/filesystem.ts";
+
+export interface BaselineFile {
+	readonly entries: readonly BaselineEntry[];
+	readonly raw: string | undefined;
+}
+
+export function readInput(root: string, path: string): Effect.Effect<string | undefined, SetupFailure, FileSystem.FileSystem> {
+	return Effect.mapError(readOptionalText(join(root, path)), (failure) => new SetupFailure({ message: failure.message }));
+}
+
+export const readBaseline = Effect.fn("Engine.readBaseline")(function* (
+	config: ResolvedConfig,
+): Effect.fn.Return<BaselineFile, SetupFailure, FileSystem.FileSystem> {
+	const raw = yield* readInput(config.root, config.baseline);
+	if (raw === undefined && config.baseline !== LEGACY_BASELINE && (yield* readInput(config.root, LEGACY_BASELINE)) !== undefined) {
+		return yield* new SetupFailure({
+			message: `${LEGACY_BASELINE} holds a baseline in the earlier JSON format. Run \`quality baseline migrate\` to move it to ${config.baseline}.`,
+		});
+	}
+	return { entries: yield* validOrFail(config.baseline, yield* Effect.promise(() => decodeBaseline(raw))), raw };
+});

package/src/engine/evaluate.ts

@@ -11,29 +11,28 @@ export interface Outcome {
 	readonly regressions: readonly Regression[];
 	readonly staleBaseline: readonly StaleBaselineEntry[];
 	readonly staleRegistry: readonly StaleRegistryEntry[];
-	readonly warnings: readonly Violation[];
 }
 
-export const evaluate = (
+export function evaluate(
 	violations: readonly Violation[],
 	registry: readonly RegistryEntry[],
 	baseline: readonly BaselineEntry[],
 	rules: RuleIndex,
-): Outcome => {
+): Outcome {
 	const registered = applyRegistry(violations, registry, rules);
 	const baselined = applyBaseline(registered.kept, baseline, rules);
 	const kept = [...baselined.kept].sort(byLocation);
 	return {
 		baselined: baselined.baselined,
-		errors: kept.filter((violation) => violation.level === "error"),
+		errors: kept,
 		looseBaseline: baselined.loose,
 		registered: registered.registered,
 		regressions: baselined.regressions,
 		staleBaseline: baselined.stale,
 		staleRegistry: registered.stale,
-		warnings: kept.filter((violation) => violation.level === "warn"),
 	};
-};
+}
 
-export const passes = (outcome: Outcome): boolean =>
-	outcome.errors.length === 0 && outcome.staleBaseline.length === 0 && outcome.staleRegistry.length === 0;
+export function passes(outcome: Outcome): boolean {
+	return outcome.errors.length === 0 && outcome.staleBaseline.length === 0 && outcome.staleRegistry.length === 0;
+}

package/src/engine/{run-rules.ts → runRules.ts}

@@ -1,7 +1,7 @@
 import { isAbsolute, relative } from "node:path";
 import { Effect } from "effect";
 import { SetupFailure } from "#failure.ts";
-import { posix } from "#inventory/ignore-scope.ts";
+import { posix } from "#inventory/ignoreScope.ts";
 import type { Finding, Findings, RuleInputs } from "#rule.ts";
 import type { ActiveLevel, Violation } from "./violation.ts";
 
@@ -14,10 +14,14 @@ export interface ActiveRule {
 	readonly registrable?: boolean;
 }
 
-const messageOf = (cause: unknown): string => (cause instanceof Error ? cause.message : String(cause));
+function messageOf(cause: unknown): string {
+	return cause instanceof Error ? cause.message : String(cause);
+}
 
 // Registry and baseline entries match on the path, so every finding names its file the same way.
-const repositoryPath = (root: string, file: string): string => posix(isAbsolute(file) ? relative(root, file) : file).replace(/^(\.\/)+/u, "");
+function repositoryPath(root: string, file: string): string {
+	return posix(isAbsolute(file) ? relative(root, file) : file).replace(/^(?:\.\/)+/u, "");
+}
 
 function exceptionHint(rule: ActiveRule, finding: Finding, file: string, config: string): string {
 	const id = rule.family && finding.subject !== undefined ? `${rule.id}/${finding.subject}` : rule.id;
@@ -34,25 +38,29 @@ function exceptionHint(rule: ActiveRule, finding: Finding, file: string, config:
 	return ` For a permanent exception, add to exceptions in ${config}: ${shape}.`;
 }
 
-const violationOf = (rule: ActiveRule, root: string, finding: Finding, exceptionFile: string): Violation => ({
-	...finding,
-	file: repositoryPath(root, finding.file),
-	level: rule.level,
-	message: finding.message + exceptionHint(rule, finding, repositoryPath(root, finding.file), exceptionFile),
-	rule: rule.family && finding.subject !== undefined ? `${rule.id}/${finding.subject}` : rule.id,
-});
+function violationOf(rule: ActiveRule, root: string, finding: Finding, exceptionFile: string): Violation {
+	return {
+		...finding,
+		file: repositoryPath(root, finding.file),
+		level: rule.level,
+		message: finding.message + exceptionHint(rule, finding, repositoryPath(root, finding.file), exceptionFile),
+		rule: rule.family && finding.subject !== undefined ? `${rule.id}/${finding.subject}` : rule.id,
+	};
+}
 
-const runRule = (rule: ActiveRule, inputs: RuleInputs, exceptionFile: string): Effect.Effect<readonly Violation[], SetupFailure> =>
-	Effect.map(
+function runRule(rule: ActiveRule, inputs: RuleInputs, exceptionFile: string): Effect.Effect<readonly Violation[], SetupFailure> {
+	return Effect.map(
 		Effect.tryPromise({
 			catch: (cause) => new SetupFailure({ message: `rule ${rule.id} failed: ${messageOf(cause)}` }),
 			try: () => rule.check(inputs),
 		}),
 		(findings) => findings.map((finding) => violationOf(rule, inputs.root, finding, exceptionFile)),
 	);
+}
 
-export const runRules = (rules: readonly ActiveRule[], inputs: RuleInputs): Effect.Effect<readonly Violation[], SetupFailure> =>
-	Effect.map(
+export function runRules(rules: readonly ActiveRule[], inputs: RuleInputs): Effect.Effect<readonly Violation[], SetupFailure> {
+	return Effect.map(
 		Effect.forEach(rules, (rule) => runRule(rule, inputs, inputs.configFile ?? "quality.config.ts"), { concurrency: "unbounded" }),
 		(results) => results.flat(),
 	);
+}

package/src/engine/session.ts

@@ -7,8 +7,8 @@ import { registryEntries } from "#exceptions/registryEntries.ts";
 import { SetupFailure } from "#failure.ts";
 import { collectInventory, type Inventory } from "#inventory/collect.ts";
 import { type FilesystemFailure, readOptionalText } from "#inventory/filesystem.ts";
-import { type BaselineFile, readBaseline, readInput } from "./baseline-file.ts";
-import { runRules } from "./run-rules.ts";
+import { type BaselineFile, readBaseline, readInput } from "./baselineFile.ts";
+import { runRules } from "./runRules.ts";
 import type { Violation } from "./violation.ts";
 
 export interface Session {
@@ -19,32 +19,39 @@ export interface Session {
 	readonly violations: readonly Violation[];
 }
 
-const setup = <TValue, TRequirements>(
+function setup<TValue, TRequirements>(
 	effect: Effect.Effect<TValue, FilesystemFailure, TRequirements>,
-): Effect.Effect<TValue, SetupFailure, TRequirements> => Effect.mapError(effect, (failure) => new SetupFailure({ message: failure.message }));
+): Effect.Effect<TValue, SetupFailure, TRequirements> {
+	return Effect.mapError(effect, (failure) => new SetupFailure({ message: failure.message }));
+}
 
-export const scan = (config: ResolvedConfig): Effect.Effect<Pick<Session, "inventory" | "violations">, SetupFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const inventory = yield* setup(collectInventory(config.root, config));
-		const services = yield* Effect.context<FileSystem.FileSystem>();
-		const readText = (path: string): Promise<string | undefined> => Effect.runPromiseWith(services)(readOptionalText(resolve(config.root, path)));
-		const violations = yield* runRules(config.active, {
-			configFile: relative(config.root, config.file),
-			exceptions: config.exceptions,
-			files: inventory.files,
-			readText,
-			root: config.root,
-			sources: inventory.sources,
-		});
-		return { inventory, violations };
+export const scan = Effect.fn("Engine.scan")(function* (
+	config: ResolvedConfig,
+): Effect.fn.Return<Pick<Session, "inventory" | "violations">, SetupFailure, FileSystem.FileSystem> {
+	const inventory = yield* setup(collectInventory(config.root, config));
+	const services = yield* Effect.context<FileSystem.FileSystem>();
+	function readText(path: string): Promise<string | undefined> {
+		return Effect.runPromiseWith(services)(readOptionalText(resolve(config.root, path)));
+	}
+	const violations = yield* runRules(config.active, {
+		configFile: relative(config.root, config.file),
+		exceptions: config.exceptions,
+		files: inventory.files,
+		readText,
+		root: config.root,
+		sources: inventory.sources,
 	});
+	return { inventory, violations };
+});
 
-export const openSession = (cwd: string, configPath: string | undefined): Effect.Effect<Session, SetupFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const config = yield* loadConfig(cwd, configPath);
-		const registryRaw = yield* readInput(config.root, config.registry);
-		const registry = yield* validOrFail(config.registry, yield* Effect.promise(() => decodeRegistry(registryRaw)));
-		const baseline = yield* readBaseline(config);
-		const { inventory, violations } = yield* scan(config);
-		return { baseline, config, inventory, registry: [...registry, ...registryEntries(config.exceptions)], violations };
-	});
+export const openSession = Effect.fn("Engine.openSession")(function* (
+	cwd: string,
+	configPath: string | undefined,
+): Effect.fn.Return<Session, SetupFailure, FileSystem.FileSystem> {
+	const config = yield* loadConfig(cwd, configPath);
+	const registryRaw = yield* readInput(config.root, config.registry);
+	const registry = yield* validOrFail(config.registry, yield* Effect.promise(() => decodeRegistry(registryRaw)));
+	const baseline = yield* readBaseline(config);
+	const { inventory, violations } = yield* scan(config);
+	return { baseline, config, inventory, registry: [...registry, ...registryEntries(config.exceptions)], violations };
+});

package/src/engine/violation.ts

@@ -1,19 +1,22 @@
 import type { Level } from "#config.ts";
 import type { Finding } from "#rule.ts";
 
-export type ActiveLevel = "error" | "warn";
+export type ActiveLevel = "error";
 
 export interface Violation extends Finding {
 	readonly level: ActiveLevel;
 	readonly rule: string;
 }
 
-export const keyOf = (rule: string, file: string): string => `${rule}\u0000${file}`;
+export function keyOf(rule: string, file: string): string {
+	return `${rule}\u0000${file}`;
+}
 
-export const byLocation = (left: Violation, right: Violation): number =>
-	left.rule.localeCompare(right.rule) || left.file.localeCompare(right.file) || (left.line ?? 0) - (right.line ?? 0);
+export function byLocation(left: Violation, right: Violation): number {
+	return left.rule.localeCompare(right.rule) || left.file.localeCompare(right.file) || (left.line ?? 0) - (right.line ?? 0);
+}
 
-export const groupBy = <TItem>(items: readonly TItem[], key: (item: TItem) => string): ReadonlyMap<string, readonly TItem[]> => {
+export function groupBy<TItem>(items: readonly TItem[], key: (item: TItem) => string): ReadonlyMap<string, readonly TItem[]> {
 	const groups = new Map<string, TItem[]>();
 	for (const item of items) {
 		const group = groups.get(key(item));
@@ -24,7 +27,7 @@ export const groupBy = <TItem>(items: readonly TItem[], key: (item: TItem) => st
 		}
 	}
 	return groups;
-};
+}
 
 export interface RuleIndex {
 	readonly families: ReadonlySet<string>;
@@ -32,18 +35,26 @@ export interface RuleIndex {
 	readonly unregistrable: ReadonlySet<string>;
 }
 
-export const covers = (name: string, rule: string): boolean => rule === name || rule.startsWith(`${name}/`);
+export function covers(name: string, rule: string): boolean {
+	return rule === name || rule.startsWith(`${name}/`);
+}
 
-const ownerOf = (index: RuleIndex, rule: string): string => [...index.families].find((family) => covers(family, rule)) ?? rule;
+function ownerOf(index: RuleIndex, rule: string): string {
+	return [...index.families].find((family) => covers(family, rule)) ?? rule;
+}
 
-export const levelOf = (index: RuleIndex, rule: string): Level | undefined => index.levels.get(ownerOf(index, rule));
+export function levelOf(index: RuleIndex, rule: string): Level | undefined {
+	return index.levels.get(ownerOf(index, rule));
+}
 
-export const registrable = (index: RuleIndex, rule: string): boolean => !index.unregistrable.has(ownerOf(index, rule));
+export function registrable(index: RuleIndex, rule: string): boolean {
+	return !index.unregistrable.has(ownerOf(index, rule));
+}
 
-export const unusedEntryProblem = (index: RuleIndex, rule: string, unused: string): string => {
+export function unusedEntryProblem(index: RuleIndex, rule: string, unused: string): string {
 	const level = levelOf(index, rule);
 	if (level === undefined) {
 		return "names no known rule";
 	}
-	return level === "off" ? "names a rule that is off" : unused;
-};
+	return unused;
+}

package/src/exceptions/registry.ts

@@ -15,8 +15,9 @@ const standard = Schema.toStandardSchemaV1(Schema.fromJsonString(Schema.Array(Re
 	parseOptions: { errors: "all", onExcessProperty: "error" },
 });
 
-export const decodeRegistry = (raw: string | undefined): Promise<Decoded<readonly RegistryEntry[]>> =>
-	raw === undefined ? Promise.resolve({ _tag: "Valid", value: [] }) : decodeWith(standard, raw);
+export function decodeRegistry(raw: string | undefined): Promise<Decoded<readonly RegistryEntry[]>> {
+	return raw === undefined ? Promise.resolve({ _tag: "Valid", value: [] }) : decodeWith(standard, raw);
+}
 
 export interface StaleRegistryEntry {
 	readonly entry: RegistryEntry;
@@ -29,17 +30,18 @@ export interface RegistryCheck {
 	readonly stale: readonly StaleRegistryEntry[];
 }
 
-const covers = (entry: RegistryEntry, violation: Violation): boolean =>
-	entry.rule === violation.rule && entry.file === violation.file && (entry.subject === undefined || entry.subject === violation.subject);
+function covers(entry: RegistryEntry, violation: Violation): boolean {
+	return entry.rule === violation.rule && entry.file === violation.file && (entry.subject === undefined || entry.subject === violation.subject);
+}
 
 const UNREGISTRABLE = "names a rule that takes no exceptions. Fix the code, or baseline the violations while the repository adopts the rule";
 
-const coveringEntry = (entries: readonly RegistryEntry[], violation: Violation): RegistryEntry | undefined => {
+function coveringEntry(entries: readonly RegistryEntry[], violation: Violation): RegistryEntry | undefined {
 	const matching = entries.filter((entry) => covers(entry, violation));
 	return matching.find((entry) => entry.subject !== undefined) ?? matching[0];
-};
+}
 
-export const applyRegistry = (violations: readonly Violation[], entries: readonly RegistryEntry[], rules: RuleIndex): RegistryCheck => {
+export function applyRegistry(violations: readonly Violation[], entries: readonly RegistryEntry[], rules: RuleIndex): RegistryCheck {
 	const usable = entries.filter((entry) => registrable(rules, entry.rule));
 	const used = new Set<RegistryEntry>();
 	const kept = violations.filter((violation) => {
@@ -56,4 +58,4 @@ export const applyRegistry = (violations: readonly Violation[], entries: readonl
 			problem: registrable(rules, entry.rule) ? unusedEntryProblem(rules, entry.rule, "matches no violation") : UNREGISTRABLE,
 		}));
 	return { kept, registered: violations.length - kept.length, stale };
-};
+}