@shivaedev/quality 0.3.1 → 0.5.0

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

@@ -1,50 +1,119 @@
 import { posix } from "node:path";
-import type { RuleInputs } from "../../../rule.ts";
-import { itemsOf, type Json, member, parseJsonc, textOf } from "./json.ts";
+import type { Finding, RuleInputs } from "../../../rule.ts";
+import { type Declaration, decodeShipped, PRESET_DECLARATIONS } from "./declarations.ts";
+import { itemsOf, type Json, member, type Parsed, parseJsonc, textOf } from "./json.ts";
+import { resolvePackage } from "./resolve.ts";
 
-export type Config =
-	| { readonly _tag: "Config"; readonly path: string; readonly base: string; readonly json: Json }
-	| { readonly _tag: "Unreadable"; readonly path: string; readonly reason: string };
+export interface Preset {
+	readonly declared: readonly Declaration[];
+	readonly file: string;
+	readonly line: number;
+	readonly specifier: string;
+}
 
-const ROOT_CONFIGS: ReadonlyArray<string> = ["biome.json", "biome.jsonc"];
+export interface Layer {
+	readonly json: Json;
+	readonly path: string;
+	readonly preset: Preset | undefined;
+}
 
-const NESTED = /(?:^|\/)biome\.jsonc?$/;
+export interface Chain {
+	readonly base: string;
+	readonly layers: readonly Layer[];
+}
+
+interface Loaded {
+	readonly layers: readonly Layer[];
+	readonly problems: readonly Finding[];
+}
+
+type ReadText = RuleInputs["readText"];
+
+const ROOT_CONFIGS: readonly string[] = ["biome.json", "biome.jsonc"];
+
+const NESTED = /(?:^|\/)biome\.jsonc?$/u;
+
+const RELATIVE = /^\.\.?(?:\/|$)/u;
 
 const directoryOf = (path: string): string => (posix.dirname(path) === "." ? "" : posix.dirname(path));
 
-const localExtends = (path: string, json: Json): ReadonlyArray<string> => {
-	const node = member(json, "extends");
-	const entries = node?._tag === "Array" ? itemsOf(node).flatMap((item) => textOf(item) ?? []) : [textOf(node) ?? ""];
-	return entries.filter((entry) => entry.startsWith(".")).map((entry) => posix.join(posix.dirname(path), entry));
+const read = async (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 load = async (readText: RuleInputs["readText"], path: string, base: string, seen: Set<string>): Promise<ReadonlyArray<Config>> => {
-	if (seen.has(path)) {
-		return [];
-	}
-	seen.add(path);
-	const text = await readText(path);
-	if (text === undefined) {
-		return [{ _tag: "Unreadable", path, reason: "the file does not exist" }];
+const problem = (file: string, message: string, line?: number): Loaded => ({ layers: [], problems: [{ file, line, message }] });
+
+const local = async (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> => {
+	const target = await resolvePackage(readText, specifier);
+	if (target === undefined) {
+		return problem(from, `Cannot resolve the Biome config "${specifier}" from node_modules.`, entry.line);
 	}
-	const parsed = parseJsonc(path, text);
+	const parsed = await read(readText, target);
 	if (parsed._tag === "Unreadable") {
-		return [{ _tag: "Unreadable", path, reason: parsed.reason }];
+		return problem(from, `Cannot read the Biome config "${specifier}" at ${target}: ${parsed.reason}.`, entry.line);
 	}
-	const extended = await Promise.all(localExtends(path, parsed.json).map((target) => load(readText, target, base, seen)));
-	return [{ _tag: "Config", base, json: parsed.json, path }, ...extended.flat()];
+	const shipped = posix.join(posix.dirname(target), PRESET_DECLARATIONS);
+	const declared = await decodeShipped(await readText(shipped));
+	if (declared._tag === "Invalid") {
+		return problem(from, `Cannot read the declarations shipped with "${specifier}" at ${shipped}: ${declared.issues.join("; ")}.`, entry.line);
+	}
+	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> => {
+	const specifier = textOf(entry);
+	if (specifier === undefined || specifier === "//") {
+		return { layers: [], problems: [] };
+	}
+	if (RELATIVE.test(specifier)) {
+		return local(readText, posix.join(posix.dirname(from), specifier));
+	}
+	const relative = posix.normalize(specifier);
+	return (await readText(relative)) === undefined ? fromPackage(readText, from, entry, specifier) : local(readText, relative);
 };
 
-const rootConfig = async (readText: RuleInputs["readText"]): Promise<string | undefined> => {
+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);
+	const [layer] = own.layers;
+	if (layer === undefined) {
+		return own;
+	}
+	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> => {
 	const present = await Promise.all(ROOT_CONFIGS.map(async (path) => ((await readText(path)) === undefined ? [] : [path])));
 	return present.flat()[0];
 };
 
-export const biomeConfigs = async ({ files, readText }: RuleInputs): Promise<ReadonlyArray<Config>> => {
-	const seen = new Set<string>();
+export interface BiomeConfigs {
+	readonly chains: readonly Chain[];
+	readonly problems: readonly Finding[];
+	readonly root: string;
+}
+
+export const biomeConfigs = async ({ files, readText }: RuleInputs): Promise<BiomeConfigs> => {
 	const root = await rootConfig(readText);
-	const nested = files.filter((path) => NESTED.test(path) && path !== root);
-	const roots = root === undefined ? [] : await load(readText, root, "", seen);
-	const below = await Promise.all(nested.map((path) => load(readText, path, directoryOf(path), seen)));
-	return [...roots, ...below.flat()];
+	const rootChain = root === undefined ? { layers: [], problems: [] } : await chainOf(readText, root);
+	const loaded = new Set(rootChain.layers.map((layer) => layer.path));
+	const nested = files.filter((path) => NESTED.test(path) && path !== root && !loaded.has(path));
+	const below = await Promise.all(nested.map(async (path) => ({ base: directoryOf(path), ...(await chainOf(readText, path)) })));
+	const all = [{ base: "", ...rootChain }, ...below];
+	return {
+		chains: all.filter((chain) => chain.layers.length > 0).map(({ base, layers }) => ({ base, layers })),
+		problems: all.flatMap((chain) => chain.problems),
+		root: root ?? "biome.json",
+	};
 };

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

@@ -0,0 +1,37 @@
+import { Schema } from "effect";
+import { type Decoded, decodeWith } from "../../../decoded.ts";
+
+export const Declaration = Schema.Struct({
+	includes: Schema.NonEmptyArray(Schema.NonEmptyString),
+	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;
+
+export const PRESET_DECLARATIONS = "declarations.json";
+
+const shipped = Schema.toStandardSchemaV1(Schema.fromJsonString(Schema.Array(Declaration)), {
+	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 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));
+
+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] = /^(!*)(.*)$/u.exec(glob) ?? [];
+	return base === "" ? glob : `${negation}${base}/${path}`;
+};
+
+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

@@ -0,0 +1,86 @@
+import { posix } from "node:path";
+import { Schema } from "effect";
+import { decodeWith } from "../../../decoded.ts";
+import type { RuleInputs } from "../../../rule.ts";
+
+const Manifest = Schema.Struct({
+	exports: Schema.optionalKey(Schema.Unknown),
+	main: Schema.optionalKey(Schema.String),
+	name: Schema.optionalKey(Schema.String),
+});
+
+type Manifest = typeof Manifest.Type;
+
+const manifestSchema = Schema.toStandardSchemaV1(Schema.fromJsonString(Manifest));
+
+const CONDITIONS: ReadonlySet<string> = new Set(["biome", "default"]);
+
+const SPECIFIER = /^((?:@[^/]+\/)?[^/]+)(?:\/(.+))?$/u;
+
+const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> => typeof value === "object" && value !== null && !Array.isArray(value);
+
+const targetOf = (value: unknown, star: string | undefined): string | undefined => {
+	if (typeof value === "string") {
+		return star === undefined ? value : value.replaceAll("*", star);
+	}
+	if (Array.isArray(value)) {
+		return value.map((item: unknown) => targetOf(item, star)).find((target) => target !== 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;
+
+const patternTarget = (exports: Readonly<Record<string, unknown>>, key: string): string | undefined => {
+	const pattern = Object.keys(exports)
+		.filter((candidate) => candidate.split("*").length === 2)
+		.sort(bySpecificity)
+		.find((candidate) => {
+			const [prefix = "", suffix = ""] = candidate.split("*");
+			return key.startsWith(prefix) && key !== prefix && key.endsWith(suffix) && key.length >= candidate.length;
+		});
+	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 => {
+	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;
+
+const manifestAt = async (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 => {
+	if (manifest.exports !== undefined) {
+		return inPackage(directory, exported(manifest.exports, subpath));
+	}
+	if (subpath === "" && manifest.main !== undefined) {
+		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) ?? [];
+	if (name === undefined) {
+		return undefined;
+	}
+	const own = await manifestAt(readText, "package.json");
+	if (own?.name === name && own.exports !== undefined && subpath !== "") {
+		return inPackage("", exported(own.exports, subpath));
+	}
+	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);
+};