@shivaedev/quality 0.22.0 → 0.24.0

package/src/engine/violation.ts

@@ -8,12 +8,15 @@ export interface Violation extends Finding {
 	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;
-};
+}

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

package/src/git/base.ts

@@ -9,54 +9,62 @@ export interface Base {
 
 const FALLBACK_BRANCHES = ["origin/main", "origin/master"];
 
-const fail = (message: string) => Effect.fail(new SetupFailure({ message }));
+function fail(message: string) {
+	return Effect.fail(new SetupFailure({ message }));
+}
 
-const isCommit = (root: string, ref: string): Effect.Effect<boolean, SetupFailure, Git> =>
-	Effect.map(git(root, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]), (result) => result.code === 0);
+function isCommit(root: string, ref: string): Effect.Effect<boolean, SetupFailure, Git> {
+	return Effect.map(git(root, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]), (result) => result.code === 0);
+}
 
-const defaultBranch = (root: string): Effect.Effect<string, SetupFailure, Git> =>
-	Effect.gen(function* () {
-		const head = yield* git(root, ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]);
-		if (head.code === 0) {
-			return head.stdout.trim();
-		}
-		for (const candidate of FALLBACK_BRANCHES) {
-			if (yield* isCommit(root, candidate)) {
-				return candidate;
-			}
+const defaultBranch = Effect.fn("Git.defaultBranch")(function* (root: string): Effect.fn.Return<string, SetupFailure, Git> {
+	const head = yield* git(root, ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]);
+	if (head.code === 0) {
+		return head.stdout.trim();
+	}
+	for (const candidate of FALLBACK_BRANCHES) {
+		if (yield* isCommit(root, candidate)) {
+			return candidate;
 		}
-		return yield* fail(
-			"cannot find the default branch: origin/HEAD, origin/main and origin/master are missing. Pass --against <ref>, or run `git remote set-head origin --auto`.",
-		);
-	});
+	}
+	return yield* fail(
+		"cannot find the default branch: origin/HEAD, origin/main and origin/master are missing. Pass --against <ref>, or run `git remote set-head origin --auto`.",
+	);
+});
 
-const isShallow = (root: string): Effect.Effect<boolean, SetupFailure, Git> =>
-	Effect.map(git(root, ["rev-parse", "--is-shallow-repository"]), (result) => result.stdout.trim() === "true");
+function isShallow(root: string): Effect.Effect<boolean, SetupFailure, Git> {
+	return Effect.map(git(root, ["rev-parse", "--is-shallow-repository"]), (result) => result.stdout.trim() === "true");
+}
 
-const mergeBase = (root: string, ref: string): Effect.Effect<string | undefined, SetupFailure, Git> =>
-	Effect.map(git(root, ["merge-base", "HEAD", ref]), (result) => (result.code === 0 ? result.stdout.trim() : undefined));
+function mergeBase(root: string, ref: string): Effect.Effect<string | undefined, SetupFailure, Git> {
+	return Effect.map(git(root, ["merge-base", "HEAD", ref]), (result) => (result.code === 0 ? result.stdout.trim() : undefined));
+}
 
-const missingMergeBase = (root: string, ref: string): Effect.Effect<never, SetupFailure, Git> =>
-	Effect.flatMap(isShallow(root), (shallow) =>
+function missingMergeBase(root: string, ref: string): Effect.Effect<never, SetupFailure, Git> {
+	return Effect.flatMap(isShallow(root), (shallow) =>
 		fail(
 			shallow
 				? `the clone is shallow and does not reach the merge base of HEAD and ${ref}. Fetch the history first: \`git fetch --unshallow\`.`
 				: `HEAD and ${ref} share no history.`,
 		),
 	);
+}
 
-const reachMergeBase = (root: string, ref: string): Effect.Effect<string, SetupFailure, Git> =>
-	Effect.flatMap(mergeBase(root, ref), (found) => (found === undefined ? missingMergeBase(root, ref) : Effect.succeed(found)));
+function reachMergeBase(root: string, ref: string): Effect.Effect<string, SetupFailure, Git> {
+	return Effect.flatMap(mergeBase(root, ref), (found) => (found === undefined ? missingMergeBase(root, ref) : Effect.succeed(found)));
+}
 
-export const resolveBase = (root: string, against: string | undefined): Effect.Effect<Base, SetupFailure, Git> =>
-	Effect.gen(function* () {
-		const inside = yield* git(root, ["rev-parse", "--is-inside-work-tree"]);
-		if (inside.code !== 0 || inside.stdout.trim() !== "true") {
-			return yield* fail(`${root} is not in a git work tree; moves are followed through git history.`);
-		}
-		const ref = against ?? (yield* defaultBranch(root));
-		if (!(yield* isCommit(root, ref))) {
-			return yield* fail(`${ref} names no commit in this clone. Fetch it first, or pass another --against <ref>.`);
-		}
-		return { commit: yield* reachMergeBase(root, ref), ref };
-	});
+export const resolveBase = Effect.fn("Git.resolveBase")(function* (
+	root: string,
+	against: string | undefined,
+): Effect.fn.Return<Base, SetupFailure, Git> {
+	const inside = yield* git(root, ["rev-parse", "--is-inside-work-tree"]);
+	if (inside.code !== 0 || inside.stdout.trim() !== "true") {
+		return yield* fail(`${root} is not in a git work tree; moves are followed through git history.`);
+	}
+	const ref = against ?? (yield* defaultBranch(root));
+	if (!(yield* isCommit(root, ref))) {
+		return yield* fail(`${ref} names no commit in this clone. Fetch it first, or pass another --against <ref>.`);
+	}
+	return { commit: yield* reachMergeBase(root, ref), ref };
+});

package/src/git/command.ts

@@ -10,8 +10,8 @@ export interface GitResult {
 
 export type Git = ChildProcessSpawner.ChildProcessSpawner;
 
-export const git = (cwd: string, args: readonly string[]): Effect.Effect<GitResult, SetupFailure, Git> =>
-	Effect.scoped(
+export function git(cwd: string, args: readonly string[]): Effect.Effect<GitResult, SetupFailure, Git> {
+	return Effect.scoped(
 		Effect.gen(function* () {
 			const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
 			const child = yield* spawner.spawn(ChildProcess.make("git", [...args], { cwd, stdin: "ignore" }));
@@ -22,10 +22,12 @@ export const git = (cwd: string, args: readonly string[]): Effect.Effect<GitResu
 			return { code: Number(code), stderr, stdout };
 		}),
 	).pipe(Effect.mapError((error) => new SetupFailure({ message: `cannot run git: ${error.message}` })));
+}
 
-export const gitOrFail = (cwd: string, args: readonly string[]): Effect.Effect<string, SetupFailure, Git> =>
-	Effect.flatMap(git(cwd, args), (result) =>
+export function gitOrFail(cwd: string, args: readonly string[]): Effect.Effect<string, SetupFailure, Git> {
+	return Effect.flatMap(git(cwd, args), (result) =>
 		result.code === 0
 			? Effect.succeed(result.stdout)
 			: Effect.fail(new SetupFailure({ message: `git ${args[0]} failed: ${result.stderr.trim() || `exit code ${result.code}`}` })),
 	);
+}

package/src/git/history.ts

@@ -7,7 +7,7 @@ export interface Changes {
 	readonly moves: ReadonlyMap<string, string>;
 }
 
-const parse = (output: string): Changes => {
+function parse(output: string): Changes {
 	const fields = output.split("\0");
 	const files = new Set<string>();
 	const moves = new Map<string, string>();
@@ -24,11 +24,12 @@ const parse = (output: string): Changes => {
 		index += paths.length + 1;
 	}
 	return { files, moves };
-};
+}
 
 // Paths are relative to the root, and only tracked files count: a move is seen once both of its sides are staged.
-export const changesSince = (root: string, revision: readonly string[]): Effect.Effect<Changes, SetupFailure, Git> =>
-	Effect.map(
+export function changesSince(root: string, revision: readonly string[]): Effect.Effect<Changes, SetupFailure, Git> {
+	return Effect.map(
 		gitOrFail(root, ["diff", "--no-color", "--no-ext-diff", "--find-renames", "--name-status", "-z", "--relative", ...revision, "--"]),
 		parse,
 	);
+}

package/src/inventory/collect.ts

@@ -19,42 +19,47 @@ export interface Inventory {
 
 const READ_CONCURRENCY = 16;
 
-export const linesOf = (text: string): readonly string[] => {
+export function linesOf(text: string): readonly string[] {
 	const lines = text.split("\n");
 	return lines.at(-1) === "" ? lines.slice(0, -1) : lines;
-};
+}
 
-const zoneFiles = (root: string, zone: string): Effect.Effect<readonly string[], FilesystemFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		const path = join(root, zone);
-		if (posix(relative(root, path)).startsWith("..")) {
-			return yield* new FilesystemFailure({ message: `source "${zone}" lies outside the repository at ${root}`, path });
-		}
-		const info = yield* orWhenAbsent<FileSystem.File.Info | undefined>(path, fs.stat(path), undefined);
-		if (info === undefined) {
-			return yield* new FilesystemFailure({ message: `source "${zone}" does not exist in ${root}`, path });
-		}
-		return info.type === "Directory" ? yield* walk(path, yield* scopeAbove(root, path)) : [path];
-	});
+const zoneFiles = Effect.fn("Inventory.zoneFiles")(function* (
+	root: string,
+	zone: string,
+): Effect.fn.Return<readonly string[], FilesystemFailure, FileSystem.FileSystem> {
+	const fs = yield* FileSystem.FileSystem;
+	const path = join(root, zone);
+	if (posix(relative(root, path)).startsWith("..")) {
+		return yield* new FilesystemFailure({ message: `source "${zone}" lies outside the repository at ${root}`, path });
+	}
+	const info = yield* orWhenAbsent<FileSystem.File.Info | undefined>(path, fs.stat(path), undefined);
+	if (info === undefined) {
+		return yield* new FilesystemFailure({ message: `source "${zone}" does not exist in ${root}`, path });
+	}
+	return info.type === "Directory" ? yield* walk(path, yield* scopeAbove(root, path)) : [path];
+});
 
-const readSource = (root: string, path: string): Effect.Effect<SourceFile, FilesystemFailure, FileSystem.FileSystem> =>
-	Effect.map(readRequiredText(join(root, path)), (text) => ({ lines: linesOf(text), path, text }));
+function readSource(root: string, path: string): Effect.Effect<SourceFile, FilesystemFailure, FileSystem.FileSystem> {
+	return Effect.map(readRequiredText(join(root, path)), (text) => ({ lines: linesOf(text), path, text }));
+}
 
-export const collectInventory = (root: string, scope: InventoryScope): Effect.Effect<Inventory, FilesystemFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const excluded = ignore().add([...scope.exclude]);
-		const zones = yield* Effect.forEach(scope.sources, (zone) => zoneFiles(root, zone), { concurrency: READ_CONCURRENCY });
-		const relativePaths = zones.flat().map((absolute) => posix(relative(root, absolute)));
-		const files = [...new Set(relativePaths)]
-			.filter((path) => !excluded.ignores(path))
-			.sort((left, right) => {
-				if (left === right) {
-					return 0;
-				}
-				return left < right ? -1 : 1;
-			});
-		const sourcePaths = files.filter((path) => scope.extensions.some((extension) => path.endsWith(extension)));
-		const sources = yield* Effect.forEach(sourcePaths, (path) => readSource(root, path), { concurrency: READ_CONCURRENCY });
-		return { files, sources };
-	});
+export const collectInventory = Effect.fn("Inventory.collectInventory")(function* (
+	root: string,
+	scope: InventoryScope,
+): Effect.fn.Return<Inventory, FilesystemFailure, FileSystem.FileSystem> {
+	const excluded = ignore().add([...scope.exclude]);
+	const zones = yield* Effect.forEach(scope.sources, (zone) => zoneFiles(root, zone), { concurrency: READ_CONCURRENCY });
+	const relativePaths = zones.flat().map((absolute) => posix(relative(root, absolute)));
+	const files = [...new Set(relativePaths)]
+		.filter((path) => !excluded.ignores(path))
+		.sort((left, right) => {
+			if (left === right) {
+				return 0;
+			}
+			return left < right ? -1 : 1;
+		});
+	const sourcePaths = files.filter((path) => scope.extensions.some((extension) => path.endsWith(extension)));
+	const sources = yield* Effect.forEach(sourcePaths, (path) => readSource(root, path), { concurrency: READ_CONCURRENCY });
+	return { files, sources };
+});

package/src/inventory/filesystem.ts

@@ -10,38 +10,46 @@ export class FilesystemFailure extends Data.TaggedError("FilesystemFailure")<{
 }> {}
 
 // Effect maps ENOTDIR and EISDIR to BadResource; the original errno remains on the cause.
-const errnoOf = (error: PlatformError): string => {
+function errnoOf(error: PlatformError): string {
 	const cause: unknown = error.reason.cause;
 	return typeof cause === "object" && cause !== null && "code" in cause && typeof cause.code === "string" ? cause.code : "";
-};
+}
 
-const failure = (path: string, error: PlatformError): FilesystemFailure =>
-	new FilesystemFailure({ message: `cannot read ${path}: ${error.message}`, path });
+function failure(path: string, error: PlatformError): FilesystemFailure {
+	return new FilesystemFailure({ message: `cannot read ${path}: ${error.message}`, path });
+}
 
-export const orWhenAbsent = <Value>(
+export function orWhenAbsent<TValue>(
 	path: string,
-	action: Effect.Effect<Value, PlatformError, FileSystem.FileSystem>,
-	whenAbsent: Value,
-): Effect.Effect<Value, FilesystemFailure, FileSystem.FileSystem> =>
-	Effect.catchTag(action, "PlatformError", (error) => (ABSENT.has(errnoOf(error)) ? Effect.succeed(whenAbsent) : Effect.fail(failure(path, error))));
-
-export const readOptionalText = (path: string): Effect.Effect<string | undefined, FilesystemFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		return yield* orWhenAbsent<string | undefined>(path, fs.readFileString(path), undefined);
-	});
-
-export const readRequiredText = (path: string): Effect.Effect<string, FilesystemFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		return yield* Effect.mapError(fs.readFileString(path), (error) =>
-			ABSENT.has(errnoOf(error)) ? new FilesystemFailure({ message: `required input is missing: ${path}`, path }) : failure(path, error),
-		);
-	});
-
-export const writeText = (path: string, text: string): Effect.Effect<void, FilesystemFailure, FileSystem.FileSystem> =>
-	Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		const written = Effect.andThen(fs.makeDirectory(dirname(path), { recursive: true }), fs.writeFileString(path, text));
-		return yield* Effect.mapError(written, (error) => new FilesystemFailure({ message: `cannot write ${path}: ${error.message}`, path }));
-	});
+	action: Effect.Effect<TValue, PlatformError, FileSystem.FileSystem>,
+	whenAbsent: TValue,
+): Effect.Effect<TValue, FilesystemFailure, FileSystem.FileSystem> {
+	return Effect.catchTag(action, "PlatformError", (error) =>
+		ABSENT.has(errnoOf(error)) ? Effect.succeed(whenAbsent) : Effect.fail(failure(path, error)),
+	);
+}
+
+export const readOptionalText = Effect.fn("Inventory.readOptionalText")(function* (
+	path: string,
+): Effect.fn.Return<string | undefined, FilesystemFailure, FileSystem.FileSystem> {
+	const fs = yield* FileSystem.FileSystem;
+	return yield* orWhenAbsent<string | undefined>(path, fs.readFileString(path), undefined);
+});
+
+export const readRequiredText = Effect.fn("Inventory.readRequiredText")(function* (
+	path: string,
+): Effect.fn.Return<string, FilesystemFailure, FileSystem.FileSystem> {
+	const fs = yield* FileSystem.FileSystem;
+	return yield* Effect.mapError(fs.readFileString(path), (error) =>
+		ABSENT.has(errnoOf(error)) ? new FilesystemFailure({ message: `required input is missing: ${path}`, path }) : failure(path, error),
+	);
+});
+
+export const writeText = Effect.fn("Inventory.writeText")(function* (
+	path: string,
+	text: string,
+): Effect.fn.Return<void, FilesystemFailure, FileSystem.FileSystem> {
+	const fs = yield* FileSystem.FileSystem;
+	const written = Effect.andThen(fs.makeDirectory(dirname(path), { recursive: true }), fs.writeFileString(path, text));
+	return yield* Effect.mapError(written, (error) => new FilesystemFailure({ message: `cannot write ${path}: ${error.message}`, path }));
+});

package/src/inventory/ignore-scope.ts

@@ -15,17 +15,23 @@ export interface IgnoreScope {
 
 export const emptyScope: IgnoreScope = { boundary: undefined, matchers: [] };
 
-export const posix = (path: string): string => path.replaceAll("\\", "/");
+export function posix(path: string): string {
+	return path.replaceAll("\\", "/");
+}
 
-export const withIgnoreFile = (scope: IgnoreScope, base: string, contents: string): IgnoreScope => ({
-	boundary: scope.boundary,
-	matchers: [...scope.matchers, { base, rules: ignore().add(contents) }],
-});
+export function withIgnoreFile(scope: IgnoreScope, base: string, contents: string): IgnoreScope {
+	return {
+		boundary: scope.boundary,
+		matchers: [...scope.matchers, { base, rules: ignore().add(contents) }],
+	};
+}
 
 // Re-including a directory resets directory rules below that boundary; filename rules still apply.
-export const insideKept = (scope: IgnoreScope, directory: string): IgnoreScope => ({ boundary: directory, matchers: scope.matchers });
+export function insideKept(scope: IgnoreScope, directory: string): IgnoreScope {
+	return { boundary: directory, matchers: scope.matchers };
+}
 
-const matcherVerdict = (matcher: IgnoreMatcher, boundary: string | undefined, path: string, directory: boolean): Verdict => {
+function matcherVerdict(matcher: IgnoreMatcher, boundary: string | undefined, path: string, directory: boolean): Verdict {
 	const anchor = boundary !== undefined && boundary.length > matcher.base.length ? boundary : matcher.base;
 	const rel = posix(relative(anchor, path));
 	if (rel === "" || rel.startsWith("..")) {
@@ -37,7 +43,11 @@ const matcherVerdict = (matcher: IgnoreMatcher, boundary: string | undefined, pa
 		return "ignored";
 	}
 	return result.unignored ? "kept" : "unknown";
-};
+}
 
-export const verdictFor = (scope: IgnoreScope, path: string, directory: boolean): Verdict =>
-	scope.matchers.map((matcher) => matcherVerdict(matcher, scope.boundary, path, directory)).findLast((verdict) => verdict !== "unknown") ?? "unknown";
+export function verdictFor(scope: IgnoreScope, path: string, directory: boolean): Verdict {
+	return (
+		scope.matchers.map((matcher) => matcherVerdict(matcher, scope.boundary, path, directory)).findLast((verdict) => verdict !== "unknown")
+		?? "unknown"
+	);
+}

package/src/manifests/sorted.ts

@@ -26,21 +26,21 @@ export function sortingOf(text: string): Sorting {
 	return sorted === text ? { _tag: "Sorted" } : { _tag: "Unsorted", sorted };
 }
 
-export function sortManifests(root: string): Effect.Effect<number, FilesystemFailure, FileSystem.FileSystem> {
-	return Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		const manifests = yield* manifestsIn(root);
-		const written = yield* Effect.forEach(manifests, (path) =>
-			Effect.gen(function* () {
-				const absolute = join(root, path);
-				const sorting = sortingOf(yield* fs.readFileString(absolute));
-				if (sorting._tag !== "Unsorted") {
-					return false;
-				}
-				yield* fs.writeFileString(absolute, sorting.sorted);
-				return true;
-			}).pipe(Effect.mapError((error) => new FilesystemFailure({ message: `cannot sort ${path}: ${error.message}`, path }))),
-		);
-		return written.filter(Boolean).length;
-	});
-}
+export const sortManifests = Effect.fn("Manifests.sortManifests")(function* (
+	root: string,
+): Effect.fn.Return<number, FilesystemFailure, FileSystem.FileSystem> {
+	const fs = yield* FileSystem.FileSystem;
+	const manifests = yield* manifestsIn(root);
+	const written = yield* Effect.forEach(manifests, (path) =>
+		Effect.gen(function* () {
+			const absolute = join(root, path);
+			const sorting = sortingOf(yield* fs.readFileString(absolute));
+			if (sorting._tag !== "Unsorted") {
+				return false;
+			}
+			yield* fs.writeFileString(absolute, sorting.sorted);
+			return true;
+		}).pipe(Effect.mapError((error) => new FilesystemFailure({ message: `cannot sort ${path}: ${error.message}`, path }))),
+	);
+	return written.filter(Boolean).length;
+});

package/src/report/plural.ts

@@ -1 +1,3 @@
-export const plural = (count: number, singular: string, many = `${singular}s`): string => `${count} ${count === 1 ? singular : many}`;
+export function plural(count: number, singular: string, many = `${singular}s`): string {
+	return `${count} ${count === 1 ? singular : many}`;
+}

package/src/report/render.ts

@@ -16,18 +16,21 @@ export interface ReportContext {
 
 const LISTED_FILES = 5;
 
-const locate = (violation: Violation): string => (violation.line === undefined ? violation.file : `${violation.file}:${violation.line}`);
+function locate(violation: Violation): string {
+	return violation.line === undefined ? violation.file : `${violation.file}:${violation.line}`;
+}
 
-const regressionNote = (regression: Regression): string =>
-	`  ${regression.entry.file} is over its baseline: ${regression.count} against ${regression.entry.count} baselined.`;
+function regressionNote(regression: Regression): string {
+	return `  ${regression.entry.file} is over its baseline: ${regression.count} against ${regression.entry.count} baselined.`;
+}
 
-const heading = (label: string, rule: string, violations: readonly Violation[], context: ReportContext): readonly string[] => {
+function heading(label: string, rule: string, violations: readonly Violation[], context: ReportContext): readonly string[] {
 	const description = context.descriptions.get(rule);
 	return [`${label} ${rule} (${violations.length})`, ...(description === undefined ? [] : [`  ${description}`])];
-};
+}
 
-const detailed = (violations: readonly Violation[], regressions: ReadonlyMap<string, Regression>): readonly string[] =>
-	[...groupBy(violations, (violation) => violation.file).values()].flatMap((inFile) => {
+function detailed(violations: readonly Violation[], regressions: ReadonlyMap<string, Regression>): readonly string[] {
+	return [...groupBy(violations, (violation) => violation.file).values()].flatMap((inFile) => {
 		const first = inFile[0];
 		const regression = first === undefined ? undefined : regressions.get(keyOf(first.rule, first.file));
 		return [
@@ -35,33 +38,35 @@ const detailed = (violations: readonly Violation[], regressions: ReadonlyMap<str
 			...(regression === undefined ? [] : [regressionNote(regression)]),
 		];
 	});
+}
 
-const summarized = (violations: readonly Violation[]): readonly string[] => {
+function summarized(violations: readonly Violation[]): readonly string[] {
 	const files = [...groupBy(violations, (violation) => violation.file).entries()].sort(([, left], [, right]) => right.length - left.length);
 	const listed = files.slice(0, LISTED_FILES).map(([file, inFile]) => `${file} (${inFile.length})`);
 	const rest = files.length - listed.length;
 	return [`  ${listed.join(", ")}${rest > 0 ? `, and ${plural(rest, "more file", "more files")}` : ""}. --warnings all lists each one.`];
-};
+}
 
-const ruleSections = (
+function ruleSections(
 	label: string,
 	violations: readonly Violation[],
 	context: ReportContext,
 	body: (inRule: readonly Violation[]) => readonly string[],
-): readonly string[] =>
-	[...groupBy(violations, (violation) => violation.rule).entries()].map(([rule, inRule]) =>
+): readonly string[] {
+	return [...groupBy(violations, (violation) => violation.rule).entries()].map(([rule, inRule]) =>
 		[...heading(label, rule, inRule, context), ...body(inRule)].join("\n"),
 	);
+}
 
-const failures = (outcome: Outcome): string => {
+function failures(outcome: Outcome): string {
 	const stale = outcome.staleBaseline.length + outcome.staleRegistry.length;
 	return [
 		...(outcome.errors.length > 0 ? [plural(outcome.errors.length, "error")] : []),
 		...(stale > 0 ? [plural(stale, "stale entry", "stale entries")] : []),
 	].join(" and ");
-};
+}
 
-const summary = (outcome: Outcome, context: ReportContext): string => {
+function summary(outcome: Outcome, context: ReportContext): string {
 	const verdict = passes(outcome) ? "quality: passed" : `quality: failed with ${failures(outcome)}`;
 	const warnings = outcome.warnings.length > 0 ? `; ${plural(outcome.warnings.length, "warning")} from rules still at warn` : "";
 	const hidden = [
@@ -71,7 +76,7 @@ const summary = (outcome: Outcome, context: ReportContext): string => {
 	const suppressed =
 		hidden.length === 0 ? "" : `; ${hidden.join(" and ")} ${outcome.baselined + outcome.registered === 1 ? "violation" : "violations"} not shown`;
 	return `${verdict}${warnings}. ${plural(context.checked, "source file")} checked${suppressed}.`;
-};
+}
 
 function rerecord(outcome: Outcome): readonly string[] {
 	const rules = [...new Set(outcome.errors.map((violation) => violation.rule))].sort((left, right) => left.localeCompare(right));
@@ -84,7 +89,7 @@ function rerecord(outcome: Outcome): readonly string[] {
 	];
 }
 
-export const render = (outcome: Outcome, context: ReportContext): string => {
+export function render(outcome: Outcome, context: ReportContext): string {
 	const regressions = new Map(outcome.regressions.map((regression) => [keyOf(regression.entry.rule, regression.entry.file), regression]));
 	const warningBody = context.warnings === "all" ? (inRule: readonly Violation[]) => detailed(inRule, regressions) : summarized;
 	return [
@@ -94,4 +99,4 @@ export const render = (outcome: Outcome, context: ReportContext): string => {
 		summary(outcome, context),
 		...rerecord(outcome),
 	].join("\n\n");
-};
+}