@shivaedev/quality 0.23.0 → 0.24.0

package/docs/modules.md

@@ -182,6 +182,8 @@ A module link opens its source. Type and value declarations with the same name a
 | [rules/built-in.ts](https://github.com/ShivaeDev/platform/blob/main/packages/quality/src/rules/built-in.ts) | `builtInRules` |
 | [rules/manifests-sorted.ts](https://github.com/ShivaeDev/platform/blob/main/packages/quality/src/rules/manifests-sorted.ts) | `manifestsSorted` |
 | [rules/max-lines.ts](https://github.com/ShivaeDev/platform/blob/main/packages/quality/src/rules/max-lines.ts) | `maxLines` |
+| [rules/maxDepth.ts](https://github.com/ShivaeDev/platform/blob/main/packages/quality/src/rules/maxDepth.ts) | `maxDepth` |
+| [rules/noBarrel.ts](https://github.com/ShivaeDev/platform/blob/main/packages/quality/src/rules/noBarrel.ts) | `noBarrel` |
 | [rules/syntax.ts](https://github.com/ShivaeDev/platform/blob/main/packages/quality/src/rules/syntax.ts) | `parse` |
 
 ## rules/comments

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/quality",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "Repository quality gate with typed rules, a baseline of existing debt and a registry of reasoned exceptions",
   "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/quality#readme",
   "bugs": {

package/src/baseline/compare.ts

@@ -19,9 +19,11 @@ export interface BaselineCheck {
 	readonly stale: readonly StaleBaselineEntry[];
 }
 
-export const countOf = (violations: readonly Violation[]): number => violations.reduce((total, violation) => total + (violation.count ?? 1), 0);
+export function countOf(violations: readonly Violation[]): number {
+	return violations.reduce((total, violation) => total + (violation.count ?? 1), 0);
+}
 
-export const applyBaseline = (violations: readonly Violation[], entries: readonly BaselineEntry[], rules: RuleIndex): BaselineCheck => {
+export function applyBaseline(violations: readonly Violation[], entries: readonly BaselineEntry[], rules: RuleIndex): BaselineCheck {
 	const groups = groupBy(violations, (violation) => keyOf(violation.rule, violation.file));
 	const covered = new Set<string>();
 	const regressions: Regression[] = [];
@@ -49,4 +51,4 @@ export const applyBaseline = (violations: readonly Violation[], entries: readonl
 	}
 	const kept = violations.filter((violation) => !covered.has(keyOf(violation.rule, violation.file)));
 	return { baselined: violations.length - kept.length, kept, loose, regressions, stale };
-};
+}

package/src/baseline/format.ts

@@ -16,18 +16,22 @@ export interface BaselineEntry {
 	readonly rule: string;
 }
 
-const codepoints = (left: string, right: string): number => (left < right ? -1 : Number(left > right));
+function codepoints(left: string, right: string): number {
+	return left < right ? -1 : Number(left > right);
+}
 
-export const byPathAndRule = (left: BaselineEntry, right: BaselineEntry): number =>
-	codepoints(left.file, right.file) || codepoints(left.rule, right.rule);
+export function byPathAndRule(left: BaselineEntry, right: BaselineEntry): number {
+	return codepoints(left.file, right.file) || codepoints(left.rule, right.rule);
+}
 
-export const linesOf = (raw: string | undefined): ReadonlyArray<{ readonly line: number; readonly text: string }> =>
-	(raw ?? "")
+export function linesOf(raw: string | undefined): ReadonlyArray<{ readonly line: number; readonly text: string }> {
+	return (raw ?? "")
 		.split("\n")
 		.map((text, index) => ({ line: index + 1, text }))
 		.filter((row) => row.text.trim() !== "");
+}
 
-export const decodeBaseline = async (raw: string | undefined): Promise<Decoded<readonly BaselineEntry[]>> => {
+export async function decodeBaseline(raw: string | undefined): Promise<Decoded<readonly BaselineEntry[]>> {
 	const issues: string[] = [];
 	const entries: BaselineEntry[] = [];
 	const seen = new Set<string>();
@@ -45,14 +49,17 @@ export const decodeBaseline = async (raw: string | undefined): Promise<Decoded<r
 		entries.push({ ...stored, file: path });
 	}
 	return issues.length === 0 ? { _tag: "Valid", value: entries } : { _tag: "Invalid", issues };
-};
+}
 
 const LINE_KEYS = ["path", "rule", "count"];
 
-export const encodeEntry = (entry: BaselineEntry): string => JSON.stringify({ count: entry.count, path: entry.file, rule: entry.rule }, LINE_KEYS);
+export function encodeEntry(entry: BaselineEntry): string {
+	return JSON.stringify({ count: entry.count, path: entry.file, rule: entry.rule }, LINE_KEYS);
+}
 
-export const encodeBaseline = (entries: readonly BaselineEntry[]): string =>
-	[...entries]
+export function encodeBaseline(entries: readonly BaselineEntry[]): string {
+	return [...entries]
 		.sort(byPathAndRule)
 		.map((entry) => `${encodeEntry(entry)}\n`)
 		.join("");
+}

package/src/baseline/legacy.ts

@@ -19,7 +19,7 @@ export interface LegacyEntry extends BaselineEntry {
 	readonly measure?: number | undefined;
 }
 
-export const decodeLegacyBaseline = async (raw: string): Promise<Decoded<readonly LegacyEntry[]>> => {
+export async function decodeLegacyBaseline(raw: string): Promise<Decoded<readonly LegacyEntry[]>> {
 	const decoded = await decodeWith(standard, raw);
 	if (decoded._tag === "Invalid") {
 		return decoded;
@@ -28,9 +28,9 @@ export const decodeLegacyBaseline = async (raw: string): Promise<Decoded<readonl
 		Object.entries(files).map(([file, stored]) => ({ ...stored, file, rule })),
 	);
 	return { _tag: "Valid", value: entries };
-};
+}
 
-export const convertLegacy = (legacy: readonly LegacyEntry[], violations: readonly Violation[]): readonly BaselineEntry[] => {
+export function convertLegacy(legacy: readonly LegacyEntry[], violations: readonly Violation[]): readonly BaselineEntry[] {
 	const current = groupBy(violations, (violation) => keyOf(violation.rule, violation.file));
 	return legacy.flatMap(({ count, file, measure, rule }) => {
 		if (measure === undefined) {
@@ -41,4 +41,4 @@ export const convertLegacy = (legacy: readonly LegacyEntry[], violations: readon
 		const converted = threshold === undefined ? countOf(group) : Math.ceil(measure - threshold);
 		return converted > 0 ? [{ count: converted, file, rule }] : [];
 	});
-};
+}

package/src/baseline/rewrite.ts

@@ -7,7 +7,7 @@ interface Row {
 }
 
 // An untouched entry keeps its exact line and a new one goes before the first line that sorts after it, so two branches conflict only on the same or neighbouring entries.
-export const rewriteBaseline = (raw: string | undefined, before: readonly BaselineEntry[], after: readonly BaselineEntry[]): string => {
+export function rewriteBaseline(raw: string | undefined, before: readonly BaselineEntry[], after: readonly BaselineEntry[]): string {
 	const wanted = new Map(after.map((entry) => [keyOf(entry.rule, entry.file), entry]));
 	const lines = linesOf(raw);
 	const rows: Row[] = before.flatMap((old, index) => {
@@ -21,4 +21,4 @@ export const rewriteBaseline = (raw: string | undefined, before: readonly Baseli
 		rows.splice(at === -1 ? rows.length : at, 0, { entry, text: encodeEntry(entry) });
 	}
 	return rows.map((row) => `${row.text}\n`).join("");
-};
+}

package/src/baseline/update.ts

@@ -13,8 +13,8 @@ export interface Pruned {
 	readonly removed: number;
 }
 
-const record = (violations: readonly Violation[]): readonly BaselineEntry[] =>
-	[...groupBy(violations, (violation) => keyOf(violation.rule, violation.file)).values()].flatMap((group) => {
+function record(violations: readonly Violation[]): readonly BaselineEntry[] {
+	return [...groupBy(violations, (violation) => keyOf(violation.rule, violation.file)).values()].flatMap((group) => {
 		const first = group[0];
 		if (first === undefined) {
 			return [];
@@ -22,21 +22,22 @@ const record = (violations: readonly Violation[]): readonly BaselineEntry[] =>
 		const count = countOf(group);
 		return count > 0 ? [{ count, file: first.file, rule: first.rule }] : [];
 	});
+}
 
-const refusal = (id: string, index: RuleIndex): readonly string[] => {
+function refusal(id: string, index: RuleIndex): readonly string[] {
 	const level = levelOf(index, id);
 	if (level === undefined) {
 		return [`${id}: no built-in or local rule has this id.`];
 	}
 	return level === "error" ? [] : [`${id}: the rule is ${level}. Set it to error before baselining it.`];
-};
+}
 
-export const adopt = (
+export function adopt(
 	existing: readonly BaselineEntry[] | undefined,
 	rules: readonly string[],
 	violations: readonly Violation[],
 	index: RuleIndex,
-): Adoption => {
+): Adoption {
 	if (existing !== undefined && rules.length === 0) {
 		return { _tag: "Refused", reasons: ["a baseline exists. Record a rule with --rule <id>, or drop fixed debt with prune."] };
 	}
@@ -44,38 +45,41 @@ export const adopt = (
 	if (reasons.length > 0) {
 		return { _tag: "Refused", reasons };
 	}
-	const named = (rule: string): boolean => rules.some((name) => covers(name, rule));
+	function named(rule: string): boolean {
+		return rules.some((name) => covers(name, rule));
+	}
 	const kept = (existing ?? []).filter((entry) => !named(entry.rule));
 	const adopted = violations.filter((violation) => violation.level === "error" && (rules.length === 0 || named(violation.rule)));
 	const added = record(adopted);
 	return { _tag: "Adopted", added: added.length, entries: [...kept, ...added], replaced: (existing ?? []).length - kept.length };
-};
+}
 
 export interface Scope {
 	readonly files?: ReadonlySet<string> | undefined;
 	readonly moves: ReadonlyMap<string, string>;
 }
 
-const inScope = (entry: BaselineEntry, scope: Scope): boolean =>
-	scope.files === undefined || scope.files.has(entry.file) || scope.moves.has(entry.file);
+function inScope(entry: BaselineEntry, scope: Scope): boolean {
+	return scope.files === undefined || scope.files.has(entry.file) || scope.moves.has(entry.file);
+}
 
-const destination = (
+function destination(
 	before: BaselineEntry,
 	current: ReadonlyMap<string, BaselineEntry>,
 	moves: ReadonlyMap<string, string>,
 	taken: ReadonlySet<string>,
-) => {
+) {
 	const to = moves.get(before.file);
 	const key = to === undefined ? undefined : keyOf(before.rule, to);
 	return key === undefined || taken.has(key) ? undefined : current.get(key);
-};
+}
 
-export const prune = (
+export function prune(
 	existing: readonly BaselineEntry[],
 	violations: readonly Violation[],
 	index: RuleIndex,
 	scope: Scope = { moves: new Map() },
-): Pruned => {
+): Pruned {
 	const current = new Map(record(violations).map((entry) => [keyOf(entry.rule, entry.file), entry]));
 	const taken = new Set(existing.map((entry) => keyOf(entry.rule, entry.file)));
 	let moved = 0;
@@ -97,4 +101,4 @@ export const prune = (
 		moved,
 		removed: existing.length - kept.length,
 	};
-};
+}

package/src/cli/args.ts

@@ -31,7 +31,9 @@ const OPTIONS = {
 	warnings: { type: "string" },
 } as const;
 
-const usage = (problem: string): Parsed => ({ _tag: "Usage", problem });
+function usage(problem: string): Parsed {
+	return { _tag: "Usage", problem };
+}
 
 const SUBCOMMANDS: Readonly<Record<string, string>> = {
 	baseline: "baseline takes write, prune, tighten or migrate.",
@@ -39,7 +41,9 @@ const SUBCOMMANDS: Readonly<Record<string, string>> = {
 	hooks: "hooks takes install, uninstall or pre-commit.",
 };
 
-const parsed = (command: Command): Parsed => ({ _tag: "Parsed", command });
+function parsed(command: Command): Parsed {
+	return { _tag: "Parsed", command };
+}
 
 type Values = ReturnType<typeof parseArgs<{ options: typeof OPTIONS; allowPositionals: true }>>["values"];
 
@@ -60,16 +64,17 @@ const ACCEPTS: Readonly<Record<string, readonly Option[]>> = {
 	lint: ["warnings"],
 };
 
-const misplaced = (name: string, values: Values): string | undefined => {
+function misplaced(name: string, values: Values): string | undefined {
 	const option = COMMAND_OPTIONS.find((key) => values[key] !== undefined && !(ACCEPTS[name] ?? []).includes(key));
 	const owners = Object.keys(ACCEPTS).filter((owner) => option !== undefined && (ACCEPTS[owner] ?? []).includes(option));
 	return option === undefined ? undefined : `--${option} applies only to ${owners.join(" and ")}.`;
-};
+}
 
-const ref = (against: string | undefined, command: Command): Parsed =>
-	against?.startsWith("-") === true ? usage(`--against takes a git ref, not "${against}".`) : parsed(command);
+function ref(against: string | undefined, command: Command): Parsed {
+	return against?.startsWith("-") === true ? usage(`--against takes a git ref, not "${against}".`) : parsed(command);
+}
 
-const commandFor = (name: string, values: Values): Parsed => {
+function commandFor(name: string, values: Values): Parsed {
 	const config = values.config;
 	switch (name) {
 		case "lint": {
@@ -97,9 +102,9 @@ const commandFor = (name: string, values: Values): Parsed => {
 		default:
 			return parsed({ _tag: "BaselineMigrate", config, from: values.from });
 	}
-};
+}
 
-export const parseCommand = (args: readonly string[]): Parsed => {
+export function parseCommand(args: readonly string[]): Parsed {
 	const result = Result.try({
 		catch: (error) => (error instanceof Error ? error.message : String(error)),
 		try: () => parseArgs({ allowPositionals: true, args: [...args], options: OPTIONS, strict: true }),
@@ -122,4 +127,4 @@ export const parseCommand = (args: readonly string[]): Parsed => {
 	}
 	const problem = misplaced(name, values);
 	return problem === undefined ? commandFor(name, values) : usage(problem);
-};
+}

package/src/cli/baseline.ts

@@ -9,57 +9,58 @@ import { SetupFailure } from "#failure.ts";
 import { writeText } from "#inventory/filesystem.ts";
 import { plural } from "#report/plural.ts";
 
-const save = (session: Session, entries: readonly BaselineEntry[]): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> =>
-	Effect.mapError(
+function save(session: Session, entries: readonly BaselineEntry[]): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> {
+	return Effect.mapError(
 		writeText(join(session.config.root, session.config.baseline), rewriteBaseline(session.baseline.raw, session.baseline.entries, entries)),
 		(failure) => new SetupFailure({ message: failure.message }),
 	);
+}
 
-const unregistered = (session: Session) => applyRegistry(session.violations, session.registry, session.config).kept;
+function unregistered(session: Session) {
+	return applyRegistry(session.violations, session.registry, session.config).kept;
+}
 
-export const writeBaseline = (
+export const writeBaseline = Effect.fn("Cli.writeBaseline")(function* (
 	cwd: string,
 	config: string | undefined,
 	rules: readonly string[],
-): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const session = yield* openSession(cwd, config);
-		const existing = session.baseline.raw === undefined ? undefined : session.baseline.entries;
-		const adoption = adopt(existing, rules, unregistered(session), session.config);
-		if (adoption._tag === "Refused") {
-			return yield* new SetupFailure({ message: `baseline write refused:\n${adoption.reasons.map((reason) => `  - ${reason}`).join("\n")}` });
-		}
-		if (adoption.added === 0 && adoption.replaced === 0) {
-			return yield* Console.log(`quality: no error-level violations to record; ${session.config.baseline} is unchanged.`);
-		}
-		yield* save(session, adoption.entries);
-		const replaced = adoption.replaced > 0 ? `, replacing ${plural(adoption.replaced, "entry", "entries")}` : "";
-		yield* Console.log(`quality: recorded ${plural(adoption.added, "entry", "entries")} in ${session.config.baseline}${replaced}.`);
-	});
+): Effect.fn.Return<void, SetupFailure, FileSystem.FileSystem> {
+	const session = yield* openSession(cwd, config);
+	const existing = session.baseline.raw === undefined ? undefined : session.baseline.entries;
+	const adoption = adopt(existing, rules, unregistered(session), session.config);
+	if (adoption._tag === "Refused") {
+		return yield* new SetupFailure({ message: `baseline write refused:\n${adoption.reasons.map((reason) => `  - ${reason}`).join("\n")}` });
+	}
+	if (adoption.added === 0 && adoption.replaced === 0) {
+		return yield* Console.log(`quality: no error-level violations to record; ${session.config.baseline} is unchanged.`);
+	}
+	yield* save(session, adoption.entries);
+	const replaced = adoption.replaced > 0 ? `, replacing ${plural(adoption.replaced, "entry", "entries")}` : "";
+	yield* Console.log(`quality: recorded ${plural(adoption.added, "entry", "entries")} in ${session.config.baseline}${replaced}.`);
+});
 
-const changes = (pruned: Pruned): string => {
+function changes(pruned: Pruned): string {
 	const parts = [
 		`removed ${plural(pruned.removed, "entry", "entries")}`,
 		`lowered ${plural(pruned.lowered, "entry", "entries")}`,
 		...(pruned.moved > 0 ? [`carried ${plural(pruned.moved, "entry", "entries")} to moved files`] : []),
 	];
 	return `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}`;
-};
+}
 
-export const shrinkBaseline = <TRequirements>(
+export const shrinkBaseline = Effect.fn("Cli.shrinkBaseline")(function* <TRequirements>(
 	cwd: string,
 	config: string | undefined,
 	scopeOf: (session: Session) => Effect.Effect<Scope, SetupFailure, TRequirements>,
-): Effect.Effect<void, SetupFailure, FileSystem.FileSystem | TRequirements> =>
-	Effect.gen(function* () {
-		const session = yield* openSession(cwd, config);
-		if (session.baseline.raw === undefined) {
-			return yield* Console.log(`quality: no baseline at ${session.config.baseline}; nothing to lower.`);
-		}
-		const pruned = prune(session.baseline.entries, unregistered(session), session.config, yield* scopeOf(session));
-		if (pruned.removed === 0 && pruned.lowered === 0 && pruned.moved === 0) {
-			return yield* Console.log(`quality: ${session.config.baseline} is current.`);
-		}
-		yield* save(session, pruned.entries);
-		yield* Console.log(`quality: ${changes(pruned)} in ${session.config.baseline}.`);
-	});
+): Effect.fn.Return<void, SetupFailure, FileSystem.FileSystem | TRequirements> {
+	const session = yield* openSession(cwd, config);
+	if (session.baseline.raw === undefined) {
+		return yield* Console.log(`quality: no baseline at ${session.config.baseline}; nothing to lower.`);
+	}
+	const pruned = prune(session.baseline.entries, unregistered(session), session.config, yield* scopeOf(session));
+	if (pruned.removed === 0 && pruned.lowered === 0 && pruned.moved === 0) {
+		return yield* Console.log(`quality: ${session.config.baseline} is current.`);
+	}
+	yield* save(session, pruned.entries);
+	yield* Console.log(`quality: ${changes(pruned)} in ${session.config.baseline}.`);
+});

package/src/cli/fix.ts

@@ -62,24 +62,22 @@ function biomePasses(root: string, exceptions: readonly ExceptionDeclaration[]):
 	];
 }
 
-function round<TFailure, TRequirements>(
+const round = Effect.fn("Cli.round")(function* <TFailure, TRequirements>(
 	passes: readonly Pass<TFailure, TRequirements>[],
 	index: number,
 	afterEachPass: Effect.Effect<void, TFailure, TRequirements>,
-): Effect.Effect<number, TFailure, TRequirements> {
-	return Effect.gen(function* () {
-		let total = 0;
-		const parts: string[] = [];
-		for (const pass of passes) {
-			const changed = yield* pass.run;
-			total += changed;
-			parts.push(`${plural(changed, "file")} ${pass.label}`);
-			yield* afterEachPass;
-		}
-		yield* Console.log(`quality: Biome round ${index} rewrote ${parts.join(" and ")}.`);
-		return total;
-	});
-}
+): Effect.fn.Return<number, TFailure, TRequirements> {
+	let total = 0;
+	const parts: string[] = [];
+	for (const pass of passes) {
+		const changed = yield* pass.run;
+		total += changed;
+		parts.push(`${plural(changed, "file")} ${pass.label}`);
+		yield* afterEachPass;
+	}
+	yield* Console.log(`quality: Biome round ${index} rewrote ${parts.join(" and ")}.`);
+	return total;
+});
 
 function changedBetween(before: ReadonlyMap<string, string>, after: ReadonlyMap<string, string>): readonly string[] {
 	return [...new Set([...before.keys(), ...after.keys()])].filter((path) => before.get(path) !== after.get(path));
@@ -100,36 +98,35 @@ function unsettled(changed: ReadonlySet<string>): SetupFailure {
 	});
 }
 
-export function settle<TFailure, TRequirements>({
+export const settle = Effect.fn("Cli.settle")(function* <TFailure, TRequirements>({
 	passes,
 	snapshot,
-}: Settling<TFailure, TRequirements>): Effect.Effect<void, TFailure | SetupFailure, TRequirements> {
-	return Effect.gen(function* () {
-		for (let index = 1; index < MAX_FIX_ROUNDS; index += 1) {
-			if ((yield* round(passes, index, Effect.void)) === 0) {
-				return;
-			}
-		}
-		const changed = new Set<string>();
-		let previous = yield* snapshot;
-		const record = Effect.map(snapshot, (current) => {
-			for (const path of changedBetween(previous, current)) {
-				changed.add(path);
-			}
-			previous = current;
-		});
-		if ((yield* round(passes, MAX_FIX_ROUNDS, record)) === 0) {
+}: Settling<TFailure, TRequirements>): Effect.fn.Return<void, TFailure | SetupFailure, TRequirements> {
+	for (let index = 1; index < MAX_FIX_ROUNDS; index += 1) {
+		if ((yield* round(passes, index, Effect.void)) === 0) {
 			return;
 		}
-		return yield* unsettled(changed);
+	}
+	const changed = new Set<string>();
+	let previous = yield* snapshot;
+	const record = Effect.map(snapshot, (current) => {
+		for (const path of changedBetween(previous, current)) {
+			changed.add(path);
+		}
+		previous = current;
 	});
-}
+	if ((yield* round(passes, MAX_FIX_ROUNDS, record)) === 0) {
+		return;
+	}
+	return yield* unsettled(changed);
+});
 
-export function fix(cwd: string, config: string | undefined): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> {
-	return Effect.gen(function* () {
-		const { root, exceptions } = yield* loadConfig(cwd, config);
-		const sorted = yield* Effect.mapError(sortManifests(root), (failure) => new SetupFailure({ message: failure.message }));
-		yield* Console.log(`quality: sort-package-json rewrote ${plural(sorted, "manifest")}.`);
-		yield* settle({ passes: biomePasses(root, exceptions), snapshot: snapshotOf(root) });
-	});
-}
+export const fix = Effect.fn("Cli.fix")(function* (
+	cwd: string,
+	config: string | undefined,
+): Effect.fn.Return<void, SetupFailure, FileSystem.FileSystem> {
+	const { root, exceptions } = yield* loadConfig(cwd, config);
+	const sorted = yield* Effect.mapError(sortManifests(root), (failure) => new SetupFailure({ message: failure.message }));
+	yield* Console.log(`quality: sort-package-json rewrote ${plural(sorted, "manifest")}.`);
+	yield* settle({ passes: biomePasses(root, exceptions), snapshot: snapshotOf(root) });
+});

package/src/cli/lint.ts

@@ -5,25 +5,23 @@ import { openSession } from "#engine/session.ts";
 import { GateFailed, type SetupFailure } from "#failure.ts";
 import { render, type WarningDetail } from "#report/render.ts";
 
-export const lint = (
+export const lint = Effect.fn("Cli.lint")(function* (
 	cwd: string,
 	config: string | undefined,
 	warnings: WarningDetail,
-): Effect.Effect<void, SetupFailure | GateFailed, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const session = yield* openSession(cwd, config);
-		const outcome = evaluate(session.violations, session.registry, session.baseline.entries, session.config);
-		yield* Console.log(
-			render(outcome, {
-				baseline: session.config.baseline,
-				checked: session.inventory.sources.length,
-				descriptions: new Map(session.config.active.map((rule) => [rule.id, rule.description])),
-				registry:
-					session.config.exceptions.length === 0 ? session.config.registry : `${relative(session.config.root, session.config.file)} exceptions`,
-				warnings,
-			}),
-		);
-		if (!passes(outcome)) {
-			return yield* new GateFailed();
-		}
-	});
+): Effect.fn.Return<void, SetupFailure | GateFailed, FileSystem.FileSystem> {
+	const session = yield* openSession(cwd, config);
+	const outcome = evaluate(session.violations, session.registry, session.baseline.entries, session.config);
+	yield* Console.log(
+		render(outcome, {
+			baseline: session.config.baseline,
+			checked: session.inventory.sources.length,
+			descriptions: new Map(session.config.active.map((rule) => [rule.id, rule.description])),
+			registry: session.config.exceptions.length === 0 ? session.config.registry : `${relative(session.config.root, session.config.file)} exceptions`,
+			warnings,
+		}),
+	);
+	if (!passes(outcome)) {
+		return yield* new GateFailed();
+	}
+});

package/src/cli/migrate.ts

@@ -10,27 +10,26 @@ import { SetupFailure } from "#failure.ts";
 import { writeText } from "#inventory/filesystem.ts";
 import { plural } from "#report/plural.ts";
 
-export const migrateBaseline = (
+export const migrateBaseline = Effect.fn("Cli.migrateBaseline")(function* (
 	cwd: string,
 	configPath: string | undefined,
 	from: string | undefined,
-): Effect.Effect<void, SetupFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const config = yield* loadConfig(cwd, configPath);
-		const source = from ?? LEGACY_BASELINE;
-		if (source === config.baseline || (yield* readInput(config.root, config.baseline)) !== undefined) {
-			return yield* new SetupFailure({ message: `${config.baseline} already exists. Migrate into a baseline file that does not exist yet.` });
-		}
-		const raw = yield* readInput(config.root, source);
-		if (raw === undefined) {
-			return yield* new SetupFailure({ message: `no baseline at ${source} to migrate. Name it with --from <file>.` });
-		}
-		const legacy = yield* validOrFail(source, yield* Effect.promise(() => decodeLegacyBaseline(raw)));
-		const entries = convertLegacy(legacy, (yield* scan(config)).violations);
-		const fs = yield* FileSystem.FileSystem;
-		const written = Effect.andThen(writeText(join(config.root, config.baseline), encodeBaseline(entries)), fs.remove(join(config.root, source)));
-		yield* Effect.mapError(written, (failure) => new SetupFailure({ message: failure.message }));
-		const fixed = legacy.length - entries.length;
-		const dropped = fixed > 0 ? `, dropping ${plural(fixed, "fixed entry", "fixed entries")}` : "";
-		yield* Console.log(`quality: moved ${plural(entries.length, "entry", "entries")} from ${source} to ${config.baseline}${dropped}.`);
-	});
+): Effect.fn.Return<void, SetupFailure, FileSystem.FileSystem> {
+	const config = yield* loadConfig(cwd, configPath);
+	const source = from ?? LEGACY_BASELINE;
+	if (source === config.baseline || (yield* readInput(config.root, config.baseline)) !== undefined) {
+		return yield* new SetupFailure({ message: `${config.baseline} already exists. Migrate into a baseline file that does not exist yet.` });
+	}
+	const raw = yield* readInput(config.root, source);
+	if (raw === undefined) {
+		return yield* new SetupFailure({ message: `no baseline at ${source} to migrate. Name it with --from <file>.` });
+	}
+	const legacy = yield* validOrFail(source, yield* Effect.promise(() => decodeLegacyBaseline(raw)));
+	const entries = convertLegacy(legacy, (yield* scan(config)).violations);
+	const fs = yield* FileSystem.FileSystem;
+	const written = Effect.andThen(writeText(join(config.root, config.baseline), encodeBaseline(entries)), fs.remove(join(config.root, source)));
+	yield* Effect.mapError(written, (failure) => new SetupFailure({ message: failure.message }));
+	const fixed = legacy.length - entries.length;
+	const dropped = fixed > 0 ? `, dropping ${plural(fixed, "fixed entry", "fixed entries")}` : "";
+	yield* Console.log(`quality: moved ${plural(entries.length, "entry", "entries")} from ${source} to ${config.baseline}${dropped}.`);
+});

package/src/cli/run-main.ts

@@ -30,9 +30,9 @@ export function exitCode(exit: Exit.Exit<unknown, unknown>): number {
 	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";

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