@shivaedev/quality 0.4.0 → 0.5.1

package/src/rules/comments/kinds.ts

@@ -2,39 +2,29 @@ import { Effect, Schema } from "effect";
 import { SUPPRESSIONS } from "../suppressions/directives.ts";
 import type { SourceComment } from "./scan.ts";
 
-export const DEFAULT_PRAGMAS: ReadonlyArray<string> = [
-	"@vitest-environment",
-	"@vitest-environment-options",
-	"@jest-environment",
-	"@jsx",
-	"@jsxFrag",
-	"@jsxImportSource",
-	"@jsxRuntime",
-];
-
-export const Pragmas = Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_PRAGMAS)));
+export const Pragmas = Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed<readonly string[]>([])));
 
-const DIRECTIVES: ReadonlyArray<RegExp> = [
+const DIRECTIVES: readonly RegExp[] = [
 	...SUPPRESSIONS,
-	/^@ts-/,
-	/^biome-ignore/,
-	/^(?:eslint|oxlint|stylelint)-(?:disable|enable)/,
-	/^[#@]__(?:PURE|NO_SIDE_EFFECTS)__/,
-	/^(?:c8|v8|istanbul) ignore/,
+	/^@ts-/u,
+	/^biome-ignore/u,
+	/^(?:eslint|oxlint|stylelint)-(?:disable|enable)/u,
+	/^[#@]__(?:PURE|NO_SIDE_EFFECTS)__/u,
+	/^(?:c8|v8|istanbul) ignore/u,
 ];
 
-const TRIPLE_SLASH = /^\/\/\/\s*</;
+const TRIPLE_SLASH = /^\/\/\/\s*</u;
 
-const contentOf = (comment: SourceComment): ReadonlyArray<string> => comment.body.filter((line) => line !== "");
+const contentOf = (comment: SourceComment): readonly string[] => comment.body.filter((line) => line !== "");
 
-const startsWithTag = (line: string, tags: ReadonlyArray<string>): boolean =>
+const startsWithTag = (line: string, tags: readonly string[]): boolean =>
 	tags.some((tag) => line === tag || line.startsWith(`${tag} `) || line.startsWith(`${tag}\t`));
 
 export const textOf = (comment: SourceComment): string => comment.body.join("\n");
 
 export const isJsdoc = (comment: SourceComment): boolean => comment.kind === "block" && comment.text.startsWith("/**") && comment.text !== "/**/";
 
-export const isPragma = (comment: SourceComment, pragmas: ReadonlyArray<string>): boolean => {
+export const isPragma = (comment: SourceComment, pragmas: readonly string[]): boolean => {
 	const content = contentOf(comment);
 	return content.length > 0 && content.every((line) => startsWithTag(line, pragmas));
 };

package/src/rules/comments/max-per-file.ts

@@ -5,32 +5,32 @@ import { isDirective, isPragma, Pragmas } from "./kinds.ts";
 import { commentsOf, type SourceComment } from "./scan.ts";
 
 const MaxPerFileOptions = Schema.Struct({
-	max: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).pipe(Schema.withDecodingDefaultKey(Effect.succeed(2))),
 	allow: Pragmas,
+	max: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).pipe(Schema.withDecodingDefaultKey(Effect.succeed(2))),
 });
 
 const continues = (previous: SourceComment | undefined, comment: SourceComment): boolean =>
-	previous !== undefined &&
-	previous.kind === "line" &&
-	comment.kind === "line" &&
-	previous.ownLine &&
-	comment.ownLine &&
-	comment.line === previous.endLine + 1;
+	previous !== undefined
+	&& previous.kind === "line"
+	&& comment.kind === "line"
+	&& previous.ownLine
+	&& comment.ownLine
+	&& comment.line === previous.endLine + 1;
 
-const commentBlocks = (comments: ReadonlyArray<SourceComment>): ReadonlyArray<SourceComment> =>
+const commentBlocks = (comments: readonly SourceComment[]): readonly SourceComment[] =>
 	comments.filter((comment, index) => !continues(comments[index - 1], comment));
 
-const overCap = (file: SourceFile, max: number, allow: ReadonlyArray<string>): ReadonlyArray<Finding> => {
-	const counted = commentsOf(file).filter((comment) => !isDirective(comment) && !isPragma(comment, allow));
+const overCap = (file: SourceFile, max: number, allow: readonly string[]): readonly Finding[] => {
+	const counted = commentsOf(file).filter((comment) => !(isDirective(comment) || isPragma(comment, allow)));
 	const blocks = commentBlocks(counted);
 	const first = blocks[max];
 	return first === undefined
 		? []
 		: [
 				{
+					count: blocks.length - max,
 					file: file.path,
 					line: first.line,
-					count: blocks.length - max,
 					message: `${plural(blocks.length, "comment", "comments")} against a limit of ${max}.`,
 					threshold: max,
 				},
@@ -38,9 +38,9 @@ const overCap = (file: SourceFile, max: number, allow: ReadonlyArray<string>): R
 };
 
 export const maxPerFile = defineRule({
-	id: "comments/max-per-file",
+	check: ({ options, sources }) => sources.flatMap((file) => overCap(file, options.max, options.allow)),
 	description:
 		"A file that needs more than a few comments does too much, or its comments narrate the code. Delete the comments that restate the code, then split the file.",
+	id: "comments/max-per-file",
 	options: Schema.toStandardSchemaV1(MaxPerFileOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
-	check: ({ options, sources }) => sources.flatMap((file) => overCap(file, options.max, options.allow)),
 });

package/src/rules/comments/no-banner.ts

@@ -3,8 +3,8 @@ import { definePatternRule } from "./pattern-rule.ts";
 const DIVIDER = "[-=*#~_+/\\\\─━═┄┈]{3,}";
 
 export const noBanner = definePatternRule({
-	id: "comments/no-banner",
 	description: "Banners, dividers and regions mark a file that does several jobs. Split the file along those sections instead.",
-	patterns: [new RegExp(`^${DIVIDER}|${DIVIDER}$`, "m"), /^#(?:end)?region\b/m],
+	id: "comments/no-banner",
 	message: (match) => `Banner or divider: "${match}".`,
+	patterns: [new RegExp(`^${DIVIDER}|${DIVIDER}$`, "mu"), /^#(?:end)?region\b/mu],
 });

package/src/rules/comments/no-environment-pragma.ts

@@ -0,0 +1,9 @@
+import { definePatternRule } from "./pattern-rule.ts";
+
+export const noEnvironmentPragma = definePatternRule({
+	description:
+		"A test file gets its environment from its name, not from a pragma: `*.dom.test.ts` runs in a DOM, every other test in Node. `@shivaedev/quality/vitest` sets up the Vitest projects that read the name.",
+	id: "comments/no-environment-pragma",
+	message: (match) => `Sets the test environment with "${match}". Name the file *.dom.test.ts or *.dom.test.tsx instead.`,
+	patterns: [/^@(?:vitest|jest)-environment(?:-options)?(?=\s|$)/mu],
+});

package/src/rules/comments/no-jsdoc.ts

@@ -6,13 +6,13 @@ import { commentsOf } from "./scan.ts";
 const NoJsdocOptions = Schema.Struct({ allow: Pragmas });
 
 export const noJsdoc = defineRule({
-	id: "comments/no-jsdoc",
-	description: "Names and types already say what a JSDoc block repeats. Delete it, and keep a reason the code cannot show as a short // comment.",
-	options: Schema.toStandardSchemaV1(NoJsdocOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
 	check: ({ options, sources }) =>
 		sources.flatMap((file) =>
 			commentsOf(file)
 				.filter((comment) => isJsdoc(comment) && !isPragma(comment, options.allow) && !isDirective(comment))
 				.map((comment) => ({ file: file.path, line: comment.line, message: "JSDoc block." })),
 		),
+	description: "Names and types already say what a JSDoc block repeats. Delete it, and keep a reason the code cannot show as a short // comment.",
+	id: "comments/no-jsdoc",
+	options: Schema.toStandardSchemaV1(NoJsdocOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
 });

package/src/rules/comments/no-line-reference.ts

@@ -4,8 +4,8 @@ const SOURCE_EXTENSION =
 	"(?:[cm]?[jt]sx?|json5?|mdx?|css|scss|less|html?|vue|svelte|astro|ya?ml|toml|sql|prisma|graphql|gql|go|rs|py|rb|java|kt|swift|sh)";
 
 export const noLineReference = definePatternRule({
-	id: "comments/no-line-reference",
 	description: "A line number goes stale with the next edit. Name the function, type, test or setting instead.",
-	patterns: [new RegExp(`[\\w./@-]*\\.${SOURCE_EXTENSION}(?::\\d+|#L\\d+)`, "i"), /(?<![\w-])lines?\s+\d+/i],
+	id: "comments/no-line-reference",
 	message: (match) => `Refers to a line: "${match}".`,
+	patterns: [new RegExp(`[\\w./@-]*\\.${SOURCE_EXTENSION}(?::\\d+|#L\\d+)`, "iu"), /(?<![\w-])lines?\s+\d+/iu],
 });

package/src/rules/comments/no-pr-reference.ts

@@ -1,13 +1,13 @@
 import { definePatternRule } from "./pattern-rule.ts";
 
 export const noPrReference = definePatternRule({
-	id: "comments/no-pr-reference",
 	description: "History belongs in version control, not in the code. State the reason itself, so the comment holds without the link.",
+	id: "comments/no-pr-reference",
+	message: (match) => `Refers to a pull request or issue: "${match}".`,
 	patterns: [
-		/\b(?:PR|MR|pull request|merge request|issue|ticket)s?\s*#?\d+\b/i,
-		/\/(?:pull|pulls|issues|merge_requests)\/\d+/,
-		/\bGH-\d+\b/,
-		/(?<![\w&/#-])#\d+\b/,
+		/\b(?:PR|MR|pull request|merge request|issue|ticket)s?\s*#?\d+\b/iu,
+		/\/(?:pull|pulls|issues|merge_requests)\/\d+/u,
+		/\bGH-\d+\b/u,
+		/(?<![\w&/#-])#\d+\b/u,
 	],
-	message: (match) => `Refers to a pull request or issue: "${match}".`,
 });

package/src/rules/comments/no-todo.ts

@@ -1,8 +1,8 @@
 import { definePatternRule } from "./pattern-rule.ts";
 
 export const noTodo = definePatternRule({
-	id: "comments/no-todo",
 	description: "A TODO in the code is never done. Do the work now, or track it where the repository tracks work.",
-	patterns: [/\b(?:TODO|FIXME|XXX)\b/, /@todo\b/i],
+	id: "comments/no-todo",
 	message: (match) => `Marks unfinished work: "${match}".`,
+	patterns: [/\b(?:TODO|FIXME|XXX)\b/u, /@todo\b/iu],
 });

package/src/rules/comments/pattern-rule.ts

@@ -3,26 +3,26 @@ import { isDirective, textOf } from "./kinds.ts";
 import { commentsOf, type SourceComment } from "./scan.ts";
 
 interface PatternRule<Id extends string> {
-	readonly id: Id;
 	readonly description: string;
-	readonly patterns: ReadonlyArray<RegExp>;
+	readonly id: Id;
 	readonly message: (match: string) => string;
+	readonly patterns: readonly RegExp[];
 }
 
-const firstMatch = (comment: SourceComment, patterns: ReadonlyArray<RegExp>): string | undefined => {
+const firstMatch = (comment: SourceComment, patterns: readonly RegExp[]): string | undefined => {
 	const text = textOf(comment);
 	return patterns.map((pattern) => pattern.exec(text)?.[0]).find((match) => match !== undefined);
 };
 
 export const definePatternRule = <const Id extends string>({ description, id, message, patterns }: PatternRule<Id>): Rule<Id, undefined> =>
 	defineRule({
-		id,
-		description,
 		check: ({ sources }) =>
 			sources.flatMap((file) =>
-				commentsOf(file).flatMap((comment): ReadonlyArray<Finding> => {
+				commentsOf(file).flatMap((comment): readonly Finding[] => {
 					const match = isDirective(comment) ? undefined : firstMatch(comment, patterns);
 					return match === undefined ? [] : [{ file: file.path, line: comment.line, message: message(match) }];
 				}),
 			),
+		description,
+		id,
 	});

package/src/rules/comments/scan.ts

@@ -3,20 +3,20 @@ import type { SourceFile } from "../../rule.ts";
 import { parse } from "../syntax.ts";
 
 export interface SourceComment {
+	readonly body: readonly string[];
+	readonly endLine: number;
 	readonly kind: "block" | "line";
-	readonly text: string;
-	readonly body: ReadonlyArray<string>;
 	readonly line: number;
-	readonly endLine: number;
 	readonly ownLine: boolean;
+	readonly text: string;
 }
 
-const DECLARATION = /\.d\.[cm]?ts$/;
+const DECLARATION = /\.d\.[cm]?ts$/u;
 
-const commentRanges = (source: ts.SourceFile): ReadonlyArray<ts.CommentRange> => {
+const commentRanges = (source: ts.SourceFile): readonly ts.CommentRange[] => {
 	const ranges = new Map<number, ts.CommentRange>();
-	const jsxText: Array<ts.Node> = [];
-	const add = (found: ReadonlyArray<ts.CommentRange> | undefined) => {
+	const jsxText: ts.Node[] = [];
+	const add = (found: readonly ts.CommentRange[] | undefined) => {
 		for (const range of found ?? []) {
 			ranges.set(range.pos, range);
 		}
@@ -37,13 +37,13 @@ const commentRanges = (source: ts.SourceFile): ReadonlyArray<ts.CommentRange> =>
 		.sort((left, right) => left.pos - right.pos);
 };
 
-export const bodyOf = (kind: SourceComment["kind"], text: string): ReadonlyArray<string> =>
+export const bodyOf = (kind: SourceComment["kind"], text: string): readonly string[] =>
 	kind === "line"
 		? [text.slice(2).trim()]
 		: text
 				.slice(2, -2)
 				.split("\n")
-				.map((line) => line.trim().replace(/^\*(?=\s|$)\s*/, ""));
+				.map((line) => line.trim().replace(/^\*(?=\s|$)\s*/u, ""));
 
 const toComment = (source: ts.SourceFile, range: ts.CommentRange): SourceComment => {
 	const kind = range.kind === ts.SyntaxKind.SingleLineCommentTrivia ? "line" : "block";
@@ -60,14 +60,14 @@ const toComment = (source: ts.SourceFile, range: ts.CommentRange): SourceComment
 	};
 };
 
-const scanned = new WeakMap<SourceFile, ReadonlyArray<SourceComment>>();
+const scanned = new WeakMap<SourceFile, readonly SourceComment[]>();
 
-const scan = (file: SourceFile): ReadonlyArray<SourceComment> => {
+const scan = (file: SourceFile): readonly SourceComment[] => {
 	const source = parse(file);
 	return source === undefined ? [] : commentRanges(source).map((range) => toComment(source, range));
 };
 
-export const scanComments = (file: SourceFile): ReadonlyArray<SourceComment> => {
+export const scanComments = (file: SourceFile): readonly SourceComment[] => {
 	const cached = scanned.get(file);
 	if (cached !== undefined) {
 		return cached;
@@ -77,4 +77,4 @@ export const scanComments = (file: SourceFile): ReadonlyArray<SourceComment> =>
 	return comments;
 };
 
-export const commentsOf = (file: SourceFile): ReadonlyArray<SourceComment> => (DECLARATION.test(file.path) ? [] : scanComments(file));
+export const commentsOf = (file: SourceFile): readonly SourceComment[] => (DECLARATION.test(file.path) ? [] : scanComments(file));

package/src/rules/imports/cycles.ts

@@ -0,0 +1,44 @@
+import { cyclicComponents } from "../../imports/components.ts";
+import { type ImportEdge, importGraph } from "../../imports/graph.ts";
+import { shortestPath } from "../../imports/paths.ts";
+import { defineRule, type Finding } from "../../rule.ts";
+
+type RuntimeEdge = ImportEdge & { readonly to: { readonly kind: "file"; readonly path: string } };
+
+function isRuntime(edge: ImportEdge): edge is RuntimeEdge {
+	return !edge.type && edge.kind === "import" && edge.to.kind === "file";
+}
+
+function runtimeAdjacency(edges: readonly RuntimeEdge[]): ReadonlyMap<string, readonly string[]> {
+	const adjacency = new Map<string, string[]>();
+	for (const edge of edges) {
+		adjacency.set(edge.from, [...(adjacency.get(edge.from) ?? []), edge.to.path]);
+	}
+	return adjacency;
+}
+
+function findingOf(edges: readonly RuntimeEdge[], adjacency: ReadonlyMap<string, readonly string[]>, component: readonly string[]): Finding {
+	const [anchor = ""] = component;
+	const members = new Set(component);
+	function within(node: string): readonly string[] {
+		return (adjacency.get(node) ?? []).filter((next) => members.has(next));
+	}
+	const loop = shortestPath(anchor, within, (node) => node === anchor) ?? component;
+	const first = edges.find((edge) => edge.from === anchor && edge.to.path === loop[1]);
+	const message =
+		component.length === 1
+			? `${anchor} imports itself at runtime. Use its own code directly instead of importing it.`
+			: `${component.length} modules import each other at runtime: ${component.join(", ")}. One loop: ${loop.join(" -> ")}. Move what they share into a module that imports neither, or import only types with \`import type\`.`;
+	return { count: component.length, file: anchor, line: first?.line, message };
+}
+
+export const importCycles = defineRule({
+	check: async (inputs) => {
+		const edges = (await importGraph(inputs)).edges.filter(isRuntime);
+		const adjacency = runtimeAdjacency(edges);
+		return cyclicComponents(adjacency).map((component) => findingOf(edges, adjacency, component));
+	},
+	description: "Modules never import each other in a loop at runtime. A group of modules that reach one another counts once for each module in it.",
+	id: "imports/cycles",
+	registrable: false,
+});

package/src/rules/imports/fences.ts

@@ -0,0 +1,27 @@
+import { Effect, Schema } from "effect";
+import type { Fence } from "../../imports/fences/model.ts";
+import { compilePolicy } from "../../imports/fences/policy.ts";
+import { importGraph } from "../../imports/graph.ts";
+import { defineRule } from "../../rule.ts";
+
+function isFence(value: unknown): value is Fence {
+	return typeof value === "object" && value !== null && "_tag" in value && value._tag === "Fence";
+}
+
+const FencesOptions = Schema.Struct({
+	fences: Schema.Array(Schema.declare(isFence, { expected: "a fence made with fence()" })).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+});
+
+export const importFences = defineRule({
+	check: async ({ options, ...inputs }) => {
+		if (options.fences.length === 0) {
+			return [];
+		}
+		const graph = await importGraph(inputs);
+		const policy = compilePolicy(options.fences, { files: inputs.files, packages: graph.packages });
+		return policy.flatMap((compiled) => compiled.evaluate(graph));
+	},
+	description: "Imports respect the fences the repository declares. Move the code to the side of the fence its imports belong to.",
+	id: "imports/fences",
+	options: Schema.toStandardSchemaV1(FencesOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
+});

package/src/rules/imports/resolvable.ts

@@ -0,0 +1,23 @@
+import { Effect, Schema } from "effect";
+import { withoutGenerated } from "../../imports/generated.ts";
+import { importGraph } from "../../imports/graph.ts";
+import { defineRule } from "../../rule.ts";
+
+const ResolvableOptions = Schema.Struct({
+	generated: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+});
+
+export const importsResolvable = defineRule({
+	check: async ({ options, ...inputs }) => {
+		const unresolved = await withoutGenerated(inputs, await importGraph(inputs), options.generated);
+		return unresolved.map((request) => ({
+			file: request.from,
+			line: request.line,
+			message: `Cannot resolve "${request.specifier}". Fix the path, install or declare the package, or declare the module in a .d.ts file among the sources.`,
+			subject: request.specifier,
+		}));
+	},
+	description: "Every import resolves to a file, a package or a declared module, so no edge of the import graph goes unchecked.",
+	id: "imports/resolvable",
+	options: Schema.toStandardSchemaV1(ResolvableOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
+});

package/src/rules/manifests-sorted.ts

@@ -0,0 +1,23 @@
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
+import { Effect } from "effect";
+import { manifestsIn, sortingOf } from "../manifests/sorted.ts";
+import { defineRule, type Finding } from "../rule.ts";
+
+const MESSAGES = {
+	Invalid: "Is not valid JSON.",
+	Unsorted: "Keys are not in sort-package-json order. Run `quality fix`.",
+} as const;
+
+export const manifestsSorted = defineRule({
+	check: async ({ readText, root }) => {
+		const manifests = await Effect.runPromise(manifestsIn(root).pipe(Effect.provide(NodeFileSystem.layer)));
+		const texts = await Promise.all(manifests.map(async (path) => ({ path, text: (await readText(path)) ?? "" })));
+		return texts.flatMap(({ path, text }): readonly Finding[] => {
+			const sorting = sortingOf(text);
+			return sorting._tag === "Sorted" ? [] : [{ file: path, message: MESSAGES[sorting._tag] }];
+		});
+	},
+	description: "Every package.json in the repository keeps its keys in sort-package-json order. `quality fix` sorts them.",
+	id: "manifests/sorted",
+	registrable: false,
+});

package/src/rules/max-lines.ts

@@ -2,8 +2,8 @@ import { Effect, Schema } from "effect";
 import ignore from "ignore";
 import { defineRule, type Finding, type SourceFile } from "../rule.ts";
 
-const DEFAULT_TEST_FILES: ReadonlyArray<string> = ["*.test.*", "*.spec.*", "test/", "tests/", "__tests__/"];
-const DECLARATION = /\.d\.[cm]?ts$/;
+const DEFAULT_TEST_FILES: readonly string[] = ["*.test.*", "*.spec.*", "test/", "tests/", "__tests__/"];
+const DECLARATION = /\.d\.[cm]?ts$/u;
 
 const Limit = Schema.Int.check(Schema.isGreaterThan(0));
 
@@ -13,7 +13,7 @@ const MaxLinesOptions = Schema.Struct({
 	testFiles: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_TEST_FILES))),
 });
 
-const oversized = (file: SourceFile, limit: number): ReadonlyArray<Finding> =>
+const oversized = (file: SourceFile, limit: number): readonly Finding[] =>
 	file.lines.length <= limit
 		? []
 		: [
@@ -26,13 +26,13 @@ const oversized = (file: SourceFile, limit: number): ReadonlyArray<Finding> =>
 			];
 
 export const maxLines = defineRule({
-	id: "structure/max-lines",
-	description: "Keep each module to one job. Split a long file along its responsibilities; never golf it under the limit.",
-	options: Schema.toStandardSchemaV1(MaxLinesOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
 	check: ({ options, sources }) => {
 		const tests = ignore().add([...options.testFiles]);
 		return sources
 			.filter((file) => !DECLARATION.test(file.path))
 			.flatMap((file) => oversized(file, tests.ignores(file.path) ? options.test : options.source));
 	},
+	description: "Keep each module to one job. Split a long file along its responsibilities; never golf it under the limit.",
+	id: "structure/max-lines",
+	options: Schema.toStandardSchemaV1(MaxLinesOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
 });

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

@@ -5,35 +5,35 @@ import { itemsOf, type Json, member, type Parsed, parseJsonc, textOf } from "./j
 import { resolvePackage } from "./resolve.ts";
 
 export interface Preset {
-	readonly specifier: string;
+	readonly declared: readonly Declaration[];
 	readonly file: string;
 	readonly line: number;
-	readonly declared: ReadonlyArray<Declaration>;
+	readonly specifier: string;
 }
 
 export interface Layer {
-	readonly path: string;
 	readonly json: Json;
+	readonly path: string;
 	readonly preset: Preset | undefined;
 }
 
 export interface Chain {
 	readonly base: string;
-	readonly layers: ReadonlyArray<Layer>;
+	readonly layers: readonly Layer[];
 }
 
 interface Loaded {
-	readonly layers: ReadonlyArray<Layer>;
-	readonly problems: ReadonlyArray<Finding>;
+	readonly layers: readonly Layer[];
+	readonly problems: readonly Finding[];
 }
 
 type ReadText = RuleInputs["readText"];
 
-const ROOT_CONFIGS: ReadonlyArray<string> = ["biome.json", "biome.jsonc"];
+const ROOT_CONFIGS: readonly string[] = ["biome.json", "biome.jsonc"];
 
-const NESTED = /(?:^|\/)biome\.jsonc?$/;
+const NESTED = /(?:^|\/)biome\.jsonc?$/u;
 
-const RELATIVE = /^\.\.?(?:\/|$)/;
+const RELATIVE = /^\.\.?(?:\/|$)/u;
 
 const directoryOf = (path: string): string => (posix.dirname(path) === "." ? "" : posix.dirname(path));
 
@@ -81,7 +81,7 @@ const extended = async (readText: ReadText, from: string, entry: Json): Promise<
 	return (await readText(relative)) === undefined ? fromPackage(readText, from, entry, specifier) : local(readText, relative);
 };
 
-const extendsOf = (json: Json): ReadonlyArray<Json> => itemsOf(member(json, "extends"));
+const extendsOf = (json: Json): readonly Json[] => itemsOf(member(json, "extends"));
 
 const chainOf = async (readText: ReadText, path: string): Promise<Loaded> => {
 	const own = await local(readText, path);
@@ -99,9 +99,9 @@ const rootConfig = async (readText: ReadText): Promise<string | undefined> => {
 };
 
 export interface BiomeConfigs {
+	readonly chains: readonly Chain[];
+	readonly problems: readonly Finding[];
 	readonly root: string;
-	readonly chains: ReadonlyArray<Chain>;
-	readonly problems: ReadonlyArray<Finding>;
 }
 
 export const biomeConfigs = async ({ files, readText }: RuleInputs): Promise<BiomeConfigs> => {

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

@@ -2,9 +2,9 @@ import { Schema } from "effect";
 import { type Decoded, decodeWith } from "../../../decoded.ts";
 
 export const Declaration = Schema.Struct({
-	rule: Schema.NonEmptyString,
 	includes: Schema.NonEmptyArray(Schema.NonEmptyString),
-	reason: Schema.String.check(Schema.isPattern(/\S/, { expected: "a reason that says why the scope needs the rule weakened" })),
+	reason: Schema.String.check(Schema.isPattern(/\S/u, { expected: "a reason that says why the scope needs the rule weakened" })),
+	rule: Schema.NonEmptyString,
 });
 
 export type Declaration = typeof Declaration.Type;
@@ -15,23 +15,23 @@ const shipped = Schema.toStandardSchemaV1(Schema.fromJsonString(Schema.Array(Dec
 	parseOptions: { errors: "all", onExcessProperty: "error" },
 });
 
-export const decodeShipped = (text: string | undefined): Promise<Decoded<ReadonlyArray<Declaration>>> =>
+export const decodeShipped = (text: string | undefined): Promise<Decoded<readonly Declaration[]>> =>
 	text === undefined ? Promise.resolve({ _tag: "Valid", value: [] }) : decodeWith(shipped, text);
 
 export interface Scoped {
+	readonly includes: readonly string[];
 	readonly rule: string;
-	readonly includes: ReadonlyArray<string>;
 }
 
-const sameScope = (left: ReadonlyArray<string>, right: ReadonlyArray<string>): boolean =>
+const sameScope = (left: readonly string[], right: readonly string[]): boolean =>
 	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 const scoped = (base: string, glob: string): string => {
-	const [, negation = "", path = glob] = /^(!*)(.*)$/.exec(glob) ?? [];
+	const [, negation = "", path = glob] = /^(!*)(.*)$/u.exec(glob) ?? [];
 	return base === "" ? glob : `${negation}${base}/${path}`;
 };
 
-export const scopeText = (includes: ReadonlyArray<string>): string => includes.map((glob) => `"${glob}"`).join(", ");
+export const scopeText = (includes: readonly string[]): string => includes.map((glob) => `"${glob}"`).join(", ");

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

@@ -2,7 +2,7 @@ import ts from "typescript";
 
 export type Json =
 	| { readonly _tag: "Object"; readonly line: number; readonly entries: ReadonlyMap<string, Json> }
-	| { readonly _tag: "Array"; readonly line: number; readonly items: ReadonlyArray<Json> }
+	| { readonly _tag: "Array"; readonly line: number; readonly items: readonly Json[] }
 	| { readonly _tag: "Value"; readonly line: number; readonly value: string | boolean | undefined };
 
 export type Parsed = { readonly _tag: "Parsed"; readonly json: Json } | { readonly _tag: "Unreadable"; readonly reason: string };
@@ -37,7 +37,7 @@ export const parseJsonc = (path: string, text: string): Parsed => {
 	if (error !== undefined || root === undefined) {
 		return {
 			_tag: "Unreadable",
-			reason: error === undefined ? "it is empty" : ts.flattenDiagnosticMessageText(error.messageText, " ").replace(/\.$/, ""),
+			reason: error === undefined ? "it is empty" : ts.flattenDiagnosticMessageText(error.messageText, " ").replace(/\.$/u, ""),
 		};
 	}
 	return { _tag: "Parsed", json: toJson(source, root) };
@@ -47,7 +47,7 @@ export const member = (node: Json | undefined, key: string): Json | undefined =>
 
 export const entriesOf = (node: Json | undefined): ReadonlyArray<readonly [string, Json]> => (node?._tag === "Object" ? [...node.entries] : []);
 
-export const itemsOf = (node: Json | undefined): ReadonlyArray<Json> => (node?._tag === "Array" ? node.items : []);
+export const itemsOf = (node: Json | undefined): readonly Json[] => (node?._tag === "Array" ? node.items : []);
 
 export const textOf = (node: Json | undefined): string | undefined =>
 	node?._tag === "Value" && typeof node.value === "string" ? node.value : undefined;

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

@@ -4,9 +4,9 @@ import { decodeWith } from "../../../decoded.ts";
 import type { RuleInputs } from "../../../rule.ts";
 
 const Manifest = Schema.Struct({
-	name: Schema.optionalKey(Schema.String),
-	main: Schema.optionalKey(Schema.String),
 	exports: Schema.optionalKey(Schema.Unknown),
+	main: Schema.optionalKey(Schema.String),
+	name: Schema.optionalKey(Schema.String),
 });
 
 type Manifest = typeof Manifest.Type;
@@ -15,7 +15,7 @@ const manifestSchema = Schema.toStandardSchemaV1(Schema.fromJsonString(Manifest)
 
 const CONDITIONS: ReadonlySet<string> = new Set(["biome", "default"]);
 
-const SPECIFIER = /^((?:@[^/]+\/)?[^/]+)(?:\/(.+))?$/;
+const SPECIFIER = /^((?:@[^/]+\/)?[^/]+)(?:\/(.+))?$/u;
 
 const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> => typeof value === "object" && value !== null && !Array.isArray(value);