@shivaedev/quality 0.23.0 → 0.25.0

package/src/rules/stories/prerequisites.ts

@@ -0,0 +1,37 @@
+import { posix } from "node:path";
+import type { WorkspacePackage } from "#imports/workspace.ts";
+import type { RuleInputs } from "#rule.ts";
+
+const DEPENDENCIES = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"];
+
+function object(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function manifest(text: string | undefined): Record<string, unknown> {
+	const value: unknown = JSON.parse(text ?? "{}");
+	return object(value) ? value : {};
+}
+
+export async function storyPrerequisites(inputs: RuleInputs, packages: readonly WorkspacePackage[]): Promise<ReadonlySet<string>> {
+	const root = manifest(await inputs.readText("package.json"));
+	const members = typeof root.name === "string" ? [...packages, { directory: "", name: root.name }] : packages;
+	const byName = new Map(members.map((member) => [member.name, member]));
+	const pending = ["@shivaedev/test-story"];
+	const directories = new Set<string>();
+	while (pending.length > 0) {
+		const current = byName.get(pending.pop() ?? "");
+		if (current === undefined || directories.has(current.directory)) {
+			continue;
+		}
+		directories.add(current.directory);
+		const value = manifest(await inputs.readText(posix.join(current.directory, "package.json")));
+		for (const key of DEPENDENCIES) {
+			const dependencies = value[key];
+			if (object(dependencies)) {
+				pending.push(...Object.keys(dependencies).filter((name) => byName.has(name)));
+			}
+		}
+	}
+	return directories;
+}

package/src/rules/stories/program.ts

@@ -0,0 +1,29 @@
+import { join } from "node:path";
+import ts from "typescript";
+import type { ImportGraph } from "#imports/graph.ts";
+import type { RuleInputs } from "#rule.ts";
+
+export function storyProgram(inputs: RuleInputs, graph: ImportGraph): ts.Program {
+	const sources = new Map(inputs.sources.map((file) => [join(inputs.root, file.path), file.text]));
+	const targets = new Map(
+		graph.edges.flatMap((edge) =>
+			edge.to.kind === "file" ? [[`${join(inputs.root, edge.from)}:${edge.specifier}`, join(inputs.root, edge.to.path)] as const] : [],
+		),
+	);
+	const options: ts.CompilerOptions = { allowJs: true, noLib: true, types: [] };
+	const host: ts.CompilerHost = {
+		...ts.createCompilerHost(options),
+		fileExists: (path) => sources.has(path),
+		getSourceFile: (path) => {
+			const text = sources.get(path);
+			return text === undefined ? undefined : ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true);
+		},
+		readFile: (path) => sources.get(path),
+		resolveModuleNames: (names, from) =>
+			names.map((name) => {
+				const path = targets.get(`${from}:${name}`);
+				return path === undefined ? undefined : { extension: ts.Extension.Ts, resolvedFileName: path };
+			}),
+	};
+	return ts.createProgram([...sources.keys()], options, host);
+}

package/src/rules/stories/specs.ts

@@ -0,0 +1,93 @@
+import ts from "typescript";
+import { importGraph } from "#imports/graph.ts";
+import { packageOf } from "#imports/workspace.ts";
+import { testName } from "#naming/testName.ts";
+import { defineRule } from "#rule.ts";
+import { storyOrigins } from "./origins.ts";
+import { storyPrerequisites } from "./prerequisites.ts";
+
+function namesTest(node: ts.Expression): boolean {
+	if (ts.isIdentifier(node)) {
+		return node.text === "it" || node.text === "test";
+	}
+	if (ts.isPropertyAccessExpression(node)) {
+		return node.name.text === "it" || namesTest(node.expression);
+	}
+	return ts.isCallExpression(node) && namesTest(node.expression);
+}
+
+type OriginOf = ReturnType<typeof storyOrigins>["origin"];
+
+function callback(node: ts.Node, origin: OriginOf): boolean {
+	return (
+		ts.isArrowFunction(node)
+		|| ts.isFunctionExpression(node)
+		|| ((ts.isIdentifier(node) || ts.isPropertyAccessExpression(node)) && origin(node) === "function")
+	);
+}
+
+function testShaped(call: ts.CallExpression, origin: OriginOf): boolean {
+	const title = call.arguments[0];
+	return (
+		title !== undefined
+		&& (ts.isStringLiteralLike(title) || ts.isTemplateExpression(title))
+		&& call.arguments.slice(1).some((argument) => callback(argument, origin))
+	);
+}
+
+function declarationScope(node: ts.Node, origin: OriginOf): boolean {
+	for (let current = node.parent; current !== undefined; current = current.parent) {
+		if (ts.isFunctionLike(current) && (!ts.isCallExpression(current.parent) || origin(current.parent.expression) !== "suite")) {
+			return false;
+		}
+	}
+	return true;
+}
+
+function uncoveredRegistration(call: ts.CallExpression, originOf: OriginOf): boolean {
+	const origin = originOf(call.expression);
+	if (origin === "story" || origin === "suite") {
+		return false;
+	}
+	return origin === "plain" || ((namesTest(call.expression) || testShaped(call, originOf)) && declarationScope(call, originOf));
+}
+
+export const storySpecs = defineRule({
+	check: async (inputs) => {
+		const graph = await importGraph(inputs);
+		const exempt = await storyPrerequisites(inputs, graph.packages);
+		const origins = storyOrigins(inputs, graph);
+		return inputs.sources.flatMap((file) => {
+			const name = testName(file.path);
+			const owner = packageOf(graph.packages, file.path);
+			if (name === undefined || name.modifiers.includes("typecheck") || exempt.has(owner?.directory ?? "")) {
+				return [];
+			}
+			const source = origins.source(file.path);
+			let plain: ts.CallExpression | undefined;
+			function visit(node: ts.Node): void {
+				if (ts.isCallExpression(node) && uncoveredRegistration(node, origins.origin)) {
+					plain ??= node;
+				}
+				ts.forEachChild(node, visit);
+			}
+			if (source !== undefined) {
+				visit(source);
+			}
+			if (source === undefined || plain === undefined) {
+				return [];
+			}
+			return [
+				{
+					file: file.path,
+					line: source.getLineAndCharacterOfPosition(plain.getStart(source)).line + 1,
+					message:
+						"Declares tests without a test-story story kit. Build the package's kit with storyKit from @shivaedev/test-story/storyKit.ts in src/test-support, and declare every test through the kit's it. See https://github.com/ShivaeDev/platform/tree/main/packages/quality#story-tests.",
+				},
+			];
+		});
+	},
+	description:
+		"Every package tests its real engine through its own test-story kit. Typecheck tests and test-story's workspace prerequisites are exempt.",
+	id: "tests/story-specs",
+});

package/src/rules/suppressions/biome/configs.ts

@@ -35,23 +35,27 @@ const NESTED = /(?:^|\/)biome\.jsonc?$/u;
 
 const RELATIVE = /^\.\.?(?:\/|$)/u;
 
-const directoryOf = (path: string): string => (posix.dirname(path) === "." ? "" : posix.dirname(path));
+function directoryOf(path: string): string {
+	return posix.dirname(path) === "." ? "" : posix.dirname(path);
+}
 
-const read = async (readText: ReadText, path: string): Promise<Parsed> => {
+async function read(readText: ReadText, path: string): Promise<Parsed> {
 	const text = await readText(path);
 	return text === undefined ? { _tag: "Unreadable", reason: "the file does not exist" } : parseJsonc(path, text);
-};
+}
 
-const problem = (file: string, message: string, line?: number): Loaded => ({ layers: [], problems: [{ file, line, message }] });
+function problem(file: string, message: string, line?: number): Loaded {
+	return { layers: [], problems: [{ file, line, message }] };
+}
 
-const local = async (readText: ReadText, path: string): Promise<Loaded> => {
+async function local(readText: ReadText, path: string): Promise<Loaded> {
 	const parsed = await read(readText, path);
 	return parsed._tag === "Parsed"
 		? { layers: [{ json: parsed.json, path, preset: undefined }], problems: [] }
 		: problem(path, `Cannot read this Biome config: ${parsed.reason}.`);
-};
+}
 
-const fromPackage = async (readText: ReadText, from: string, entry: Json, specifier: string): Promise<Loaded> => {
+async function fromPackage(readText: ReadText, from: string, entry: Json, specifier: string): Promise<Loaded> {
 	const target = await resolvePackage(readText, specifier);
 	if (target === undefined) {
 		return problem(from, `Cannot resolve the Biome config "${specifier}" from node_modules.`, entry.line);
@@ -67,9 +71,9 @@ const fromPackage = async (readText: ReadText, from: string, entry: Json, specif
 	}
 	const preset = { declared: declared.value, file: from, line: entry.line, specifier };
 	return { layers: [{ json: parsed.json, path: target, preset }], problems: [] };
-};
+}
 
-const extended = async (readText: ReadText, from: string, entry: Json): Promise<Loaded> => {
+async function extended(readText: ReadText, from: string, entry: Json): Promise<Loaded> {
 	const specifier = textOf(entry);
 	if (specifier === undefined || specifier === "//") {
 		return { layers: [], problems: [] };
@@ -79,11 +83,13 @@ const extended = async (readText: ReadText, from: string, entry: Json): Promise<
 	}
 	const relative = posix.normalize(specifier);
 	return (await readText(relative)) === undefined ? fromPackage(readText, from, entry, specifier) : local(readText, relative);
-};
+}
 
-const extendsOf = (json: Json): readonly Json[] => itemsOf(member(json, "extends"));
+function extendsOf(json: Json): readonly Json[] {
+	return itemsOf(member(json, "extends"));
+}
 
-const chainOf = async (readText: ReadText, path: string): Promise<Loaded> => {
+async function chainOf(readText: ReadText, path: string): Promise<Loaded> {
 	const own = await local(readText, path);
 	const [layer] = own.layers;
 	if (layer === undefined) {
@@ -91,12 +97,12 @@ const chainOf = async (readText: ReadText, path: string): Promise<Loaded> => {
 	}
 	const parents = await Promise.all(extendsOf(layer.json).map((entry) => extended(readText, path, entry)));
 	return { layers: [...parents.flatMap((parent) => parent.layers), layer], problems: parents.flatMap((parent) => parent.problems) };
-};
+}
 
-const rootConfig = async (readText: ReadText): Promise<string | undefined> => {
+async function rootConfig(readText: ReadText): Promise<string | undefined> {
 	const present = await Promise.all(ROOT_CONFIGS.map(async (path) => ((await readText(path)) === undefined ? [] : [path])));
 	return present.flat()[0];
-};
+}
 
 export interface BiomeConfigs {
 	readonly chains: readonly Chain[];
@@ -104,7 +110,7 @@ export interface BiomeConfigs {
 	readonly root: string;
 }
 
-export const biomeConfigs = async ({ files, readText }: RuleInputs): Promise<BiomeConfigs> => {
+export async function biomeConfigs({ files, readText }: RuleInputs): Promise<BiomeConfigs> {
 	const root = await rootConfig(readText);
 	const rootChain = root === undefined ? { layers: [], problems: [] } : await chainOf(readText, root);
 	const loaded = new Set(rootChain.layers.map((layer) => layer.path));
@@ -116,4 +122,4 @@ export const biomeConfigs = async ({ files, readText }: RuleInputs): Promise<Bio
 		problems: all.flatMap((chain) => chain.problems),
 		root: root ?? "biome.json",
 	};
-};
+}

package/src/rules/suppressions/biome/declarations.ts

@@ -15,23 +15,28 @@ const shipped = Schema.toStandardSchemaV1(Schema.fromJsonString(Schema.Array(Dec
 	parseOptions: { errors: "all", onExcessProperty: "error" },
 });
 
-export const decodeShipped = (text: string | undefined): Promise<Decoded<readonly Declaration[]>> =>
-	text === undefined ? Promise.resolve({ _tag: "Valid", value: [] }) : decodeWith(shipped, text);
+export function decodeShipped(text: string | undefined): Promise<Decoded<readonly Declaration[]>> {
+	return text === undefined ? Promise.resolve({ _tag: "Valid", value: [] }) : decodeWith(shipped, text);
+}
 
 export interface Scoped {
 	readonly includes: readonly string[];
 	readonly rule: string;
 }
 
-const sameScope = (left: readonly string[], right: readonly string[]): boolean =>
-	new Set(left).size === new Set(right).size && left.every((glob) => right.includes(glob));
+function sameScope(left: readonly string[], right: readonly string[]): boolean {
+	return new Set(left).size === new Set(right).size && left.every((glob) => right.includes(glob));
+}
 
-export const matches = (declaration: Scoped, weakening: Scoped): boolean =>
-	declaration.rule === weakening.rule && sameScope(declaration.includes, weakening.includes);
+export function matches(declaration: Scoped, weakening: Scoped): boolean {
+	return declaration.rule === weakening.rule && sameScope(declaration.includes, weakening.includes);
+}
 
-export const scoped = (base: string, glob: string): string => {
-	const [, negation = "", path = glob] = /^(!*)(.*)$/u.exec(glob) ?? [];
+export function scoped(base: string, glob: string): string {
+	const { negation = "", path = glob } = /^(?<negation>!*)(?<path>.*)$/u.exec(glob)?.groups ?? {};
 	return base === "" ? glob : `${negation}${base}/${path}`;
-};
+}
 
-export const scopeText = (includes: readonly string[]): string => includes.map((glob) => `"${glob}"`).join(", ");
+export function scopeText(includes: readonly string[]): string {
+	return includes.map((glob) => `"${glob}"`).join(", ");
+}

package/src/rules/suppressions/biome/json.ts

@@ -12,14 +12,17 @@ const LITERALS: ReadonlyMap<ts.SyntaxKind, boolean> = new Map([
 	[ts.SyntaxKind.FalseKeyword, false],
 ]);
 
-const scalarOf = (node: ts.Expression): string | boolean | undefined => (ts.isStringLiteral(node) ? node.text : LITERALS.get(node.kind));
+function scalarOf(node: ts.Expression): string | boolean | undefined {
+	return ts.isStringLiteral(node) ? node.text : LITERALS.get(node.kind);
+}
 
-const entryOf = (source: ts.JsonSourceFile, property: ts.ObjectLiteralElementLike): ReadonlyArray<readonly [string, Json]> =>
-	ts.isPropertyAssignment(property) && (ts.isStringLiteral(property.name) || ts.isIdentifier(property.name))
+function entryOf(source: ts.JsonSourceFile, property: ts.ObjectLiteralElementLike): ReadonlyArray<readonly [string, Json]> {
+	return ts.isPropertyAssignment(property) && (ts.isStringLiteral(property.name) || ts.isIdentifier(property.name))
 		? [[property.name.text, toJson(source, property.initializer)]]
 		: [];
+}
 
-const toJson = (source: ts.JsonSourceFile, node: ts.Expression): Json => {
+function toJson(source: ts.JsonSourceFile, node: ts.Expression): Json {
 	const line = source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
 	if (ts.isObjectLiteralExpression(node)) {
 		return { _tag: "Object", entries: new Map(node.properties.flatMap((property) => entryOf(source, property))), line };
@@ -28,9 +31,9 @@ const toJson = (source: ts.JsonSourceFile, node: ts.Expression): Json => {
 		return { _tag: "Array", items: node.elements.map((element) => toJson(source, element)), line };
 	}
 	return { _tag: "Value", line, value: scalarOf(node) };
-};
+}
 
-export const parseJsonc = (path: string, text: string): Parsed => {
+export function parseJsonc(path: string, text: string): Parsed {
 	const error = ts.parseConfigFileTextToJson(path, text).error;
 	const source = ts.parseJsonText(path, text);
 	const root = source.statements[0]?.expression;
@@ -41,15 +44,24 @@ export const parseJsonc = (path: string, text: string): Parsed => {
 		};
 	}
 	return { _tag: "Parsed", json: toJson(source, root) };
-};
+}
 
-export const member = (node: Json | undefined, key: string): Json | undefined => (node?._tag === "Object" ? node.entries.get(key) : undefined);
+export function member(node: Json | undefined, key: string): Json | undefined {
+	return node?._tag === "Object" ? node.entries.get(key) : undefined;
+}
 
-export const entriesOf = (node: Json | undefined): ReadonlyArray<readonly [string, Json]> => (node?._tag === "Object" ? [...node.entries] : []);
+export function entriesOf(node: Json | undefined): ReadonlyArray<readonly [string, Json]> {
+	return node?._tag === "Object" ? [...node.entries] : [];
+}
 
-export const itemsOf = (node: Json | undefined): readonly Json[] => (node?._tag === "Array" ? node.items : []);
+export function itemsOf(node: Json | undefined): readonly Json[] {
+	return node?._tag === "Array" ? node.items : [];
+}
 
-export const textOf = (node: Json | undefined): string | undefined =>
-	node?._tag === "Value" && typeof node.value === "string" ? node.value : undefined;
+export function textOf(node: Json | undefined): string | undefined {
+	return node?._tag === "Value" && typeof node.value === "string" ? node.value : undefined;
+}
 
-export const isFalse = (node: Json | undefined): boolean => node?._tag === "Value" && node.value === false;
+export function isFalse(node: Json | undefined): boolean {
+	return node?._tag === "Value" && node.value === false;
+}

package/src/rules/suppressions/biome/resolve.ts

@@ -15,11 +15,13 @@ const manifestSchema = Schema.toStandardSchemaV1(Schema.fromJsonString(Manifest)
 
 const CONDITIONS: ReadonlySet<string> = new Set(["biome", "default"]);
 
-const SPECIFIER = /^((?:@[^/]+\/)?[^/]+)(?:\/(.+))?$/u;
+const SPECIFIER = /^(?<name>(?:@[^/]+\/)?[^/]+)(?:\/(?<subpath>.+))?$/u;
 
-const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> => typeof value === "object" && value !== null && !Array.isArray(value);
+function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
-const targetOf = (value: unknown, star: string | undefined): string | undefined => {
+function targetOf(value: unknown, star: string | undefined): string | undefined {
 	if (typeof value === "string") {
 		return star === undefined ? value : value.replaceAll("*", star);
 	}
@@ -28,11 +30,13 @@ const targetOf = (value: unknown, star: string | undefined): string | undefined
 	}
 	const condition = isRecord(value) ? Object.keys(value).find((key) => CONDITIONS.has(key)) : undefined;
 	return isRecord(value) && condition !== undefined ? targetOf(value[condition], star) : undefined;
-};
+}
 
-const bySpecificity = (left: string, right: string): number => right.indexOf("*") - left.indexOf("*") || right.length - left.length;
+function bySpecificity(left: string, right: string): number {
+	return right.indexOf("*") - left.indexOf("*") || right.length - left.length;
+}
 
-const patternTarget = (exports: Readonly<Record<string, unknown>>, key: string): string | undefined => {
+function patternTarget(exports: Readonly<Record<string, unknown>>, key: string): string | undefined {
 	const pattern = Object.keys(exports)
 		.filter((candidate) => candidate.split("*").length === 2)
 		.sort(bySpecificity)
@@ -42,26 +46,27 @@ const patternTarget = (exports: Readonly<Record<string, unknown>>, key: string):
 		});
 	const [prefix = "", suffix = ""] = pattern?.split("*") ?? [];
 	return pattern === undefined ? undefined : targetOf(exports[pattern], key.slice(prefix.length, key.length - suffix.length));
-};
+}
 
-const exported = (exports: unknown, subpath: string): string | undefined => {
+function exported(exports: unknown, subpath: string): string | undefined {
 	const key = subpath === "" ? "." : `./${subpath}`;
 	if (!isRecord(exports)) {
 		return targetOf(exports, undefined);
 	}
 	return Object.hasOwn(exports, key) ? targetOf(exports[key], undefined) : (patternTarget(exports, key) ?? targetOf(exports, undefined));
-};
+}
 
-const inPackage = (directory: string, target: string | undefined): string | undefined =>
-	target?.startsWith("./") === true ? posix.join(directory, target) : undefined;
+function inPackage(directory: string, target: string | undefined): string | undefined {
+	return target?.startsWith("./") === true ? posix.join(directory, target) : undefined;
+}
 
-const manifestAt = async (readText: RuleInputs["readText"], path: string): Promise<Manifest | undefined> => {
+async function manifestAt(readText: RuleInputs["readText"], path: string): Promise<Manifest | undefined> {
 	const text = await readText(path);
 	const decoded = text === undefined ? undefined : await decodeWith(manifestSchema, text);
 	return decoded?._tag === "Valid" ? decoded.value : undefined;
-};
+}
 
-const fromDependency = (directory: string, manifest: Manifest, subpath: string): string | undefined => {
+function fromDependency(directory: string, manifest: Manifest, subpath: string): string | undefined {
 	if (manifest.exports !== undefined) {
 		return inPackage(directory, exported(manifest.exports, subpath));
 	}
@@ -69,10 +74,10 @@ const fromDependency = (directory: string, manifest: Manifest, subpath: string):
 		return posix.join(directory, manifest.main);
 	}
 	return subpath === "" ? undefined : posix.join(directory, subpath);
-};
+}
 
-export const resolvePackage = async (readText: RuleInputs["readText"], specifier: string): Promise<string | undefined> => {
-	const [, name, subpath = ""] = SPECIFIER.exec(specifier) ?? [];
+export async function resolvePackage(readText: RuleInputs["readText"], specifier: string): Promise<string | undefined> {
+	const { name, subpath = "" } = SPECIFIER.exec(specifier)?.groups ?? {};
 	if (name === undefined) {
 		return undefined;
 	}
@@ -83,4 +88,4 @@ export const resolvePackage = async (readText: RuleInputs["readText"], specifier
 	const directory = posix.join("node_modules", name);
 	const manifest = await manifestAt(readText, posix.join(directory, "package.json"));
 	return manifest === undefined ? undefined : fromDependency(directory, manifest, subpath);
-};
+}

package/src/rules/suppressions/biome/weakenings.ts

@@ -20,29 +20,36 @@ const LINT_WEAK = new Set(["off", "warn", "info"]);
 const ASSIST_WEAK = new Set(["off"]);
 const PRESETS = new Set(["recommended", "preset"]);
 
-const levelOf = (node: Json): string | undefined => textOf(node) ?? textOf(member(node, "level"));
+function levelOf(node: Json): string | undefined {
+	return textOf(node) ?? textOf(member(node, "level"));
+}
 
-const at = (rule: string, node: Json | undefined, weak: boolean, wholeGroup = false): readonly Setting[] =>
-	node === undefined ? [] : [{ line: node.line, rule, weak, wholeGroup }];
+function at(rule: string, node: Json | undefined, weak: boolean, wholeGroup = false): readonly Setting[] {
+	return node === undefined ? [] : [{ line: node.line, rule, weak, wholeGroup }];
+}
 
-const enabled = (rule: string, section: Json | undefined): readonly Setting[] =>
-	at(rule, member(section, "enabled"), isFalse(member(section, "enabled")));
+function enabled(rule: string, section: Json | undefined): readonly Setting[] {
+	return at(rule, member(section, "enabled"), isFalse(member(section, "enabled")));
+}
 
-const defaults = (rule: string, set: Json | undefined): readonly Setting[] => [
-	...at(rule, member(set, "recommended"), isFalse(member(set, "recommended"))),
-	...at(rule, member(set, "preset"), textOf(member(set, "preset")) === "none"),
-];
+function defaults(rule: string, set: Json | undefined): readonly Setting[] {
+	return [
+		...at(rule, member(set, "recommended"), isFalse(member(set, "recommended"))),
+		...at(rule, member(set, "preset"), textOf(member(set, "preset")) === "none"),
+	];
+}
 
-const ruleSettings = (group: string, weak: ReadonlySet<string>, rules: Json): readonly Setting[] =>
-	entriesOf(rules)
+function ruleSettings(group: string, weak: ReadonlySet<string>, rules: Json): readonly Setting[] {
+	return entriesOf(rules)
 		.filter(([rule]) => !PRESETS.has(rule))
 		.flatMap(([rule, setting]) => {
 			const level = levelOf(setting);
 			return level === undefined ? [] : at(`${group}/${rule}`, setting, weak.has(level));
 		});
+}
 
-const groupSettings = (prefix: string, weak: ReadonlySet<string>, groups: Json | undefined): readonly Setting[] =>
-	entriesOf(groups)
+function groupSettings(prefix: string, weak: ReadonlySet<string>, groups: Json | undefined): readonly Setting[] {
+	return entriesOf(groups)
 		.filter(([group]) => !PRESETS.has(group))
 		.flatMap(([group, rules]) => {
 			const severity = textOf(rules);
@@ -50,19 +57,24 @@ const groupSettings = (prefix: string, weak: ReadonlySet<string>, groups: Json |
 				? [...defaults(`${prefix}/${group}`, rules), ...ruleSettings(`${prefix}/${group}`, weak, rules)]
 				: at(`${prefix}/${group}`, rules, weak.has(severity), true);
 		});
+}
 
-const linter = (section: Json | undefined): readonly Setting[] => [
-	...enabled("lint", section),
-	...defaults("lint/recommended", member(section, "rules")),
-	...groupSettings("lint", LINT_WEAK, member(section, "rules")),
-	...entriesOf(member(section, "domains")).flatMap(([domain, value]) => at(`lint/domains/${domain}`, value, textOf(value) === "none")),
-];
+function linter(section: Json | undefined): readonly Setting[] {
+	return [
+		...enabled("lint", section),
+		...defaults("lint/recommended", member(section, "rules")),
+		...groupSettings("lint", LINT_WEAK, member(section, "rules")),
+		...entriesOf(member(section, "domains")).flatMap(([domain, value]) => at(`lint/domains/${domain}`, value, textOf(value) === "none")),
+	];
+}
 
-const assist = (section: Json | undefined): readonly Setting[] => [
-	...enabled("assist", section),
-	...defaults("assist/recommended", member(section, "actions")),
-	...groupSettings("assist", ASSIST_WEAK, member(section, "actions")),
-];
+function assist(section: Json | undefined): readonly Setting[] {
+	return [
+		...enabled("assist", section),
+		...defaults("assist/recommended", member(section, "actions")),
+		...groupSettings("assist", ASSIST_WEAK, member(section, "actions")),
+	];
+}
 
 const LANGUAGES: readonly string[] = ["javascript", "json", "css", "graphql", "grit", "html"];
 
@@ -74,33 +86,39 @@ const TOOLS: ReadonlyArray<readonly [string, string]> = [
 
 const SCOPED_SECTIONS: ReadonlyArray<readonly [string, string]> = [["files", "files"], ...TOOLS];
 
-const settingsOf = (scope: Json): readonly Setting[] => [
-	...linter(member(scope, "linter")),
-	...assist(member(scope, "assist")),
-	...enabled("format", member(scope, "formatter")),
-	...LANGUAGES.flatMap((language) => TOOLS.flatMap(([key, name]) => enabled(`${language}/${name}`, member(member(scope, language), key)))),
-];
+function settingsOf(scope: Json): readonly Setting[] {
+	return [
+		...linter(member(scope, "linter")),
+		...assist(member(scope, "assist")),
+		...enabled("format", member(scope, "formatter")),
+		...LANGUAGES.flatMap((language) => TOOLS.flatMap(([key, name]) => enabled(`${language}/${name}`, member(member(scope, language), key)))),
+	];
+}
 
-const replaces = (later: Setting, earlier: Setting): boolean =>
-	later.rule === earlier.rule || (later.wholeGroup && earlier.rule.startsWith(`${later.rule}/`));
+function replaces(later: Setting, earlier: Setting): boolean {
+	return later.rule === earlier.rule || (later.wholeGroup && earlier.rule.startsWith(`${later.rule}/`));
+}
 
-const includesOf = (override: Json): readonly string[] => {
+function includesOf(override: Json): readonly string[] {
 	const includes = itemsOf(member(override, "includes")).flatMap((item) => textOf(item) ?? []);
 	return includes.length === 0 ? ["**"] : includes;
-};
+}
 
-const narrowsScope = (globs: readonly string[]): boolean => globs.length > 0 && (globs.some((glob) => glob.startsWith("!")) || !globs.includes("**"));
+function narrowsScope(globs: readonly string[]): boolean {
+	return globs.length > 0 && (globs.some((glob) => glob.startsWith("!")) || !globs.includes("**"));
+}
 
-const narrowings = (config: Json, base: string): readonly Omit<Weakening, "layer">[] =>
-	SCOPED_SECTIONS.flatMap(([key, name]) => {
+function narrowings(config: Json, base: string): readonly Omit<Weakening, "layer">[] {
+	return SCOPED_SECTIONS.flatMap(([key, name]) => {
 		const list = member(member(config, key), "includes");
 		const globs = itemsOf(list).flatMap((item) => textOf(item) ?? []);
 		return list === undefined || !narrowsScope(globs)
 			? []
 			: [{ includes: globs.map((glob) => scoped(base, glob)), line: list.line, rule: `${name}/includes` }];
 	});
+}
 
-const layerWeakenings = (layer: Layer, later: readonly Layer[], base: string): readonly Weakening[] => {
+function layerWeakenings(layer: Layer, later: readonly Layer[], base: string): readonly Weakening[] {
 	const overriding = later.flatMap((next) => settingsOf(next.json));
 	const top = settingsOf(layer.json).filter((setting) => setting.weak && !overriding.some((next) => replaces(next, setting)));
 	return [
@@ -112,7 +130,8 @@ const layerWeakenings = (layer: Layer, later: readonly Layer[], base: string): r
 				.map(({ line, rule }) => ({ includes: includesOf(override).map((glob) => scoped(base, glob)), line, rule })),
 		),
 	].map((weakening) => ({ ...weakening, layer }));
-};
+}
 
-export const weakeningsOf = ({ base, layers }: Chain): readonly Weakening[] =>
-	layers.flatMap((layer, index) => layerWeakenings(layer, layers.slice(index + 1), base));
+export function weakeningsOf({ base, layers }: Chain): readonly Weakening[] {
+	return layers.flatMap((layer, index) => layerWeakenings(layer, layers.slice(index + 1), base));
+}