@shivaedev/quality 0.22.0 → 0.24.0

package/src/cli/run-main.ts

@@ -11,27 +11,28 @@ import type { Git } from "#git/command.ts";
 const INTERRUPTED = 130;
 const COULD_NOT_RUN = 2;
 
-const explain = (cause: Cause.Cause<unknown>): Effect.Effect<void> => {
+function explain(cause: Cause.Cause<unknown>): Effect.Effect<void> {
 	const error = Cause.squash(cause);
 	if (error instanceof SetupFailure) {
 		return Console.error(`quality: ${error.message}`);
 	}
 	return Runtime.getErrorReported(error) ? Console.error(`quality: internal error\n${Cause.pretty(cause)}`) : Effect.void;
-};
+}
 
-const exitCodeOf = (error: unknown): number =>
-	typeof error === "object" && error !== null && Runtime.errorExitCode in error ? Runtime.getErrorExitCode(error) : COULD_NOT_RUN;
+function exitCodeOf(error: unknown): number {
+	return typeof error === "object" && error !== null && Runtime.errorExitCode in error ? Runtime.getErrorExitCode(error) : COULD_NOT_RUN;
+}
 
-const exitCode = (exit: Exit.Exit<unknown, unknown>): number => {
+export function exitCode(exit: Exit.Exit<unknown, unknown>): number {
 	if (Exit.isSuccess(exit)) {
 		return 0;
 	}
 	return Cause.hasInterruptsOnly(exit.cause) ? INTERRUPTED : exitCodeOf(Cause.squash(exit.cause));
-};
+}
 
-const teardown: Runtime.Teardown = (exit, onExit) => {
+function teardown(exit: Parameters<Runtime.Teardown>[0], onExit: Parameters<Runtime.Teardown>[1]): void {
 	process.stdout.write("", () => process.stderr.write("", () => onExit(exitCode(exit))));
-};
+}
 
 function isClosedPipe(error: unknown): boolean {
 	return error instanceof Error && "code" in error && error.code === "EPIPE";
@@ -45,11 +46,16 @@ export function quietOnClosedPipe(stream: EventEmitter): void {
 	});
 }
 
-const services = NodeChildProcessSpawner.layer.pipe(Layer.provideMerge(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)));
+export const services = NodeChildProcessSpawner.layer.pipe(Layer.provideMerge(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)));
 
-export const runMain = <TValue, TError>(program: Effect.Effect<TValue, TError, FileSystem.FileSystem | Git>): void => {
+export function explained<TValue, TError, TRequirements>(
+	program: Effect.Effect<TValue, TError, TRequirements>,
+): Effect.Effect<TValue, TError, TRequirements> {
+	return Effect.tapCause(program, (cause) => (Cause.hasInterruptsOnly(cause) ? Effect.void : explain(cause)));
+}
+
+export function runMain<TValue, TError>(program: Effect.Effect<TValue, TError, FileSystem.FileSystem | Git>): void {
 	quietOnClosedPipe(process.stdout);
 	quietOnClosedPipe(process.stderr);
-	const explained = Effect.tapCause(program, (cause) => (Cause.hasInterruptsOnly(cause) ? Effect.void : explain(cause)));
-	NodeRuntime.runMain(Effect.provide(explained, services), { disableErrorReporting: true, teardown });
-};
+	NodeRuntime.runMain(Effect.provide(explained(program), services), { disableErrorReporting: true, teardown });
+}

package/src/cli/shrink.ts

@@ -6,8 +6,8 @@ import type { Git } from "#git/command.ts";
 import { changesSince } from "#git/history.ts";
 import { shrinkBaseline } from "./baseline.ts";
 
-const followedMoves = (root: string, against: string | undefined): Effect.Effect<Scope, SetupFailure, Git> =>
-	resolveBase(root, against).pipe(
+function followedMoves(root: string, against: string | undefined): Effect.Effect<Scope, SetupFailure, Git> {
+	return resolveBase(root, against).pipe(
 		Effect.flatMap((base) => changesSince(root, [base.commit])),
 		Effect.map((changes): Scope => ({ moves: changes.moves })),
 		Effect.catchIf(
@@ -15,17 +15,20 @@ const followedMoves = (root: string, against: string | undefined): Effect.Effect
 			(failure) => Effect.as(Console.error(`quality: moved files are not followed: ${failure.message}`), { moves: new Map() }),
 		),
 	);
+}
 
-export const pruneBaseline = (
+export function pruneBaseline(
 	cwd: string,
 	config: string | undefined,
 	against: string | undefined,
-): Effect.Effect<void, SetupFailure, FileSystem.FileSystem | Git> =>
-	shrinkBaseline(cwd, config, (session) => followedMoves(session.config.root, against));
+): Effect.Effect<void, SetupFailure, FileSystem.FileSystem | Git> {
+	return shrinkBaseline(cwd, config, (session) => followedMoves(session.config.root, against));
+}
 
-export const tightenBaseline = (
+export function tightenBaseline(
 	cwd: string,
 	config: string | undefined,
 	staged: boolean,
-): Effect.Effect<void, SetupFailure, FileSystem.FileSystem | Git> =>
-	shrinkBaseline(cwd, config, (session) => changesSince(session.config.root, staged ? ["--cached"] : ["HEAD"]));
+): Effect.Effect<void, SetupFailure, FileSystem.FileSystem | Git> {
+	return shrinkBaseline(cwd, config, (session) => changesSince(session.config.root, staged ? ["--cached"] : ["HEAD"]));
+}

package/src/cli.ts

@@ -1,55 +1,6 @@
 #!/usr/bin/env node
 import process from "node:process";
-import { Console, Effect } from "effect";
-import { parseCommand, USAGE } from "#cli/args.ts";
-import { writeBaseline } from "#cli/baseline.ts";
-import { fix } from "#cli/fix.ts";
-import { lint } from "#cli/lint.ts";
-import { migrateBaseline } from "#cli/migrate.ts";
-import { migrateExceptions } from "#cli/migrateExceptions.ts";
+import { program } from "#cli/program.ts";
 import { runMain } from "#cli/run-main.ts";
-import { pruneBaseline, tightenBaseline } from "#cli/shrink.ts";
-import { installHook } from "#hooks/install.ts";
-import { preCommitHook } from "#hooks/preCommit.ts";
-import { uninstallHook } from "#hooks/uninstall.ts";
-import { SetupFailure } from "./failure.ts";
 
-const parsed = parseCommand(process.argv.slice(2));
-
-const program = Effect.gen(function* () {
-	if (parsed._tag === "Usage") {
-		return yield* new SetupFailure({ message: `${parsed.problem}\n\n${USAGE}` });
-	}
-	const command = parsed.command;
-	switch (command._tag) {
-		case "Help":
-			return yield* Console.log(USAGE);
-		case "Lint":
-			return yield* lint(process.cwd(), command.config, command.warnings);
-		case "Fix":
-			return yield* fix(process.cwd(), command.config);
-		case "BaselineWrite":
-			return yield* writeBaseline(process.cwd(), command.config, command.rules);
-		case "BaselinePrune":
-			return yield* pruneBaseline(process.cwd(), command.config, command.against);
-		case "BaselineTighten":
-			return yield* tightenBaseline(process.cwd(), command.config, command.staged);
-		case "ExceptionsMigrate":
-			return yield* migrateExceptions(process.cwd(), command.config, command.from);
-		case "BaselineMigrate":
-			return yield* migrateBaseline(process.cwd(), command.config, command.from);
-		case "HooksInstall":
-			return yield* installHook({
-				config: command.config,
-				cwd: process.cwd(),
-				force: command.force,
-				launch: { options: process.execArgv, script: process.argv[1] ?? "" },
-			});
-		case "HooksUninstall":
-			return yield* uninstallHook(process.cwd());
-		case "HooksPreCommit":
-			return yield* preCommitHook(process.cwd(), command.config);
-	}
-});
-
-runMain(program);
+runMain(program(process.argv.slice(2), { cwd: process.cwd(), launch: { options: process.execArgv, script: process.argv[1] ?? "" } }));

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

@@ -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

@@ -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

@@ -4,12 +4,13 @@ import { describeIssue, type StandardSchemaV1 } from "./standard-schema.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/baseline-file.ts

@@ -12,16 +12,18 @@ export interface BaselineFile {
 	readonly raw: string | undefined;
 }
 
-export const readInput = (root: string, path: string): Effect.Effect<string | undefined, SetupFailure, FileSystem.FileSystem> =>
-	Effect.mapError(readOptionalText(join(root, path)), (failure) => new SetupFailure({ message: failure.message }));
+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 = (config: ResolvedConfig): Effect.Effect<BaselineFile, SetupFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		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 };
-	});
+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

@@ -14,12 +14,12 @@ export interface Outcome {
 	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);
@@ -33,7 +33,8 @@ export const evaluate = (
 		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

@@ -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

@@ -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 };
+});