@avi2dg/checks 0.35.1 → 0.37.0

package/src/quality/jsonc-patch.ts

@@ -0,0 +1,209 @@
+type Key = string | number;
+
+type Entry = { readonly key: Key; readonly start: number; readonly node: Tree; readonly comma: number | undefined };
+
+type Container = { readonly kind: "object" | "array"; readonly start: number; readonly end: number; readonly entries: readonly Entry[] };
+
+type Tree = Container | { readonly kind: "scalar"; readonly start: number; readonly end: number; readonly value: unknown };
+
+type Edit = { readonly start: number; readonly end: number; readonly text: string };
+
+export type Step = string | Readonly<Record<string, unknown>>;
+
+type Reached = { readonly container: Container; readonly entry: Entry } | { readonly container: Container; readonly missing: readonly [Step, ...Step[]] };
+
+const SCALAR_END = /[\s,:\]}/]/;
+
+class Scanner {
+  readonly text: string;
+  at = 0;
+
+  constructor(text: string) {
+    this.text = text;
+  }
+
+  blank(): void {
+    for (;;) {
+      while (/\s/.test(this.text.charAt(this.at))) this.at += 1;
+      if (this.text.startsWith("//", this.at)) this.at = this.text.includes("\n", this.at) ? this.text.indexOf("\n", this.at) : this.text.length;
+      else if (this.text.startsWith("/*", this.at)) this.at = this.text.indexOf("*/", this.at + 2) + 2;
+      else return;
+    }
+  }
+
+  quoted(): string {
+    const start = this.at;
+    const quote = this.text.charAt(start);
+    this.at += 1;
+    while (this.at < this.text.length && this.text.charAt(this.at) !== quote) this.at += this.text.charAt(this.at) === "\\" ? 2 : 1;
+    this.at += 1;
+    return this.text.slice(start, this.at);
+  }
+
+  scalar(): Tree {
+    const start = this.at;
+    const opening = this.text.charAt(start);
+    if (opening === '"' || opening === "'") this.quoted();
+    else while (this.at < this.text.length && !SCALAR_END.test(this.text.charAt(this.at))) this.at += 1;
+    return { kind: "scalar", start, end: this.at, value: Bun.JSONC.parse(this.text.slice(start, this.at)) };
+  }
+
+  container(kind: Container["kind"]): Container {
+    const start = this.at;
+    const close = kind === "object" ? "}" : "]";
+    const entries: Entry[] = [];
+    this.at += 1;
+    for (this.blank(); this.at < this.text.length && this.text.charAt(this.at) !== close; this.blank()) {
+      const entryStart = this.at;
+      const key = kind === "object" ? this.member() : entries.length;
+      const node = this.node();
+      this.blank();
+      const comma = this.text.charAt(this.at) === "," ? this.at : undefined;
+      if (comma !== undefined) this.at += 1;
+      entries.push({ key, start: entryStart, node, comma });
+    }
+    this.at += 1;
+    return { kind, start, end: this.at, entries };
+  }
+
+  member(): string {
+    const key = String(Bun.JSONC.parse(this.quoted()));
+    this.blank();
+    this.at += 1;
+    return key;
+  }
+
+  node(): Tree {
+    this.blank();
+    const opening = this.text.charAt(this.at);
+    if (opening === "{") return this.container("object");
+    if (opening === "[") return this.container("array");
+    return this.scalar();
+  }
+}
+
+function valueOf(text: string, tree: Tree): unknown {
+  return tree.kind === "scalar" ? tree.value : Bun.JSONC.parse(text.slice(tree.start, tree.end));
+}
+
+function holds(text: string, tree: Tree, match: Readonly<Record<string, unknown>>): boolean {
+  if (tree.kind !== "object") return false;
+  return Object.entries(match).every(([key, wanted]) => {
+    const member = tree.entries.findLast((entry) => entry.key === key);
+    return member !== undefined && Bun.deepEquals(valueOf(text, member.node), wanted);
+  });
+}
+
+function childOf(text: string, container: Container, step: Step): Entry | undefined {
+  if (typeof step === "string") return container.kind === "object" ? container.entries.findLast(({ key }) => key === step) : undefined;
+  return container.kind === "array" ? container.entries.find(({ node }) => holds(text, node, step)) : undefined;
+}
+
+// Every step but the last reaches a container, an object for a key and an array for a match.
+function reached(text: string, path: readonly [Step, ...Step[]]): Reached | undefined {
+  let container = new Scanner(text).node();
+  let steps = path;
+  for (;;) {
+    if (container.kind === "scalar") return undefined;
+    const [step, ...tail] = steps;
+    const entry = childOf(text, container, step);
+    if (entry === undefined) return { container, missing: steps };
+    const [next, ...after] = tail;
+    if (next === undefined) return { container, entry };
+    container = entry.node;
+    steps = [next, ...after];
+  }
+}
+
+function childValue(step: Step, tail: readonly Step[], value: unknown): unknown {
+  const [next, ...after] = tail;
+  const inner = next === undefined ? value : typeof next === "string" ? { [next]: childValue(next, after, value) } : [childValue(next, after, value)];
+  return typeof step === "string" ? inner : Object.assign({}, step, inner);
+}
+
+function indentAt(text: string, at: number): string {
+  const line = text.slice(text.lastIndexOf("\n", at - 1) + 1, at);
+  return line.slice(0, line.length - line.trimStart().length);
+}
+
+function serialized(value: unknown, indent: string): string {
+  return JSON.stringify(value, null, 2).replaceAll("\n", `\n${indent}`);
+}
+
+function spacesFrom(text: string, at: number, step: 1 | -1): number {
+  let edge = at;
+  while (/[ \t]/.test(text.charAt(step === 1 ? edge : edge - 1))) edge += step;
+  return edge;
+}
+
+function newlineAt(text: string, at: number): number | undefined {
+  if (text.startsWith("\r\n", at)) return 2;
+  return text.charAt(at) === "\n" ? 1 : undefined;
+}
+
+function lineEndAfter(text: string, at: number): number | undefined {
+  let edge = spacesFrom(text, at, 1);
+  for (;;) {
+    if (text.startsWith("//", edge)) edge = text.includes("\n", edge) ? text.indexOf("\n", edge) : text.length;
+    else if (text.startsWith("/*", edge)) edge = spacesFrom(text, text.indexOf("*/", edge + 2) + 2, 1);
+    else return newlineAt(text, edge) === undefined ? undefined : edge;
+  }
+}
+
+function insertion(text: string, { start, end, entries }: Container, step: Step, value: unknown): Edit {
+  const key = typeof step === "string" ? `${JSON.stringify(step)}: ` : "";
+  const last = entries.at(-1);
+  if (last === undefined) {
+    const indent = indentAt(text, start);
+    return { start: start + 1, end: end - 1, text: `${text.slice(start + 1, end - 1).trimEnd()}\n${indent}  ${key}${serialized(value, `${indent}  `)}\n${indent}` };
+  }
+  const indent = indentAt(text, last.start);
+  const member = `${key}${serialized(value, indent)}${last.comma === undefined ? "" : ","}`;
+  const separated = last.comma === undefined ? "," : "";
+  const lineEnd = lineEndAfter(text, last.comma === undefined ? last.node.end : last.comma + 1);
+  const until = lineEnd ?? (last.comma === undefined ? last.node.end : last.comma + 1);
+  return { start: last.node.end, end: until, text: `${separated}${text.slice(last.node.end, until)}${lineEnd === undefined ? " " : `\n${indent}`}${member}` };
+}
+
+function removal(text: string, { entries }: Container, entry: Entry): readonly Edit[] {
+  const index = entries.indexOf(entry);
+  const followed = index < entries.length - 1;
+  const end = entry.comma === undefined ? entry.node.end : entry.comma + 1;
+  const lineStart = spacesFrom(text, entry.start, -1);
+  const lineEnd = spacesFrom(text, end, 1);
+  const newline = newlineAt(text, lineEnd);
+  const before = entries[index - 1]?.comma;
+  const comma = !followed && entry.comma === undefined && before !== undefined ? [{ start: before, end: before + 1, text: "" }] : [];
+  if (newline !== undefined && (lineStart === 0 || text.charAt(lineStart - 1) === "\n")) return [...comma, { start: lineStart, end: lineEnd + newline, text: "" }];
+  return [...comma, followed ? { start: entry.start, end: lineEnd, text: "" } : { start: lineStart, end, text: "" }];
+}
+
+function applied(text: string, edits: readonly Edit[]): string {
+  return edits.toSorted((one, other) => other.start - one.start).reduce((out, { start, end, text: replacement }) => out.slice(0, start) + replacement + out.slice(end), text);
+}
+
+// The text parses as JSONC.
+export function hasMember(text: string, path: readonly [Step, ...Step[]]): boolean {
+  const found = reached(text, path);
+  return found !== undefined && !("missing" in found);
+}
+
+// The text parses as JSONC, and value is a JSON value.
+export function withMember(text: string, path: readonly [Step, ...Step[]], value: unknown): string {
+  const found = reached(text, path);
+  if (found === undefined) return text;
+  if ("missing" in found) {
+    const [step, ...tail] = found.missing;
+    return applied(text, [insertion(text, found.container, step, childValue(step, tail, value))]);
+  }
+  const { node, start } = found.entry;
+  if (Bun.deepEquals(valueOf(text, node), value)) return text;
+  return applied(text, [{ start: node.start, end: node.end, text: serialized(value, indentAt(text, start)) }]);
+}
+
+// The text parses as JSONC.
+export function withoutMember(text: string, path: readonly [Step, ...Step[]]): string {
+  const found = reached(text, path);
+  if (found === undefined || "missing" in found) return text;
+  return applied(text, removal(text, found.container, found.entry));
+}

package/src/quality/presets/dependency-cruiser.ts

@@ -0,0 +1,148 @@
+import { existsSync, readFileSync } from "node:fs";
+import type { IConfiguration, ICruiseOptions, IForbiddenRuleType } from "dependency-cruiser";
+
+// dependency-cruiser's type requires builtInModules.override beside add, while an empty override would drop every built-in.
+type CruiseOptions = Omit<ICruiseOptions, "builtInModules"> & {
+  readonly builtInModules?: Partial<NonNullable<ICruiseOptions["builtInModules"]>>;
+};
+
+export type CruiseConfig = Omit<IConfiguration, "extends" | "options"> & { readonly options?: CruiseOptions };
+
+export type ChecksCruiseConfig = CruiseConfig & {
+  readonly devOnly?: readonly string[];
+  readonly orphans?: readonly string[];
+};
+
+export const DEV_ONLY = ["^tests/"] as const;
+
+const TEST_FILES = "[.](?:spec|test)[.](?:js|mjs|cjs|jsx|ts|mts|cts|tsx)$";
+
+const MANIFEST = "package.json";
+
+const CONFIG_FILES = "(^|/)[^/]*[.]config[.](?:js|cjs|mjs|ts|cts|mts)$";
+
+type ExcludeObject = Exclude<NonNullable<ICruiseOptions["exclude"]>, string | readonly string[]>;
+
+const BASE = {
+  forbidden: [
+    {
+      name: "no-circular",
+      severity: "error",
+      comment: "A circular relationship never has a single entry point, so invert one side.",
+      from: {},
+      to: { circular: true },
+    },
+    {
+      name: "no-orphans",
+      severity: "error",
+      comment: "Nothing reaches this module. Use it, remove it, or exempt the entry point by name in your own config.",
+      from: {
+        orphan: true,
+        pathNot: [
+          "(^|/)[.][^/]+[.](?:js|cjs|mjs|ts|cts|mts|json)$",
+          "[.]d[.]ts$",
+          "(^|/)tsconfig[.]json$",
+          "(^|/)(?:babel|webpack)[.]config[.](?:js|cjs|mjs|ts|cts|mts|json)$",
+          CONFIG_FILES,
+          TEST_FILES,
+        ],
+      },
+      to: {},
+    },
+    {
+      name: "not-to-dev-dep",
+      severity: "error",
+      comment:
+        "Shipped source cannot rely on a package that is absent in production. Move it to dependencies or peerDependencies, or keep the import in a test or config file.",
+      from: { pathNot: [TEST_FILES, CONFIG_FILES] },
+      to: { dependencyTypes: ["npm-dev"], dependencyTypesNot: ["type-only", "npm-peer"] },
+    },
+    {
+      name: "no-non-package-json",
+      severity: "error",
+      comment:
+        "The import resolves to an installed package the nearest package.json does not declare, so it holds only while something else keeps it hoisted. Declare it in dependencies, devDependencies or peerDependencies.",
+      from: {},
+      // dependency-cruiser reads every package.json key holding "ependencies" as a list, so peerDependenciesMeta tags a declared peer npm-no-pkg too.
+      to: { dependencyTypes: ["npm-no-pkg", "npm-unknown"], dependencyTypesNot: ["npm", "npm-dev", "npm-optional", "npm-peer"] },
+    },
+    {
+      name: "not-to-unresolvable",
+      severity: "error",
+      comment: "Nothing installed answers to this specifier. Install the package or fix the path.",
+      from: {},
+      to: { couldNotResolve: true },
+    },
+    {
+      name: "no-deep-imports",
+      severity: "error",
+      comment:
+        "The specifier reaches past the package name into a subpath its exports map does not publish. Depend on a published entry instead.",
+      from: {},
+      to: { couldNotResolve: true, path: "^(@[^/]+/[^/]+|[^@./#][^/]*)/" },
+    },
+  ],
+  options: {
+    parser: "swc",
+    builtInModules: { add: ["bun"] },
+    doNotFollow: { path: ["node_modules"] },
+    // The cruise follows the repos/ links without this.
+    exclude: { path: "^repos/" },
+    enhancedResolveOptions: {
+      exportsFields: ["exports"],
+      conditionNames: ["types", "import", "require", "node", "default"],
+    },
+  },
+} satisfies CruiseConfig;
+
+export const base: CruiseConfig = BASE;
+
+function asList(value: string | readonly string[] | undefined): readonly string[] {
+  if (value === undefined) return [];
+  return typeof value === "string" ? [value] : value;
+}
+
+function widened(rule: IForbiddenRuleType, extra: readonly string[]): IForbiddenRuleType {
+  if (extra.length === 0 || !("pathNot" in rule.from)) return rule;
+  return { ...rule, from: { ...rule.from, pathNot: [...asList(rule.from.pathNot), ...extra] } };
+}
+
+function kitRule(rule: IForbiddenRuleType, devOnly: readonly string[], orphans: readonly string[]): IForbiddenRuleType {
+  if (rule.name === "not-to-dev-dep") return widened(rule, devOnly);
+  if (rule.name === "no-orphans") return widened(rule, orphans);
+  return rule;
+}
+
+function excludeObject(exclude: ICruiseOptions["exclude"]): ExcludeObject {
+  if (exclude === undefined || typeof exclude === "string" || Array.isArray(exclude)) return { path: [...asList(exclude)] };
+  return exclude;
+}
+
+function joinedExclude(exclude: ICruiseOptions["exclude"]): ExcludeObject {
+  const own = excludeObject(exclude);
+  return { ...own, path: [...asList(BASE.options.exclude.path), ...asList(own.path)] };
+}
+
+function declaresAstro(manifest: unknown): boolean {
+  if (typeof manifest !== "object" || manifest === null) return false;
+  return ["dependencies", "devDependencies"].some((field) => {
+    const declared: unknown = Reflect.get(manifest, field);
+    return typeof declared === "object" && declared !== null && "astro" in declared;
+  });
+}
+
+// The cruise never reads an .astro importer, so a module only a page imports would read as an orphan.
+function dependsOnAstro(): boolean {
+  return existsSync(MANIFEST) && declaresAstro(JSON.parse(readFileSync(MANIFEST, "utf8")));
+}
+
+export function defineConfig({ devOnly = DEV_ONLY, orphans = [], forbidden = [], options, ...rest }: ChecksCruiseConfig = {}): CruiseConfig {
+  const named = new Set(forbidden.map(({ name }) => name));
+  if (dependsOnAstro()) named.add("no-orphans");
+  const kitRules = BASE.forbidden.filter(({ name }) => !named.has(name)).map((rule) => kitRule(rule, devOnly, orphans));
+  return {
+    ...rest,
+    forbidden: [...kitRules, ...forbidden],
+    options: { ...BASE.options, ...options, exclude: joinedExclude(options?.exclude) },
+  };
+}

package/src/quality/presets/oxlint.ts

@@ -0,0 +1,165 @@
+import { fileURLToPath } from "node:url";
+import type { OxlintConfig, OxlintOverride } from "oxlint";
+
+type Globs = readonly [string, ...string[]];
+
+export type EffectScope = boolean | { readonly files?: Globs; readonly excludeFiles?: readonly string[] };
+
+export type ChecksConfig = Omit<OxlintConfig, "extends" | "plugins" | "jsPlugins" | "categories"> & {
+  readonly effect: EffectScope;
+};
+
+const SIZE_RULES = ["max-lines", "max-lines-per-function", "max-statements", "readability/cognitive-complexity", "max-depth"] as const;
+
+export type SizeRule = (typeof SIZE_RULES)[number];
+
+export type SizeLimits = Readonly<Record<SizeRule, number | "off">>;
+
+export const SOURCE_LIMITS = {
+  "max-lines": 400,
+  "max-lines-per-function": 100,
+  "max-statements": 30,
+  "readability/cognitive-complexity": 15,
+  "max-depth": 4,
+} as const satisfies SizeLimits;
+
+export const TEST_LIMITS = {
+  "max-lines": 600,
+  "max-lines-per-function": "off",
+  "max-statements": 50,
+  "readability/cognitive-complexity": 15,
+  "max-depth": 4,
+} as const satisfies SizeLimits;
+
+export const SOURCES = ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"] as const;
+
+export const TESTS = ["tests/**", "**/*.test.ts", "**/*.test.tsx"] as const;
+
+const PLUGINS = ["typescript", "oxc", "eslint", "import"] as const;
+
+const EFFECT_ONLY_PLUGINS = ["node", "promise", "unicorn"] as const;
+
+const EFFECT_PLUGINS = [...PLUGINS, ...EFFECT_ONLY_PLUGINS] as const;
+
+const JS_PLUGINS = ["dist/effect-channel/index.js", "dist/readability/index.js", "dist/data-shape/index.js"] as const;
+
+const EFFECT_RULES = {
+  "node/no-sync": "error",
+  "oxc/no-async-await": "error",
+  "promise/avoid-new": "error",
+  "unicorn/no-process-exit": "error",
+  "effect-channel/no-throw": "error",
+  "effect-channel/no-try-catch": "error",
+} as const;
+
+const LINE_RULES: ReadonlySet<SizeRule> = new Set(["max-lines", "max-lines-per-function"]);
+
+const REFUSED_EFFECT = "@avi2dg/checks/oxlint: set effect to true, false, or { files, excludeFiles } with at least one glob in files";
+
+// oxlint reads each relative jsPlugins path against the consumer's config, not against this package.
+function packagePath(path: string): string {
+  return fileURLToPath(new URL(`../../${path}`, import.meta.url));
+}
+
+const BASE = {
+  plugins: [...PLUGINS],
+  jsPlugins: JS_PLUGINS.map(packagePath),
+  categories: { correctness: "error", suspicious: "error" },
+  rules: {
+    "effect-channel/no-error-channel-escape": "error",
+    "typescript/no-explicit-any": "error",
+    "typescript/ban-ts-comment": ["error", { "ts-expect-error": true }],
+    "typescript/no-inferrable-types": "error",
+    "typescript/explicit-module-boundary-types": "error",
+    "typescript/switch-exhaustiveness-check": "error",
+    "typescript/prefer-readonly": "error",
+    "typescript/no-unnecessary-condition": ["error", { allowConstantLoopConditions: true }],
+    "typescript/no-unnecessary-type-parameters": "error",
+    "typescript/use-unknown-in-catch-callback-variable": "error",
+    "eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_", varsIgnorePattern: "^_", ignoreRestSiblings: true }],
+    "typescript/no-unsafe-type-assertion": "error",
+    "typescript/no-non-null-assertion": "error",
+    "typescript/no-deprecated": "error",
+    "typescript/consistent-return": "off",
+  },
+  overrides: [
+    {
+      files: ["**/*.ts", "**/*.tsx"],
+      rules: { "data-shape/readonly-collection-param": "error" },
+    },
+    {
+      files: ["**/*.ts", "**/*.tsx"],
+      excludeFiles: ["tests/**"],
+      rules: {
+        "data-shape/schema-twin": "error",
+        "typescript/no-unsafe-assignment": "error",
+        "typescript/no-unsafe-member-access": "error",
+        "typescript/no-unsafe-argument": "error",
+        "typescript/no-unsafe-return": "error",
+        "typescript/no-unsafe-call": "error",
+      },
+    },
+    {
+      files: ["**/*.astro"],
+      rules: { "readability/thin-astro": "error", "import/no-unassigned-import": "off" },
+    },
+  ],
+} satisfies OxlintConfig;
+
+export const base: OxlintConfig = BASE;
+
+function sizeSetting(rule: SizeRule, limit: number | "off"): NonNullable<OxlintConfig["rules"]>[string] {
+  if (limit === "off") return "off";
+  return LINE_RULES.has(rule) ? ["error", { max: limit, skipBlankLines: false, skipComments: false }] : ["error", { max: limit }];
+}
+
+export function sizeBudget(files: readonly string[], limits: SizeLimits, excludeFiles: readonly string[] = []): OxlintOverride {
+  const rules = Object.fromEntries(SIZE_RULES.map((rule) => [rule, sizeSetting(rule, limits[rule])]));
+  return { files: [...files], excludeFiles: [...excludeFiles], rules };
+}
+
+export function effectRules(files: readonly string[], excludeFiles: readonly string[] = []): OxlintOverride {
+  return { files: [...files], excludeFiles: [...excludeFiles], plugins: [...EFFECT_PLUGINS], rules: { ...EFFECT_RULES } };
+}
+
+function isGlobList(value: unknown): value is readonly string[] {
+  return Array.isArray(value) && value.every((glob) => typeof glob === "string" && glob !== "");
+}
+
+// The types already refuse each case below, and the guard repeats them for a config no typecheck reads.
+function effectOverrides(effect: unknown): readonly OxlintOverride[] {
+  if (effect === true) return [effectRules(SOURCES, TESTS)];
+  if (effect === false) return [];
+  if (typeof effect !== "object" || effect === null) throw new TypeError(REFUSED_EFFECT);
+  const files = "files" in effect ? effect.files : undefined;
+  const excludeFiles = "excludeFiles" in effect ? effect.excludeFiles : [];
+  if (!isGlobList(excludeFiles)) throw new TypeError(REFUSED_EFFECT);
+  if (files === undefined) return [effectRules(SOURCES, [...TESTS, ...excludeFiles])];
+  if (!isGlobList(files) || files.length === 0) throw new TypeError(REFUSED_EFFECT);
+  return [effectRules(files, excludeFiles)];
+}
+
+// oxlint drops an override's setting for a rule whose plugin is neither top-level nor named in that override.
+// Naming only that plugin turns on its correctness and suspicious rules, and naming the Effect override's set does not.
+function withRulePlugins(override: OxlintOverride): OxlintOverride {
+  const rules = Object.keys(override.rules ?? {});
+  const namesEffectOnlyRule = rules.some((rule) => EFFECT_ONLY_PLUGINS.some((plugin) => rule.startsWith(`${plugin}/`)));
+  if (!namesEffectOnlyRule) return override;
+  return { ...override, plugins: [...new Set([...EFFECT_PLUGINS, ...(override.plugins ?? [])])] };
+}
+
+export function defineConfig({ effect, rules, overrides = [], options, ...rest }: ChecksConfig): OxlintConfig {
+  return {
+    ...BASE,
+    ...rest,
+    options: { typeAware: true, ...options },
+    rules: { ...BASE.rules, ...rules },
+    overrides: [
+      ...BASE.overrides,
+      sizeBudget(SOURCES, SOURCE_LIMITS, TESTS),
+      sizeBudget(TESTS, TEST_LIMITS),
+      ...effectOverrides(effect),
+      ...overrides.map(withRulePlugins),
+    ],
+  };
+}

package/stryker.preset.js

@@ -1,3 +1,4 @@
+import { readdirSync } from "node:fs";
 import { availableParallelism } from "node:os";
 import { fileURLToPath } from "node:url";
 import { GUARD_IGNORER } from "./src/testing/mutation-guard-plugin.js";
@@ -9,6 +10,13 @@ if (refusal !== undefined) throw new Error(refusal);
 
 export const halfAvailableCores = (cores = availableParallelism()) => Math.max(1, Math.floor(cores / 2));
 
+// The bun runner narrows a mutant's run to its covering files only when each listed path equals a test id's file part, which carries no leading ./.
+export const unitTestFiles = () =>
+  readdirSync("tests/unit", { recursive: true, encoding: "utf8" })
+    .filter((name) => name.endsWith(".test.ts") || name.endsWith(".test.tsx"))
+    .map((name) => `tests/unit/${name}`)
+    .toSorted();
+
 export default {
   packageManager: "npm",
   plugins: [

package/src/quality/presets/effect.oxlint.json

@@ -1,11 +0,0 @@
-{
-  "plugins": ["node", "promise", "unicorn"],
-  "rules": {
-    "node/no-sync": "error",
-    "oxc/no-async-await": "error",
-    "promise/avoid-new": "error",
-    "unicorn/no-process-exit": "error",
-    "effect-channel/no-throw": "error",
-    "effect-channel/no-try-catch": "error"
-  }
-}