@avi2dg/checks 0.18.0 → 0.19.0

package/scripts/quarantine-clock.ts

@@ -0,0 +1,153 @@
+#!/usr/bin/env bun
+import { Console, Effect, Schema } from "effect";
+import { commitOf, git, isShallowBoundary, refArgs } from "./git.ts";
+import { runMain } from "./main.ts";
+import { TEST_FILE } from "./test-layout.ts";
+
+export const QUARANTINE = "tests/quarantine/";
+export const QUARANTINE_DAYS = 30;
+const DAY_SECONDS = 86400;
+
+export class QuarantineError extends Schema.TaggedError<QuarantineError>()("QuarantineError", {
+  message: Schema.String,
+}) {}
+
+const USAGE = "usage: quarantine-clock.ts <ref> | <base-ref> <head-ref>";
+
+export type Entry =
+  | { readonly kind: "entered"; readonly sha: string; readonly at: number; readonly day: string }
+  | { readonly kind: "truncated" };
+
+export type Overdue = {
+  readonly file: string;
+  readonly day: string;
+  readonly days: number;
+};
+
+export type ClockResult = {
+  readonly checked: number;
+  readonly overdue: readonly Overdue[];
+};
+
+const HEADER = /^commit ([0-9a-f]{40}|[0-9a-f]{64}) (\d+) (\S+)$/;
+const TWO_PATHS = /^[RC]/;
+
+type Status = readonly [status: string, from: string, to: string];
+
+type CommitBlock = {
+  readonly sha: string;
+  readonly at: number;
+  readonly day: string;
+  readonly statuses: readonly Status[];
+};
+
+function parseBlocks(output: string): readonly CommitBlock[] {
+  const blocks: { readonly sha: string; readonly at: number; readonly day: string; readonly statuses: Status[] }[] = [];
+  const fields = output.split("\0");
+  let index = 0;
+  while (index < fields.length) {
+    const field = (fields[index] ?? "").replace(/^\n/, "");
+    index += 1;
+    const header = HEADER.exec(field);
+    if (header !== null) {
+      blocks.push({ sha: header[1] ?? "", at: Number(header[2] ?? "0"), day: (header[3] ?? "").slice(0, "YYYY-MM-DD".length), statuses: [] });
+      continue;
+    }
+    if (field === "") continue;
+    const paths = TWO_PATHS.test(field) ? 2 : 1;
+    blocks.at(-1)?.statuses.push([field, fields[index] ?? "", fields[index + paths - 1] ?? ""]);
+    index += paths;
+  }
+  return blocks;
+}
+
+function entryIn({ sha, at, day, statuses }: CommitBlock, path: string): Entry | undefined {
+  const entered = statuses.some(
+    ([status, from, to]) =>
+      to === path && (status === "A" || status.startsWith("C") || (status.startsWith("R") && !from.startsWith(QUARANTINE))),
+  );
+  return entered ? { kind: "entered", sha, at, day } : undefined;
+}
+
+function followedPath({ statuses }: CommitBlock, path: string): string {
+  const rename = statuses.find(([status, , to]) => status.startsWith("R") && to === path);
+  return rename?.[1] ?? path;
+}
+
+export function findEntry(output: string, file: string): Entry {
+  let current = file;
+  for (const block of parseBlocks(output)) {
+    const entry = entryIn(block, current);
+    if (entry !== undefined) return entry;
+    current = followedPath(block, current);
+  }
+  return { kind: "truncated" };
+}
+
+export function overdueOf(
+  entries: readonly { readonly file: string; readonly at: number; readonly day: string }[],
+  headAt: number,
+): readonly Overdue[] {
+  const limit = QUARANTINE_DAYS * DAY_SECONDS;
+  return entries
+    .flatMap((entry) =>
+      headAt - entry.at > limit
+        ? [{ file: entry.file, day: entry.day, days: Math.floor((headAt - entry.at) / DAY_SECONDS) }]
+        : [],
+    )
+    .toSorted((a, b) => (a.file < b.file ? -1 : 1));
+}
+
+export function report({ checked, overdue }: ClockResult): string {
+  if (overdue.length === 0) {
+    return `quarantine-clock: no test in ${QUARANTINE} is past ${QUARANTINE_DAYS} days (${checked} checked)`;
+  }
+  const verb = overdue.length === 1 ? "is" : "are";
+  return [
+    `quarantine-clock: ${overdue.length} test(s) in ${QUARANTINE} ${verb} past ${QUARANTINE_DAYS} days; fix each and move it back, or delete it:`,
+    ...overdue.map((file) => `  ${file.file} entered quarantine on ${file.day} (${file.days} days ago)`),
+  ].join("\n");
+}
+
+const filesAt = Effect.fn("filesAt")(function* (root: string, head: string) {
+  const listed = yield* git(["ls-tree", "-r", "-z", "--name-only", head, "--", QUARANTINE], root);
+  return listed.split("\0").filter((file) => TEST_FILE.test(file));
+});
+
+const entryAt = Effect.fn("entryAt")(function* (root: string, head: string, file: string) {
+  const output = yield* git(["log", "--follow", "--root", "--name-status", "-z", "--format=commit %H %at %aI", head, "--", file], root);
+  const entry = findEntry(output, file);
+  if (entry.kind === "truncated" || (yield* isShallowBoundary(entry.sha, root))) {
+    return yield* new QuarantineError({
+      message: `cannot see ${file} entering ${QUARANTINE}; fetch the whole history, since a shallow clone ends before it`,
+    });
+  }
+  return { file, at: entry.at, day: entry.day };
+});
+
+const headAt = Effect.fn("headAt")(function* (root: string, head: string) {
+  const shown = yield* git(["show", "-s", "--format=%at %ct", head], root);
+  const dates = shown.trim().split(" ").map(Number);
+  if (dates.length !== 2 || !dates.every(Number.isInteger)) {
+    return yield* new QuarantineError({ message: `cannot read when ${head} was written` });
+  }
+  return Math.max(...dates);
+});
+
+export const runHead = Effect.fn("runHead")(function* (root: string, head: string) {
+  const files = yield* filesAt(root, head);
+  const entries = yield* Effect.forEach(files, (file) => entryAt(root, head, file));
+  return { checked: files.length, overdue: overdueOf(entries, yield* headAt(root, head)) } satisfies ClockResult;
+});
+
+const clock = Effect.gen(function* () {
+  const { first, second } = yield* refArgs(process.argv.slice(2), USAGE);
+  if (second !== undefined) yield* commitOf(first);
+  const head = yield* commitOf(second ?? first);
+  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
+  const result = yield* runHead(root, head);
+  yield* Console.log(report(result));
+  return result.overdue.length === 0;
+});
+
+if (import.meta.main) runMain("quarantine-clock", clock);

package/scripts/repetition.ts

@@ -4,22 +4,22 @@ import { changedPaths, checkoutFiles, collect, git, pathsAt, rangeFromArgs } fro
 import { runMain } from "./main.ts";
 import { readQuality } from "./quality-file.ts";
 
-type Fragment = {
+export type Fragment = {
   readonly file: string;
   readonly start: number;
   readonly end: number;
 };
 
-type Clone = readonly [Fragment, Fragment];
+export type Clone = readonly [Fragment, Fragment];
 
-type Rise = {
+export type Rise = {
   readonly file: string;
   readonly before: number;
   readonly after: number;
   readonly clones: readonly Clone[];
 };
 
-type Held = {
+export type Held = {
   readonly measured: number;
   readonly rises: readonly Rise[];
   readonly advisory: ReadonlyMap<string, number>;
@@ -86,7 +86,7 @@ const scan = Effect.fn("scan")(
   Effect.scoped,
 );
 
-function clonesOf(file: string, clones: readonly Clone[]): readonly Clone[] {
+export function clonesOf(file: string, clones: readonly Clone[]): readonly Clone[] {
   return clones
     .flatMap(([first, second]): Clone[] => {
       if (first.file === file) return [[first, second]];
@@ -95,6 +95,36 @@ function clonesOf(file: string, clones: readonly Clone[]): readonly Clone[] {
     .toSorted(([a], [b]) => a.start - b.start);
 }
 
+// Decides which held file repeats more lines than the same path, or the path it was renamed
+// from, repeated at the base.
+export function risesOf(
+  held: readonly string[],
+  before: ReadonlyMap<string, number>,
+  after: ReadonlyMap<string, number>,
+  formerPath: ReadonlyMap<string, string>,
+  clones: readonly Clone[],
+): readonly Rise[] {
+  return held
+    .flatMap((file): Rise[] => {
+      const was = before.get(formerPath.get(file) ?? file) ?? 0;
+      const is = after.get(file) ?? 0;
+      return is > was ? [{ file, before: was, after: is, clones: clonesOf(file, clones) }] : [];
+    })
+    .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 {
+  const risen = new Set(rises.map((rise) => rise.file));
+  const advisory = [...after].filter(([file]) => !risen.has(file)).concat([...othersRepeated]);
+  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);
@@ -107,28 +137,19 @@ const runHold = Effect.fn("runHold")(function* (root: string, production: readon
   const before = repeatedLines(yield* scan(root, base, yield* pathsAt(base, pathspecs, root)));
   const clones = yield* scan(root, head, held);
   const after = repeatedLines(clones);
-  const rises = held.flatMap((file): Rise[] => {
-    const was = before.get(formerPath.get(file) ?? file) ?? 0;
-    const is = after.get(file) ?? 0;
-    return is > was ? [{ file, before: was, after: is, clones: clonesOf(file, clones) }] : [];
-  });
-  const risen = new Set(rises.map((rise) => rise.file));
-  const advisory = [...after].filter(([file]) => !risen.has(file)).concat([...repeatedLines(yield* scan(root, head, others))]);
-  return {
-    measured: held.length,
-    rises: rises.toSorted((a, b) => a.file.localeCompare(b.file)),
-    advisory: new Map(advisory.toSorted(([a], [b]) => a.localeCompare(b))),
-  } satisfies Held;
+  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;
 });
 
-function describe({ file, before, after, clones }: Rise): readonly string[] {
+export function describe({ file, before, after, clones }: Rise): readonly string[] {
   return [
     `  ${file}: ${after} repeated line(s), up from ${before}`,
     ...clones.map(([own, other]) => `    ${own.file}:${own.start}-${own.end} repeats ${other.file}:${other.start}-${other.end}`),
   ];
 }
 
-function report({ measured, rises, advisory }: Held): 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}`]

package/scripts/size-budget.ts

@@ -20,9 +20,9 @@ import {
   type SizeRule,
 } from "./size-rules.ts";
 
-type Held = { readonly path: string; readonly from: string };
+export type Held = { readonly path: string; readonly from: string };
 
-type Site = {
+export type Site = {
   readonly file: string;
   readonly line: number | undefined;
   readonly rule: SizeRule["rule"];
@@ -30,7 +30,7 @@ type Site = {
   readonly message: string;
 };
 
-type Growth = {
+export type Growth = {
   readonly file: string;
   readonly rule: SizeRule["rule"];
   readonly base: number;
@@ -38,7 +38,7 @@ type Growth = {
   readonly sites: readonly Site[];
 };
 
-type Verdict =
+export type Verdict =
   | { readonly applies: "all"; readonly held: number; readonly overruns: readonly Site[]; readonly advisory: readonly Site[] }
   | { readonly applies: "ratchet"; readonly held: number; readonly growths: readonly Growth[]; readonly advisory: readonly Site[] };
 
@@ -69,7 +69,17 @@ const Diagnostic = Schema.Struct({
 
 const decodeReport = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ diagnostics: Schema.Array(Diagnostic) })));
 
-function rulesOf(budget: Budget): Record<string, unknown> {
+type Rules = Readonly<Record<string, unknown>>;
+
+export type SizeConfig = {
+  readonly plugins: readonly string[];
+  readonly jsPlugins: readonly string[];
+  readonly categories: Readonly<Record<string, string>>;
+  readonly rules: Rules;
+  readonly overrides: readonly { readonly files: readonly string[]; readonly rules: Rules }[];
+};
+
+function rulesOf(budget: Budget): Rules {
   return Object.fromEntries(
     SIZE_RULES.map((entry) => {
       const max = budget[entry.key];
@@ -78,7 +88,7 @@ function rulesOf(budget: Budget): Record<string, unknown> {
   );
 }
 
-function sizeConfig({ production, tests }: Budgets, plugin: string): unknown {
+export function sizeConfig({ production, tests }: Budgets, plugin: string): SizeConfig {
   return {
     plugins: [],
     jsPlugins: [plugin],
@@ -88,7 +98,7 @@ function sizeConfig({ production, tests }: Budgets, plugin: string): unknown {
   };
 }
 
-function heldByChange(changes: readonly Change[]): readonly Held[] {
+export function heldByChange(changes: readonly Change[]): readonly Held[] {
   return changes.flatMap((change) => {
     if (change.kind === "written") return [{ path: change.path, from: change.path }];
     if (change.kind === "renamed" && change.edited) return [{ path: change.path, from: change.from }];
@@ -118,7 +128,9 @@ const materializeBase = Effect.fn("materializeBase")(function* (root: string, ba
   yield* git(["checkout-index", "--all", `--prefix=${tree}/`], root, { env });
 });
 
-const siteOf = (budgets: Budgets) =>
+export const siteOf = (
+  budgets: Budgets,
+): ((diagnostic: typeof Diagnostic.Type) => Effect.Effect<readonly Site[], OxlintUnreadable>) =>
   Effect.fn("siteOf")(function* ({ code, message, filename, labels }: typeof Diagnostic.Type) {
     const rule = SIZE_RULES.find((candidate) => code === diagnosticCode(candidate));
     if (rule === undefined) return [];
@@ -166,7 +178,8 @@ function total(sites: readonly Site[]): number {
   return sites.reduce((sum, { overrun }) => sum + overrun, 0);
 }
 
-function growthsOf(head: readonly Site[], base: readonly Site[]): readonly Growth[] {
+// Sums each rule per file separately, so a shrink in one rule or file never offsets a growth in another.
+export function growthsOf(head: readonly Site[], base: readonly Site[]): readonly Growth[] {
   const before = byFileAndRule(base);
   return [...byFileAndRule(head).entries()].flatMap(([group, sites]) => {
     const [first] = sites;
@@ -175,6 +188,24 @@ function growthsOf(head: readonly Site[], base: readonly Site[]): readonly Growt
   });
 }
 
+// Decides the verdict from sites oxlint already measured: which are held to the range or the
+// whole tree, and, under ratchet, which grew past what the base measured for the same file and rule.
+export function verdictOf(
+  applies: Applies,
+  held: number,
+  holds: ReadonlySet<string>,
+  sites: readonly Site[],
+  baseSites: readonly Site[],
+): Verdict {
+  const heldSites = sites.filter((site) => holds.has(site.file));
+  if (applies !== "ratchet") {
+    return { applies, held, overruns: heldSites, advisory: sites.filter((site) => !holds.has(site.file)) };
+  }
+  const growths = growthsOf(heldSites, baseSites);
+  const failing = new Set(growths.flatMap((growth) => growth.sites));
+  return { applies, held, growths, advisory: sites.filter((site) => !failing.has(site)) };
+}
+
 const heldFiles = Effect.fn("heldFiles")(function* (root: string, applies: Applies, pathspecs: readonly string[], base: string, head: string) {
   if (applies === "all") return (yield* pathsAt(head, pathspecs, root)).map((path): Held => ({ path, from: path }));
   return heldByChange(yield* changedPaths(base, head, pathspecs, root));
@@ -196,25 +227,20 @@ const runBudget = Effect.fn("runBudget")(
     if (held.length + others.length > 0) yield* materializeHead(root, head, [...holds, ...others], headTree);
     const plugin = path.join(import.meta.dir, "..", "dist", "index.js");
     const sites = yield* measure(headTree, budgets, plugin);
-    const heldSites = sites.filter((site) => holds.has(site.file));
-    if (applies !== "ratchet") {
-      return { applies, held: held.length, overruns: heldSites, advisory: sites.filter((site) => !holds.has(site.file)) } satisfies Verdict;
-    }
+    if (applies !== "ratchet") return verdictOf(applies, held.length, holds, sites, []);
 
     const baseTree = path.join(scratch, "base");
     if (held.length > 0) yield* materializeBase(root, base, held, baseTree);
-    const growths = growthsOf(heldSites, yield* measure(baseTree, budgets, plugin));
-    const failing = new Set(growths.flatMap((growth) => growth.sites));
-    return { applies, held: held.length, growths, advisory: sites.filter((site) => !failing.has(site)) } satisfies Verdict;
+    return verdictOf(applies, held.length, holds, sites, yield* measure(baseTree, budgets, plugin));
   },
   Effect.scoped,
 );
 
-function describe({ file, line, message }: Site, indent = "  "): string {
+export function describe({ file, line, message }: Site, indent = "  "): string {
   return `${indent}${file}${line === undefined ? "" : `:${line}`}: ${message}`;
 }
 
-function verdictLines(verdict: Verdict): readonly string[] {
+export function verdictLines(verdict: Verdict): readonly string[] {
   const scope = SCOPE[verdict.applies];
   if (verdict.applies === "ratchet") {
     if (verdict.growths.length === 0) return [`${NAME}: ${verdict.held} file(s), ${scope}, raise no overrun past the base`];
@@ -230,7 +256,7 @@ function verdictLines(verdict: Verdict): readonly string[] {
   return [`${NAME}: ${verdict.overruns.length} overrun(s) of the budget in ${scope}:`, ...verdict.overruns.map((site) => describe(site))];
 }
 
-function report(verdict: Verdict): string {
+export function report(verdict: Verdict): string {
   const { advisory } = verdict;
   const notice =
     advisory.length === 0
@@ -239,7 +265,7 @@ function report(verdict: Verdict): string {
   return [...verdictLines(verdict), ...notice].join("\n");
 }
 
-function passes(verdict: Verdict): boolean {
+export function passes(verdict: Verdict): boolean {
   return verdict.applies === "ratchet" ? verdict.growths.length === 0 : verdict.overruns.length === 0;
 }
 

package/scripts/suppressions-ratchet.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { Console, Effect, Schema } from "effect";
-import { git, parentOrEmptyTree, refArgs } from "./git.ts";
+import { git, commitOf, parentOrEmptyTree, refArgs } from "./git.ts";
 import { runMain } from "./main.ts";
 
 export const SUPPRESSIONS = "oxlint-suppressions.json";
@@ -87,10 +87,6 @@ export function report({ counted, lowered, rises }: Ratchet): string {
   ].join("\n");
 }
 
-const commitOf = Effect.fn("commitOf")(function* (rev: string) {
-  return (yield* git(["rev-parse", "--verify", `${rev}^{commit}`])).trim();
-});
-
 const mergeBase = Effect.fn("mergeBase")(function* (base: string, head: string) {
   const commit = yield* git(["merge-base", base, head]).pipe(
     Effect.mapError(() => new SuppressionsError({ message: `${base} and ${head} share no commit` })),

package/scripts/test-layout.ts

@@ -3,7 +3,8 @@ 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, TEST_ENTRY_POINT } from "./gates.ts";
+import { ENTRY_POINT, QUALITY_FILE, TEST_ENTRY_POINT } from "./gates.ts";
+import { readQuality } from "./quality-file.ts";
 
 export type Violation = {
   readonly file: string;
@@ -16,7 +17,7 @@ const E2E = "tests/e2e/";
 const HELPER_DIRS = ["tests/lib/", "tests/fixtures/"] as const;
 const DATA_DIR = "tests/fixtures/";
 
-const TEST_FILE = /(?:[.](?:test|spec)|_test)[.](tsx?)$/;
+export const TEST_FILE = /(?:[.](?:test|spec)|_test)[.](tsx?)$/;
 const TARGET_FILE = /^tests\/(?:[^/]+\/)*[^/]+[.]test[.]tsx?$/;
 const TYPESCRIPT = /[.]tsx?$/;
 
@@ -39,9 +40,14 @@ const BANNED_BUN_NAMES: readonly string[] = [
 ];
 const BANNED_GLOBAL_CALLS: readonly string[] = ["fetch"];
 
-const REQUIRED_TEST_TABLE: Record<string, unknown> = {
-  pathIgnorePatterns: ["**/tests/quarantine/**"],
-};
+const IGNORES_KEY = "pathIgnorePatterns";
+const QUARANTINE = "**/tests/quarantine/**";
+const VENDORED = "repos/**";
+const PRESET_IGNORES: readonly string[] = [QUARANTINE, VENDORED];
+
+function acceptedIgnores(vendors: boolean): readonly (readonly string[])[] {
+  return vendors ? [PRESET_IGNORES] : [PRESET_IGNORES, [QUARANTINE]];
+}
 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}`;
@@ -245,7 +251,7 @@ export function scriptViolations(manifest: unknown): readonly Violation[] {
   return violations;
 }
 
-export function bunfigViolations(consumer: unknown, preset: unknown): readonly Violation[] {
+export function bunfigViolations(consumer: unknown, preset: unknown, vendors: boolean): readonly Violation[] {
   const file = "bunfig.toml";
   const copy = "bun has no bunfig extends, so copy node_modules/@avi2dg/checks/bunfig.toml";
   if (consumer === undefined) {
@@ -255,18 +261,21 @@ export function bunfigViolations(consumer: unknown, preset: unknown): readonly V
   if (!isRecord(presetTest)) {
     return [{ file, line: undefined, message: "the shipped bunfig preset has no [test] table" }];
   }
-  const expected = { ...presetTest, ...REQUIRED_TEST_TABLE };
   const consumerTest = isRecord(consumer) ? consumer["test"] : undefined;
+  const found = (key: string): unknown => (isRecord(consumerTest) ? consumerTest[key] : undefined);
+  const drifted = (key: string, wanted: string, fix: string): Violation => ({
+    file,
+    line: undefined,
+    message: `[test].${key} must be ${wanted}, found ${JSON.stringify(found(key) ?? null)}; ${fix}`,
+  });
   const violations: Violation[] = [];
-  for (const [key, value] of Object.entries(expected)) {
-    const found = isRecord(consumerTest) ? consumerTest[key] : undefined;
-    if (!Bun.deepEquals(found, value)) {
-      violations.push({
-        file,
-        line: undefined,
-        message: `[test].${key} must be ${JSON.stringify(value)}, found ${JSON.stringify(found ?? null)}; ${copy}`,
-      });
-    }
+  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`));
   }
   return violations;
 }
@@ -321,7 +330,9 @@ export const run = Effect.fn("run")(function* (root: string, presetPath: string)
 
   const bunfig = path.join(root, "bunfig.toml");
   const consumerBunfig = (yield* fs.exists(bunfig)) ? yield* parsedToml(bunfig) : undefined;
-  violations.push(...bunfigViolations(consumerBunfig, yield* parsedToml(presetPath)));
+  const { quality } = yield* readQuality(root);
+  const vendors = (quality.sources?.libraries ?? []).length > 0;
+  violations.push(...bunfigViolations(consumerBunfig, yield* parsedToml(presetPath), vendors));
 
   return { files: files.length, violations };
 });