@avi2dg/checks 0.20.0 → 0.22.0

package/scripts/lint.ts

@@ -1,10 +1,9 @@
 #!/usr/bin/env bun
 import { Config, Console, Effect, FileSystem, Option, Path, Schema } from "effect";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-import { DEFAULT_BRANCH, selectedGates, type KitGate } from "./gates.ts";
-import { git } from "./git.ts";
+import { EVERY_REPOSITORY, KIT_GATES, type KitGate } from "./gates.ts";
+import { defaultBranch, git } from "./git.ts";
 import { runMain, Usage } from "./main.ts";
-import { readQuality } from "./quality-file.ts";
 
 type Range = {
   readonly refs: readonly [tip: string] | readonly [base: string, head: string];
@@ -56,17 +55,6 @@ const pullRequestEnds = Effect.fn("pullRequestEnds")(function* (eventPath: strin
   return pullRequestEndsOf(pullRequest);
 });
 
-const readWiring = Effect.gen(function* () {
-  const { source, quality } = yield* readQuality((yield* git(["rev-parse", "--show-toplevel"])).trim());
-  return { source, defaultBranch: quality.defaultBranch ?? DEFAULT_BRANCH, lintGates: quality.gates?.lint };
-});
-
-// Decides the base ref `git symbolic-ref` already resolved, or the repository's declared
-// default branch when that ref is absent, such as a checkout with no remote HEAD symlink.
-export function originRefOf(symbolicRef: string | undefined, defaultBranch: string): string {
-  return symbolicRef ?? `origin/${defaultBranch}`;
-}
-
 // A clone holding any remote-tracking ref but not the default branch is a shallow CI checkout,
 // where judging HEAD alone would pass every commit before it unchecked. No origin ref means no remote-tracking ref at all.
 export function localEndsOf(originRef: string | undefined): { base: string; head: string; source: string } {
@@ -74,18 +62,11 @@ export function localEndsOf(originRef: string | undefined): { base: string; head
   return { base: originRef, head: "HEAD", source: `HEAD against ${originRef}` };
 }
 
-const originRef = (defaultBranch: string) =>
-  git(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]).pipe(
-    Effect.map((ref) => ref.trim()),
-    Effect.catchTag("GitFailure", () => Effect.succeed(undefined)),
-    Effect.map((symbolicRef) => originRefOf(symbolicRef, defaultBranch)),
-  );
-
-const localEnds = Effect.fn("localEnds")(function* (defaultBranch: string) {
+const localEnds = Effect.gen(function* () {
   const remoteTracking = yield* git(["for-each-ref", "--count=1", "refs/remotes/"]).pipe(
     Effect.mapError((cause) => new RangeUnresolved({ message: cause.message })),
   );
-  return localEndsOf(remoteTracking.trim() === "" ? undefined : yield* originRef(defaultBranch));
+  return localEndsOf(remoteTracking.trim() === "" ? undefined : `origin/${yield* defaultBranch()}`);
 });
 
 // Decides which source of range ends the arguments and the pull request env vars select,
@@ -107,7 +88,7 @@ export function selectEnds(args: readonly string[], eventName: string | undefine
   return { kind: "local" };
 }
 
-const endsOf = Effect.fn("endsOf")(function* (args: readonly string[], defaultBranch: string) {
+const endsOf = Effect.fn("endsOf")(function* (args: readonly string[]) {
   const event = yield* Config.all({
     name: Config.option(Config.String("GITHUB_EVENT_NAME")),
     path: Config.option(Config.String("GITHUB_EVENT_PATH")),
@@ -127,7 +108,7 @@ const endsOf = Effect.fn("endsOf")(function* (args: readonly string[], defaultBr
     case "pull-request-unresolved":
       return yield* new RangeUnresolved({ message: `${PULL_REQUEST_EVENT} sets no GITHUB_EVENT_PATH` });
     case "local":
-      return yield* localEnds(defaultBranch);
+      return yield* localEnds;
   }
 });
 
@@ -147,8 +128,8 @@ export function rangeOf(base: string, head: string): Range["refs"] {
 
 // From the base branch's tip, every range gate would charge the head with the commits the base
 // branch gained after the head branched off.
-const resolveRange = Effect.fn("resolveRange")(function* (args: readonly string[], defaultBranch: string) {
-  const ends = yield* endsOf(args, defaultBranch);
+const resolveRange = Effect.fn("resolveRange")(function* (args: readonly string[]) {
+  const ends = yield* endsOf(args);
   const head = yield* commitOf(ends.head);
   const base = yield* git(["merge-base", yield* commitOf(ends.base), head]).pipe(
     Effect.map((sha) => sha.trim()),
@@ -184,14 +165,14 @@ const runGate = Effect.fn("runGate")(function* (gate: KitGate, range: Range) {
 });
 
 const lint = Effect.gen(function* () {
-  const { source, defaultBranch, lintGates } = yield* readWiring;
-  const range = yield* resolveRange(process.argv.slice(2), defaultBranch);
+  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
+  const range = yield* resolveRange(process.argv.slice(2));
   yield* Console.log(`${NAME}: ${describe(range)} from ${range.source}`);
-  const gates = selectedGates(lintGates);
-  if (lintGates !== undefined) {
-    yield* Console.log(`${NAME}: ${source} selects ${gates.map((gate) => gate.bin).join(", ")}`);
-  }
-
+  const gates = yield* Effect.filter(KIT_GATES, (gate) =>
+    gate.appliesTo === EVERY_REPOSITORY
+      ? Effect.succeed(true)
+      : git(["ls-files", "--", ...gate.appliesTo.pathspecs], root).pipe(Effect.map((files) => files.trim() !== "")),
+  );
   const verdicts = yield* Effect.forEach(gates, (gate) => runGate(gate, range));
   const failed = verdicts.filter((verdict) => verdict.outcome !== "passed");
   if (failed.length === 0) {

package/scripts/range-gate.ts

@@ -1,9 +1,8 @@
 import { Effect } from "effect";
 import { git, refArgs } from "./git.ts";
-import { readQuality } from "./quality-file.ts";
 
 export const rangeGateInputs = Effect.fn("rangeGateInputs")(function* (usage: string) {
   const refs = yield* refArgs(process.argv.slice(2), usage);
   const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
-  return { refs, root, ...(yield* readQuality(root)) };
+  return { refs, root };
 });

package/scripts/repetition.ts

@@ -2,7 +2,6 @@
 import { Console, Effect, FileSystem, Path, Schema } from "effect";
 import { changedPaths, checkoutFiles, collect, git, pathsAt, rangeFromArgs } from "./git.ts";
 import { runMain } from "./main.ts";
-import { readQuality } from "./quality-file.ts";
 
 export type Fragment = {
   readonly file: string;
@@ -34,19 +33,25 @@ const USAGE = "usage: repetition.ts <ref> | <base-ref> <head-ref>";
 const MIN_TOKENS = 50;
 const MIN_LINES = 5;
 const MEASURE = `at ${MIN_TOKENS} tokens and ${MIN_LINES} lines`;
-const DECLARATIONS = ":(exclude,glob)**/*.d.ts";
-const TYPESCRIPT = [":(glob)**/*.ts", ":(glob)**/*.tsx", DECLARATIONS];
+const CONFIG = ".jscpd.json";
 const JSCPD_FINISHED = 0;
 const REPORT = "jscpd-report.json";
 
 const Location = Schema.Struct({ name: Schema.String, start: Schema.Int, end: Schema.Int });
 
 const decodeReport = Schema.decodeUnknownEffect(
-  Schema.fromJsonString(Schema.Struct({ duplicates: Schema.Array(Schema.Struct({ firstFile: Location, secondFile: Location })) })),
+  Schema.fromJsonString(
+    Schema.Struct({
+      duplicates: Schema.Array(Schema.Struct({ firstFile: Location, secondFile: Location })),
+      statistics: Schema.Struct({ total: Schema.Struct({ sources: Schema.Int }) }),
+    }),
+  ),
 );
 
-function fragmentOf({ name, start, end }: typeof Location.Type): Fragment {
-  return { file: name, start, end };
+type Scan = { readonly sources: number; readonly clones: readonly Clone[] };
+
+function fragmentOf(file: (name: string) => string, { name, start, end }: typeof Location.Type): Fragment {
+  return { file: file(name), start, end };
 }
 
 export function repeatedLines(clones: readonly Clone[]): ReadonlyMap<string, number> {
@@ -60,28 +65,36 @@ export function repeatedLines(clones: readonly Clone[]): ReadonlyMap<string, num
 }
 
 // jscpd reads files from disk, and the working tree need not hold the revision: a merge checkout or an uncommitted edit.
+// Both ends scan under the head's config, so a changed file set never reads as a change in repetition.
 const scan = Effect.fn("scan")(
-  function* (root: string, rev: string, files: readonly string[]) {
-    if (files.length === 0) return [];
+  function* (root: string, rev: string, config: string) {
+    const files = yield* pathsAt(rev, [], root);
+    if (files.length === 0) return { sources: 0, clones: [] } satisfies Scan;
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
     const scratch = yield* fs.makeTempDirectoryScoped({ prefix: "checks-repetition-" });
     const tree = yield* checkoutFiles(rev, files, scratch, root);
+    yield* fs.writeFileString(path.join(tree, CONFIG), config);
     const output = path.join(scratch, "report");
-    const flags = ["--silent", "--no-tips", "--no-gitignore", "--reporters", "json", "--output", output];
+    const flags = ["--silent", "--no-tips", "--no-gitignore", "--absolute", "--reporters", "json", "--output", output];
     const thresholds = ["--min-tokens", `${MIN_TOKENS}`, "--min-lines", `${MIN_LINES}`];
 
-    const run = yield* collect("jscpd", [...flags, ...thresholds, "."], tree).pipe(
+    const run = yield* collect("jscpd", [...flags, ...thresholds], tree).pipe(
       Effect.mapError((cause) => new JscpdUnreadable({ message: `cannot run jscpd: ${cause.message}` })),
     );
-    if (run.exitCode !== JSCPD_FINISHED) {
+    const reportPath = path.join(output, REPORT);
+    // A threshold, exitCode or failOnEmpty in the repository's config fails jscpd after the report is written.
+    if (run.exitCode !== JSCPD_FINISHED && !(yield* fs.exists(reportPath))) {
       return yield* new JscpdUnreadable({ message: `jscpd exited ${run.exitCode}: ${run.stderr.trim() || run.stdout.trim()}` });
     }
-    const { duplicates } = yield* fs.readFileString(path.join(output, REPORT)).pipe(
+    const { duplicates, statistics } = yield* fs.readFileString(reportPath).pipe(
       Effect.flatMap(decodeReport),
       Effect.mapError((cause) => new JscpdUnreadable({ message: `cannot read jscpd's report: ${cause.message}` })),
     );
-    return duplicates.map(({ firstFile, secondFile }): Clone => [fragmentOf(firstFile), fragmentOf(secondFile)]);
+    const scanned = yield* fs.realPath(tree);
+    const file = (name: string): string => path.relative(scanned, name);
+    const clones = duplicates.map(({ firstFile, secondFile }): Clone => [fragmentOf(file, firstFile), fragmentOf(file, secondFile)]);
+    return { sources: statistics.total.sources, clones } satisfies Scan;
   },
   Effect.scoped,
 );
@@ -113,33 +126,22 @@ export function risesOf(
     .toSorted((a, b) => a.file.localeCompare(b.file));
 }
 
-// Tallies every held file that did not rise, plus every file outside the held set, as advisory.
-export function heldOf(
-  measured: number,
-  rises: readonly Rise[],
-  after: ReadonlyMap<string, number>,
-  othersRepeated: ReadonlyMap<string, number>,
-): Held {
+// Tallies every repeating file that did not rise as advisory.
+export function heldOf(measured: number, rises: readonly Rise[], after: ReadonlyMap<string, number>): Held {
   const risen = new Set(rises.map((rise) => rise.file));
-  const advisory = [...after].filter(([file]) => !risen.has(file)).concat([...othersRepeated]);
+  const advisory = [...after].filter(([file]) => !risen.has(file));
   return { measured, rises, advisory: new Map(advisory.toSorted(([a], [b]) => a.localeCompare(b))) };
 }
 
-const runHold = Effect.fn("runHold")(function* (root: string, production: readonly string[], base: string, head: string) {
-  const pathspecs = [...production.map((glob) => `:(glob)${glob}`), DECLARATIONS];
-  const held = yield* pathsAt(head, pathspecs, root);
-  const holds = new Set(held);
-  const others = (yield* pathsAt(head, TYPESCRIPT, root)).filter((file) => !holds.has(file));
+const runHold = Effect.fn("runHold")(function* (root: string, config: string, base: string, head: string) {
   const formerPath = new Map(
-    (yield* changedPaths(base, head, pathspecs, root)).flatMap((change) => (change.kind === "renamed" ? [[change.path, change.from]] : [])),
+    (yield* changedPaths(base, head, [], root)).flatMap((change) => (change.kind === "renamed" ? [[change.path, change.from]] : [])),
   );
-
-  const before = repeatedLines(yield* scan(root, base, yield* pathsAt(base, pathspecs, root)));
-  const clones = yield* scan(root, head, held);
+  const before = repeatedLines((yield* scan(root, base, config)).clones);
+  const { sources, clones } = yield* scan(root, head, config);
   const after = repeatedLines(clones);
-  const rises = risesOf(held, before, after, formerPath, clones);
-  const othersRepeated = repeatedLines(yield* scan(root, head, others));
-  return heldOf(held.length, rises, after, othersRepeated) satisfies Held;
+  const rises = risesOf([...after.keys()], before, after, formerPath, clones);
+  return heldOf(sources, rises, after) satisfies Held;
 });
 
 export function describe({ file, before, after, clones }: Rise): readonly string[] {
@@ -152,8 +154,8 @@ export function describe({ file, before, after, clones }: Rise): readonly string
 export function report({ measured, rises, advisory }: Held): string {
   const verdict =
     rises.length === 0
-      ? [`${NAME}: ${measured} production file(s) repeat no more lines than where the range starts, ${MEASURE}`]
-      : [`${NAME}: ${rises.length} production file(s) repeat more lines than where the range starts, ${MEASURE}:`, ...rises.flatMap(describe)];
+      ? [`${NAME}: ${measured} file(s) ${CONFIG} holds repeat no more lines than where the range starts, ${MEASURE}`]
+      : [`${NAME}: ${rises.length} file(s) ${CONFIG} holds repeat more lines than where the range starts, ${MEASURE}:`, ...rises.flatMap(describe)];
   const notice =
     advisory.size === 0
       ? []
@@ -167,13 +169,11 @@ export function report({ measured, rises, advisory }: Held): string {
 const hold = Effect.gen(function* () {
   const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
   const { base, head } = yield* rangeFromArgs(process.argv.slice(2), USAGE, root);
-  const { source, quality } = yield* readQuality(root);
-  const production = quality.sources?.production ?? [];
-  if (production.length === 0) {
-    yield* Console.log(`${NAME}: ${source} declares no sources.production`);
+  if ((yield* pathsAt(head, [`:(literal)${CONFIG}`], root)).length === 0) {
+    yield* Console.log(`${NAME}: the head holds no ${CONFIG}, so no file is measured`);
     return true;
   }
-  const held = yield* runHold(root, production, base, head);
+  const held = yield* runHold(root, yield* git(["show", `${head}:${CONFIG}`], root), base, head);
 
   yield* Console.log(report(held));
   return held.rises.length === 0;

package/scripts/shell-command.ts

@@ -64,8 +64,14 @@ export function plainCommand(script: string): Command | undefined {
   return words.length === 0 ? undefined : words;
 }
 
+// bun run resolves any other word, even one holding a slash, to a package.json script of that name first.
+const FILE_PATH = /^\.{0,2}\//;
+
 export function invokes(command: Command | undefined, gate: Command): boolean {
-  return command !== undefined && gate.length <= command.length && gate.every((word, index) => command[index] === word);
+  if (command === undefined) return false;
+  const begins = (words: Command) => gate.length <= words.length && gate.every((word, index) => words[index] === word);
+  const bunRunsFile = command[0] === "bun" && command[1] === "run" && FILE_PATH.test(gate[0] ?? "");
+  return begins(command) || (bunRunsFile && begins(command.slice(2)));
 }
 
 export function mentions(script: string, gate: Command): boolean {

package/scripts/swc.ts

@@ -0,0 +1,46 @@
+import { parse } from "@swc/core";
+import { Effect, Schema } from "effect";
+
+export class TypeScriptParseError extends Schema.TaggedError<TypeScriptParseError>()("TypeScriptParseError", {
+  message: Schema.String,
+}) {}
+
+export const parseTypeScript = Effect.fn("parseTypeScript")(function* (file: string, source: string) {
+  return yield* Effect.tryPromise({
+    try: () => parse(source, { syntax: "typescript", tsx: file.endsWith(".tsx"), target: "esnext" }),
+    catch: (cause) => new TypeScriptParseError({ message: `cannot parse ${file}: ${String(cause)}` }),
+  });
+});
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+export function identifierName(node: unknown): string | undefined {
+  if (!isRecord(node) || node["type"] !== "Identifier") return undefined;
+  const value = node["value"];
+  return typeof value === "string" ? value : undefined;
+}
+
+export function stringValue(node: unknown): string | undefined {
+  if (!isRecord(node) || node["type"] !== "StringLiteral") return undefined;
+  const value = node["value"];
+  return typeof value === "string" ? value : undefined;
+}
+
+export function spanStart(node: Record<string, unknown>): number {
+  const span = node["span"];
+  if (!isRecord(span)) return 0;
+  const start = span["start"];
+  return typeof start === "number" ? start : 0;
+}
+
+export function lineOf(source: string, start: number): number {
+  const bytes = Buffer.from(source, "utf8");
+  const offset = Math.max(0, Math.min(bytes.length, start - 1));
+  let line = 1;
+  for (let index = 0; index < offset; index += 1) {
+    if (bytes[index] === 0x0a) line += 1;
+  }
+  return line;
+}

package/scripts/test-layout.ts

@@ -1,10 +1,9 @@
 #!/usr/bin/env bun
-import { parse } from "@swc/core";
 import { Console, Effect, FileSystem, Path, Schema } from "effect";
 import { git } from "./git.ts";
 import { runMain } from "./main.ts";
-import { ENTRY_POINT, QUALITY_FILE, TEST_ENTRY_POINT } from "./gates.ts";
-import { readQuality } from "./quality-file.ts";
+import { ENTRY_POINT, TEST_ENTRY_POINT } from "./gates.ts";
+import { identifierName, isRecord, lineOf, parseTypeScript, spanStart, stringValue } from "./swc.ts";
 
 export type Violation = {
   readonly file: string;
@@ -42,12 +41,15 @@ const BANNED_GLOBAL_CALLS: readonly string[] = ["fetch"];
 
 const IGNORES_KEY = "pathIgnorePatterns";
 const QUARANTINE = "**/tests/quarantine/**";
+const LIVE_TESTS = "**/tests/live/**";
+const PIXEL_TESTS = "**/tests/pixel/**";
 const VENDORED = "repos/**";
-const PRESET_IGNORES: readonly string[] = [QUARANTINE, VENDORED];
-
-function acceptedIgnores(vendors: boolean): readonly (readonly string[])[] {
-  return vendors ? [PRESET_IGNORES] : [PRESET_IGNORES, [QUARANTINE]];
-}
+const TEST_TIERS = ["live", "pixel"] as const;
+const OUT_OF_PROCESS: readonly string[] = [E2E, ...TEST_TIERS.map((tier) => `${TESTS}${tier}/`)];
+const ACCEPTED_IGNORES: readonly (readonly string[])[] = [
+  [QUARANTINE, LIVE_TESTS, PIXEL_TESTS, VENDORED],
+  [QUARANTINE, LIVE_TESTS, PIXEL_TESTS],
+];
 export const LAYOUT_CHECK_MARK = "scripts/test-layout.ts";
 export const LAYOUT_CHECK_BIN = "checks-test-layout";
 const OWN_ENTRY_POINT = `scripts/${ENTRY_POINT.script}`;
@@ -57,10 +59,6 @@ export class LayoutError extends Schema.TaggedError<LayoutError>()("LayoutError"
   message: Schema.String,
 }) {}
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
 function runsLayoutCheck(lint: string): boolean {
   if (lint.includes(LAYOUT_CHECK_MARK) || lint.includes(LAYOUT_CHECK_BIN)) return true;
   return lint.split(/[\s|&;()]+/).some((word) => word === ENTRY_POINT.bin || word === OWN_ENTRY_POINT);
@@ -104,40 +102,11 @@ export function placementViolations(files: readonly string[]): readonly Violatio
   return violations;
 }
 
-function lineOf(source: string, start: number): number {
-  const bytes = Buffer.from(source, "utf8");
-  const offset = Math.max(0, Math.min(bytes.length, start - 1));
-  let line = 1;
-  for (let index = 0; index < offset; index += 1) {
-    if (bytes[index] === 0x0a) line += 1;
-  }
-  return line;
-}
-
 function bannedModule(specifier: string): string | undefined {
   const bare = specifier.startsWith("node:") ? specifier.slice("node:".length) : specifier;
   return BANNED_MODULES.includes(bare) ? bare : undefined;
 }
 
-function identifierName(node: unknown): string | undefined {
-  if (!isRecord(node) || node["type"] !== "Identifier") return undefined;
-  const value = node["value"];
-  return typeof value === "string" ? value : undefined;
-}
-
-function stringValue(node: unknown): string | undefined {
-  if (!isRecord(node) || node["type"] !== "StringLiteral") return undefined;
-  const value = node["value"];
-  return typeof value === "string" ? value : undefined;
-}
-
-function spanStart(node: Record<string, unknown>): number {
-  const span = node["span"];
-  if (!isRecord(span)) return 0;
-  const start = span["start"];
-  return typeof start === "number" ? start : 0;
-}
-
 function importedNames(node: Record<string, unknown>): readonly string[] {
   const specifiers = node["specifiers"];
   if (!Array.isArray(specifiers)) return [];
@@ -197,10 +166,9 @@ function outOfProcessUse(node: Record<string, unknown>): string | undefined {
 }
 
 export const isolationViolations = Effect.fn("isolationViolations")(function* (file: string, source: string) {
-  const module = yield* Effect.tryPromise({
-    try: () => parse(source, { syntax: "typescript", tsx: file.endsWith(".tsx"), target: "esnext" }),
-    catch: (error) => new LayoutError({ message: `cannot parse ${file}: ${String(error)}` }),
-  });
+  const module = yield* parseTypeScript(file, source).pipe(
+    Effect.mapError((error) => new LayoutError({ message: error.message })),
+  );
   const violations: Violation[] = [];
   const seen = new Set<unknown>();
 
@@ -228,7 +196,22 @@ export const isolationViolations = Effect.fn("isolationViolations")(function* (f
   return violations;
 });
 
-export function scriptViolations(manifest: unknown): readonly Violation[] {
+function tierScriptViolation(scripts: unknown, files: readonly string[], tier: (typeof TEST_TIERS)[number]): Violation | undefined {
+  const file = "package.json";
+  const key = `test:${tier}`;
+  const found = isRecord(scripts) ? scripts[key] : undefined;
+  const expected = `${TEST_ENTRY_POINT.bin} --tier=${tier}`;
+  const hasTests = files.some((candidate) => candidate.startsWith(`tests/${tier}/`) && TEST_FILE.test(candidate));
+  if (!hasTests && found === undefined) return undefined;
+  if (found === expected) return undefined;
+  return {
+    file,
+    line: undefined,
+    message: `${key} must be "${expected}"${hasTests ? " when its test tier has files" : " when declared"}, found ${JSON.stringify(found ?? null)}`,
+  };
+}
+
+export function scriptViolations(manifest: unknown, files: readonly string[] = []): readonly Violation[] {
   const file = "package.json";
   const scripts = isRecord(manifest) ? manifest["scripts"] : undefined;
   const test = isRecord(scripts) ? scripts["test"] : undefined;
@@ -248,10 +231,14 @@ export function scriptViolations(manifest: unknown): readonly Violation[] {
       message: `scripts.lint must run the layout check: add "${ENTRY_POINT.bin}"`,
     });
   }
+  for (const tier of TEST_TIERS) {
+    const violation = tierScriptViolation(scripts, files, tier);
+    if (violation !== undefined) violations.push(violation);
+  }
   return violations;
 }
 
-export function bunfigViolations(consumer: unknown, preset: unknown, vendors: boolean): readonly Violation[] {
+export function bunfigViolations(consumer: unknown, preset: unknown): readonly Violation[] {
   const file = "bunfig.toml";
   const copy = "bun has no bunfig extends, so copy node_modules/@avi2dg/checks/bunfig.toml";
   if (consumer === undefined) {
@@ -272,10 +259,9 @@ export function bunfigViolations(consumer: unknown, preset: unknown, vendors: bo
   for (const [key, value] of Object.entries(presetTest)) {
     if (key !== IGNORES_KEY && !Bun.deepEquals(found(key), value)) violations.push(drifted(key, JSON.stringify(value), copy));
   }
-  const accepted = acceptedIgnores(vendors);
-  if (!accepted.some((ignores) => Bun.deepEquals(found(IGNORES_KEY), ignores))) {
-    const wanted = accepted.map((ignores) => JSON.stringify(ignores)).join(" or ");
-    violations.push(drifted(IGNORES_KEY, wanted, `the check pins it, requiring ${VENDORED} where ${QUALITY_FILE} declares sources.libraries`));
+  if (!ACCEPTED_IGNORES.some((ignores) => Bun.deepEquals(found(IGNORES_KEY), ignores))) {
+    const wanted = ACCEPTED_IGNORES.map((ignores) => JSON.stringify(ignores)).join(" or ");
+    violations.push(drifted(IGNORES_KEY, wanted, `the check pins it, and a repository that links libraries under repos/ keeps ${VENDORED}`));
   }
   return violations;
 }
@@ -318,7 +304,7 @@ export const run = Effect.fn("run")(function* (root: string, presetPath: string)
     (file) =>
       file.startsWith(TESTS) &&
       TYPESCRIPT.test(file) &&
-      !file.startsWith(E2E) &&
+      !startsWithAny(file, OUT_OF_PROCESS) &&
       !file.startsWith(DATA_DIR),
   );
   for (const file of inProcess) {
@@ -326,13 +312,11 @@ export const run = Effect.fn("run")(function* (root: string, presetPath: string)
     violations.push(...(yield* isolationViolations(file, source)));
   }
 
-  violations.push(...scriptViolations(yield* readManifest(path.join(root, "package.json"))));
+  violations.push(...scriptViolations(yield* readManifest(path.join(root, "package.json")), files));
 
   const bunfig = path.join(root, "bunfig.toml");
   const consumerBunfig = (yield* fs.exists(bunfig)) ? yield* parsedToml(bunfig) : undefined;
-  const { quality } = yield* readQuality(root);
-  const vendors = (quality.sources?.libraries ?? []).length > 0;
-  violations.push(...bunfigViolations(consumerBunfig, yield* parsedToml(presetPath), vendors));
+  violations.push(...bunfigViolations(consumerBunfig, yield* parsedToml(presetPath)));
 
   return { files: files.length, violations };
 });