paperlint 3.1.3 → 4.0.0

package/src/venue-rules.test.ts

@@ -13,12 +13,9 @@ import { describe, expect, it } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
 import { sha256Hex } from "./domain/sha256.ts";
 import { packageVenuesDir } from "../skills/paper-pipeline/scripts/consumer.mjs";
-import {
-  VENUE_RULE_LEVELS,
-  venueRules,
-  type VenueRuleModule,
-} from "./venue-rules.ts";
+import { VENUE_RULE_LEVELS, venueRules } from "./venue-rules.ts";
 import { buildConfig, OPTIONAL_RULES, SHIPPED_RULES } from "./cli.ts";
+import { present } from "../test/support.ts";
 
 const VENUES = packageVenuesDir();
 const PAPER = "/work/papers/p";
@@ -34,9 +31,18 @@ const shipped = Object.fromEntries(
 );
 
 type Json = Record<string, unknown>;
+interface Font {
+  name: string;
+  type: string;
+  embedded: boolean;
+  program: string;
+}
+/** The facts file as these tests edit it: free-form, except the fonts they reach into. */
+type Facts = Json & { fonts: Font[] };
+type Patch = (f: Facts) => void;
 
 /** The facts of a short agenticdev paper that meets every number in its profile. */
-function goodFacts(): Json {
+function goodFacts(): Facts {
   return {
     schema: 2,
     pdf: "paper.pdf",
@@ -118,10 +124,7 @@ function lint(
   const files = memoryFiles(paperFiles(p));
   const rules = venueRules({ files, venuesDir: VENUES });
   const out: Finding[] = [];
-  for (const [name, rule] of Object.entries(rules) as [
-    string,
-    VenueRuleModule,
-  ][]) {
+  for (const [name, rule] of Object.entries(rules)) {
     const visitor = rule.create({
       filename,
       ...(cwd === undefined ? {} : { cwd }),
@@ -147,7 +150,13 @@ function lint(
 const DECL = { extends: "paperlint:agenticdev", kind: "short" };
 const ids = (fs: readonly Finding[]) =>
   fs.map((f) => `${f.rule}:${f.messageId}`).sort();
-const withFacts = (patch: (f: Json) => void): Json => {
+/** A patch that changes one field set of the `i`-th font. */
+const font =
+  (i: number, change: Partial<Font>): Patch =>
+  (f) => {
+    f.fonts = f.fonts.map((x, j) => (j === i ? { ...x, ...change } : x));
+  };
+const withFacts = (patch: Patch): Facts => {
   const f = goodFacts();
   patch(f);
   return f;
@@ -260,7 +269,7 @@ describe("pdf/profile — the kind", () => {
       // the fonts rule still runs with an unresolved kind
       const fonts = lint({
         venue,
-        facts: withFacts((f) => ((f.fonts as Json[])[0]!.embedded = false)),
+        facts: withFacts(font(0, { embedded: false })),
       });
       expect(ids(fonts)).toEqual([
         `pdf/fonts:notEmbedded`,
@@ -338,7 +347,7 @@ describe("pdf/measured — a paper that names a venue and was not measured says
         "pages_by_type",
       ])
         f[k] = null;
-      (f.fonts as Json[])[0]!.program = "Type3";
+      font(0, { program: "Type3" })(f);
     });
     expect(ids(lint({ venue: DECL, facts: g }))).toEqual([
       "pdf/fonts:type3",
@@ -348,7 +357,7 @@ describe("pdf/measured — a paper that names a venue and was not measured says
 });
 
 describe("pdf/fresh — facts about another build are not judged", () => {
-  it.each([
+  it.each<[string, Paper, string]>([
     [
       "a changed PDF",
       { pdf: new TextEncoder().encode("another build") },
@@ -364,55 +373,48 @@ describe("pdf/fresh — facts about another build are not judged", () => {
     ],
     [
       "a font entry of the wrong shape",
-      { facts: withFacts((f) => (f.fonts = [{ name: 3 }])) },
+      { facts: { ...goodFacts(), fonts: [{ name: 3 }] } },
       "factsBroken",
     ],
-  ] as [string, Paper, string][])(
-    "%s: one finding, from pdf/fresh only",
-    (_, p, messageId) => {
-      // Everything else planted wrong too — none of it may be reported over stale facts.
-      const facts =
-        p.facts ?? withFacts((f) => ((f.body_pages = 99), (f.columns = 1)));
-      expect(ids(lint({ venue: DECL, ...p, facts }))).toEqual([
-        `pdf/fresh:${messageId}`,
-      ]);
-    },
-  );
+  ])("%s: one finding, from pdf/fresh only", (_, p, messageId) => {
+    // Everything else planted wrong too — none of it may be reported over stale facts.
+    const facts =
+      p.facts ?? withFacts((f) => ((f.body_pages = 99), (f.columns = 1)));
+    expect(ids(lint({ venue: DECL, ...p, facts }))).toEqual([
+      `pdf/fresh:${messageId}`,
+    ]);
+  });
 });
 
 describe("pdf/fonts", () => {
-  it.each([
-    [
-      "a Type 3 font",
-      (f: Json) => ((f.fonts as Json[])[0]!.program = "Type3"),
-      ["pdf/fonts:type3"],
-    ],
+  it.each<[string, (f: Facts) => void, string[]]>([
+    ["a Type 3 font", font(0, { program: "Type3" }), ["pdf/fonts:type3"]],
     [
       "a font not embedded",
-      (f: Json) => ((f.fonts as Json[])[1]!.embedded = false),
+      font(1, { embedded: false }),
       ["pdf/fonts:notEmbedded"],
     ],
     [
       "the text family missing — acmart fell back to Computer Modern",
-      (f: Json) => ((f.fonts as Json[])[0]!.name = "CMR10"),
+      font(0, { name: "CMR10" }),
       ["pdf/fonts:noFamily"],
     ],
     [
       "both families missing: one finding per family",
-      (f: Json) =>
+      (f: Facts) =>
         (f.fonts = [
           { name: "CMR10", type: "Type 1", embedded: true, program: "Type1" },
         ]),
       ["pdf/fonts:noFamily", "pdf/fonts:noFamily"],
     ],
-  ] as [string, (f: Json) => void, string[]][])("%s", (_, patch, want) => {
+  ])("%s", (_, patch, want) => {
     expect(ids(lint({ venue: DECL, facts: withFacts(patch) }))).toEqual(want);
   });
 
   it("names the family and the fonts the PDF does have", () => {
     const [f] = lint({
       venue: DECL,
-      facts: withFacts((x) => ((x.fonts as Json[])[0]!.name = "CMR10")),
+      facts: withFacts(font(0, { name: "CMR10" })),
     });
     expect(f?.message).toMatch(/LinLibertine/);
     expect(f?.message).toMatch(/CMR10/);
@@ -420,28 +422,28 @@ describe("pdf/fonts", () => {
 });
 
 describe("pdf/geometry", () => {
-  it.each([
+  it.each<[string, (f: Facts) => void, string[]]>([
     [
       "A4 instead of letter",
-      (f: Json) => ((f.page_w_in = 8.27), (f.page_h_in = 11.69)),
+      (f: Facts) => ((f.page_w_in = 8.27), (f.page_h_in = 11.69)),
       ["pdf/geometry:dim", "pdf/geometry:dim"],
     ],
     [
       "one column instead of two",
-      (f: Json) => (f.columns = 1),
+      (f: Facts) => (f.columns = 1),
       ["pdf/geometry:columns"],
     ],
     [
       "a page size banal could not read",
-      (f: Json) => (f.page_w_in = null),
+      (f: Facts) => (f.page_w_in = null),
       ["pdf/geometry:dimMissing"],
     ],
     [
       "0.03 in off is inside the default tolerance",
-      (f: Json) => (f.page_w_in = 8.53),
+      (f: Facts) => (f.page_w_in = 8.53),
       [],
     ],
-  ] as [string, (f: Json) => void, string[]][])("%s", (_, patch, want) => {
+  ])("%s", (_, patch, want) => {
     expect(ids(lint({ venue: DECL, facts: withFacts(patch) }))).toEqual(want);
   });
 
@@ -455,46 +457,43 @@ describe("pdf/geometry", () => {
 });
 
 describe("pdf/limits", () => {
-  it.each([
+  it.each<[string, (f: Facts) => void, string[], RegExp | null]>([
     [
       "one body page over the short-paper limit",
-      (f: Json) => (f.body_pages = 6),
+      (f: Facts) => (f.body_pages = 6),
       ["pdf/limits:pages"],
       /body pages: 6, over the limit 5 for agenticdev\/short/,
     ],
     [
       "one reference page over",
-      (f: Json) => (f.ref_pages = 3),
+      (f: Facts) => (f.ref_pages = 3),
       ["pdf/limits:pages"],
       /reference pages: 3, over the limit 2/,
     ],
-    ["exactly at the limit", (f: Json) => (f.body_pages = 5), [], null],
+    ["exactly at the limit", (f: Facts) => (f.body_pages = 5), [], null],
     [
       "a reference font below the range",
-      (f: Json) => (f.ref_pt = 6),
+      (f: Facts) => (f.ref_pt = 6),
       ["pdf/limits:refPt"],
       /6 pt/,
     ],
     [
       "6.8 pt is inside the range once the measuring drift (body_pt_tol) is allowed",
-      (f: Json) => (f.ref_pt = 6.8),
+      (f: Facts) => (f.ref_pt = 6.8),
       [],
       null,
     ],
     [
       "no reference font measured (no bibliography) is not a finding",
-      (f: Json) => (f.ref_pt = null),
+      (f: Facts) => (f.ref_pt = null),
       [],
       null,
     ],
-  ] as [string, (f: Json) => void, string[], RegExp | null][])(
-    "%s",
-    (_, patch, want, text) => {
-      const fs = lint({ venue: DECL, facts: withFacts(patch) });
-      expect(ids(fs)).toEqual(want);
-      if (text) expect(fs[0]?.message).toMatch(text);
-    },
-  );
+  ])("%s", (_, patch, want, text) => {
+    const fs = lint({ venue: DECL, facts: withFacts(patch) });
+    expect(ids(fs)).toEqual(want);
+    if (text) expect(fs[0]?.message).toMatch(text);
+  });
 
   it("a longer kind of the same venue passes the same page count", () => {
     const facts = withFacts((f) => (f.body_pages = 9));
@@ -506,19 +505,19 @@ describe("pdf/limits", () => {
 });
 
 describe("pdf/body-size", () => {
-  it.each([
+  it.each<[string, (f: Facts) => void, string[]]>([
     [
       "10.2 pt against 9 ± 0.5",
-      (f: Json) => (f.body_pt = 10.2),
+      (f: Facts) => (f.body_pt = 10.2),
       ["pdf/body-size:body"],
     ],
-    ["9.4 pt is inside the tolerance", (f: Json) => (f.body_pt = 9.4), []],
+    ["9.4 pt is inside the tolerance", (f: Facts) => (f.body_pt = 9.4), []],
     [
       "no body size measured",
-      (f: Json) => (f.body_pt = null),
+      (f: Facts) => (f.body_pt = null),
       ["pdf/body-size:bodyMissing"],
     ],
-  ] as [string, (f: Json) => void, string[]][])("%s", (_, patch, want) => {
+  ])("%s", (_, patch, want) => {
     expect(ids(lint({ venue: DECL, facts: withFacts(patch) }))).toEqual(want);
   });
 });
@@ -531,12 +530,15 @@ describe("where a finding points", () => {
 });
 
 describe("paperlint's own config turns the venue rules on for every paper.tex", () => {
-  const texBlock = buildConfig({}, { sentinel: "tex language" }).find((b) =>
-    ((b as { files?: string[] }).files ?? []).includes("**/paper.tex"),
-  ) as { rules: Record<string, unknown> };
+  const texRules = present(
+    buildConfig({}, { sentinel: "tex language" }).find((b) =>
+      (b.files ?? []).includes("**/paper.tex"),
+    )?.rules,
+    "the paper.tex block's rules",
+  );
 
   it.each(Object.entries(VENUE_RULE_LEVELS))("%s is on at %s", (id, level) => {
-    expect(texBlock.rules[id]).toBe(level);
+    expect(texRules[id]).toBe(level);
     expect(SHIPPED_RULES.has(id)).toBe(true);
     expect(OPTIONAL_RULES.has(id)).toBe(false);
   });
@@ -567,7 +569,7 @@ describe("a project's own preset, and the facts' other spellings", () => {
       format: { columns: 2, body_pt: 9, ref_pt_min: 7, ref_pt_max: 8 },
     }),
   };
-  const house = (patch: (f: Json) => void = () => {}) =>
+  const house = (patch: (f: Facts) => void = () => {}) =>
     lint({
       venue: { extends: "./house.jsonc" },
       facts: withFacts(patch),

package/src/venue-rules.ts

@@ -45,10 +45,11 @@ import {
 import type { KindLimits, VenueFormat } from "./tex-requirements.ts";
 import { paperPreset, presetProblemText } from "./presets.ts";
 import type { FlatGeometry } from "./domain/geometry.ts";
-import type { AbsolutePath } from "./domain/paths.ts";
+import { callerPath } from "./caller-path.ts";
 import { sha256Hex } from "./domain/sha256.ts";
+import { fieldOf } from "./domain/record.ts";
 import type { Files } from "./ports/files.ts";
-import { CONFIG_FILE } from "../lib/paper-config.mjs";
+import { CONFIG_FILE } from "#lib/paper-config";
 
 // ── the verdict's vocabulary ─────────────────────────────────────────────────────────
 
@@ -92,9 +93,8 @@ export interface VenueRuleDeps {
   readonly venuesDir: string;
 }
 
-const at = (p: string): AbsolutePath => p as AbsolutePath;
 const text = (files: Files, p: string): string | null => {
-  const b = files.readBytes(at(p));
+  const b = files.readBytes(callerPath(p));
   return b === null ? null : new TextDecoder().decode(b);
 };
 
@@ -138,7 +138,7 @@ function freshFacts(
       : finding("factsBroken", { why: parsed.error.why });
   const f = parsed.value;
   const pdf = files.readBytes(
-    at(isAbsolute(f.pdf) ? f.pdf : join(paperDir, f.pdf)),
+    callerPath(isAbsolute(f.pdf) ? f.pdf : join(paperDir, f.pdf)),
   );
   if (pdf === null) return finding("pdfMissing", { pdf: f.pdf });
   return sha256Hex(pdf) === f.sha ? f : finding("stale", { pdf: f.pdf });
@@ -373,8 +373,7 @@ const JUDGES: Readonly<Record<VenueRuleName, Judge>> = {
           a.facts.geometry,
           a.venue.format,
           a.venue.venue,
-          (options[0] as { dimTol?: number } | undefined)?.dimTol ??
-            DEFAULT_DIM_TOL_IN,
+          dimTolOf(options[0]),
         )
       : [],
   limits: (a) =>
@@ -390,6 +389,12 @@ const JUDGES: Readonly<Record<VenueRuleName, Judge>> = {
 /** How far, in inches, a measured page dimension may be from the preset's. */
 export const DEFAULT_DIM_TOL_IN = 0.05;
 
+/** `geometry`'s `dimTol` option in inches, or the default when the rule was given none. */
+function dimTolOf(options: unknown): number {
+  const tol = fieldOf(options, "dimTol");
+  return typeof tol === "number" ? tol : DEFAULT_DIM_TOL_IN;
+}
+
 type Meta = Pick<VenueRuleModule["meta"], "docs" | "messages"> & {
   readonly type?: "suggestion";
   readonly schema?: readonly object[];
@@ -565,9 +570,14 @@ function rule(name: VenueRuleName, deps: VenueRuleDeps): VenueRuleModule {
 export function venueRules(
   deps: VenueRuleDeps,
 ): Record<VenueRuleName, VenueRuleModule> {
-  const names = Object.keys(META) as VenueRuleName[];
-  return Object.fromEntries(names.map((n) => [n, rule(n, deps)])) as Record<
-    VenueRuleName,
-    VenueRuleModule
-  >;
+  // Every name listed: a record missing one is a compile error.
+  return {
+    fresh: rule("fresh", deps),
+    profile: rule("profile", deps),
+    measured: rule("measured", deps),
+    fonts: rule("fonts", deps),
+    geometry: rule("geometry", deps),
+    limits: rule("limits", deps),
+    "body-size": rule("body-size", deps),
+  };
 }

package/tsconfig.json

@@ -11,13 +11,16 @@
     "sourceMap": true,
     "strict": true,
     "noUncheckedIndexedAccess": true,
-    "exactOptionalPropertyTypes": false,
+    "exactOptionalPropertyTypes": true,
     "skipLibCheck": true,
     "verbatimModuleSyntax": false,
     "types": ["node"],
     "allowImportingTsExtensions": true,
-    "rewriteRelativeImportExtensions": true
+    "rewriteRelativeImportExtensions": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
   },
   "include": ["src/**/*.ts"],
-  "exclude": ["src/**/*.test.ts"]
+  "exclude": ["src/**/*.test.ts", "src/**/*.harness.ts"]
 }

package/tsconfig.pkg.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "outDir": "dist",
+    "resolveJsonModule": true
+  },
+  "include": ["lib/*.ts", "eslint-rules/*.ts", "eslint-rules/*.json"],
+  "exclude": ["**/*.test.ts", "**/*.harness.ts", "**/*.d.ts"]
+}

package/lib/check.d.mts

@@ -1,17 +0,0 @@
-// Types for lib/check.mjs — the shared harness assertion helper (see the module).
-
-/** A failure detail: text, any value (rendered with `util.inspect`), or a thunk producing one. */
-export type Detail = unknown;
-
-export declare function renderDetail(detail: Detail): string;
-export declare function failureMessage(label: string, detail: Detail): string;
-
-export interface Check {
-  (label: string, cond: unknown, detail?: Detail): void;
-  /** How many times this checker has been called. */
-  readonly count: number;
-}
-
-export declare function createChecker(options?: {
-  log?: (line: string) => void;
-}): Check;

package/lib/paper-config.d.mts

@@ -1,31 +0,0 @@
-// Types for lib/paper-config.mjs, which `src/*.ts` imports. Without this file TypeScript sees
-// `any` and each import needs a `@ts-expect-error`, which covers only the next line and stops
-// working as soon as a formatter wraps the import across several lines.
-//
-// The field names are typed as `string`, not as their values, so that the value is written
-// once, in paper-config.mjs.
-
-/** The tool's name — its settings file is named after it. */
-export declare const CONFIG_KEY: string;
-/** `paperlint.json`: the settings file, at the project root and in each paper. */
-export declare const CONFIG_FILE: string;
-/** The files that make a directory a paper. */
-export declare const PAPER_MARKERS: readonly string[];
-
-/** The project root, walking up from `startDir` (see the module). */
-export declare function findProjectRoot(
-  startDir: string,
-  isFile?: (path: string) => boolean,
-): string;
-
-/** The root `paperlint.json` of `root` — undefined when absent, unparsable or not an object. */
-export declare function settingsOf(
-  root: string,
-): Readonly<Record<string, unknown>> | undefined;
-export declare const DEFAULT_PAPERS_ROOT: string;
-export declare const PAPERS_DIR_FIELD: string;
-
-/** Every key a `paperlint.json` may hold, at either level, mapped to who reads it. */
-export declare const SETTINGS_KEYS: Readonly<Record<string, string>>;
-/** The keys refused in a paper's `paperlint.json`. */
-export declare const ROOT_ONLY_KEYS: readonly string[];

package/scripts/layer-legacy-frozen.d.mts

@@ -1,36 +0,0 @@
-/** Types for `layer-legacy-frozen.mjs`, for its TypeScript test. */
-export interface Suppressed {
-  readonly filePath: string;
-  readonly suppressedMessages?: readonly {
-    readonly ruleId: string | null;
-    readonly line: number;
-    readonly suppressions?: readonly { readonly justification?: string }[];
-  }[];
-}
-export type Counts = Record<string, Record<string, number>>;
-export declare const FROZEN_FILE: string;
-export declare const LAYER_RULES: readonly string[];
-export declare const NO_LEGACY_UNDER: readonly string[];
-export declare const LEGACY: RegExp;
-export declare function tally(results: readonly Suppressed[]): {
-  counts: Counts;
-  unexplained: string[];
-};
-export declare function judge(o: {
-  counts: Counts;
-  unexplained: readonly string[];
-  frozen: Counts;
-}): string[];
-export declare function checkFrozen(
-  root?: string,
-  options?: { lint?: (cwd: string) => Promise<unknown[]> },
-): Promise<{
-  problems: string[];
-  frozen: Counts;
-  counts: Counts;
-}>;
-export declare function main(options?: {
-  check?: () => Promise<{ problems: string[]; frozen: Counts; counts: Counts }>;
-  log?: (line: string) => void;
-  err?: (line: string) => void;
-}): Promise<number>;

package/scripts/rules-are-content-only.harness.mjs

@@ -1,105 +0,0 @@
-/**
- * Colocated test for `scripts/rules-are-content-only.mjs` — a rule may not ask git.
- * Run: `npx vigiles test scripts/rules-are-content-only.harness.mjs`
- *
- * 🔴 BOTH HALVES. Like its sibling, this guard's success state is silence, so silence alone is
- * no evidence it works:
- *   I.   QUIET on this repository's real `eslint-rules/`, and the count is asserted non-zero —
- *        a guard that scanned nothing is also quiet, and that is the reading to rule out first.
- *   II.  FIRES on each form the defect takes: static `import`, `require()`, dynamic `import()`,
- *        and the `node:` prefix — the prefix matters because a set membership test that lists
- *        only the bare specifier passes a file that writes the modern spelling.
- *   III. QUIET on sources that merely TALK about the banned module — a comment and a string
- *        literal. This is the half a grep cannot have, and the reason the check parses.
- */
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createChecker } from "../lib/check.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const { rulesAreContentOnly, processImports } = await import(
-  join(HERE, "rules-are-content-only.mjs")
-);
-
-const check = createChecker();
-
-// ── I. quiet on the real corpus, and it actually looked ───────────────────────
-{
-  const { checked, findings } = rulesAreContentOnly({ cwd: join(HERE, "..") });
-  check(
-    `scanned something (${checked.length} rule sources)`,
-    checked.length > 0,
-  );
-  check(
-    `quiet on the real corpus (${findings.length} findings)`,
-    findings.length === 0,
-  );
-}
-
-// ── II. fires on every form the defect has taken ────────────────────────────
-for (const [label, src] of [
-  [
-    "execFileSync with a git argv",
-    `import { execFileSync } from "node:child_process";
-     execFileSync("git", ["cat-file", "-e", sha]);`,
-  ],
-  [
-    "a namespaced call",
-    `import cp from "node:child_process";
-     cp.spawnSync("git", ["rev-parse", ref]);`,
-  ],
-  [
-    "execSync with a git shell line",
-    `import { execSync } from "child_process";
-     execSync("git log --oneline -1");`,
-  ],
-  ["exec, async form", `exec("git rev-list --all", cb);`],
-]) {
-  check(`FIRES on ${label}`, processImports(src).length === 1);
-}
-
-// ── III. the FALSE POSITIVE that forced the narrowing, asserted so it cannot return ──
-// 🔴 `paper-texcount.mjs` in the consumer shells out to `texcount` to count words in a .tex.
-// The first version of this check keyed on importing `child_process` at all, so it claimed that
-// rule on its first run — a false positive on an `error` gate, which is worse than a miss
-// because the gate that cannot be cleared gets switched off rather than fixed.
-for (const [label, src] of [
-  [
-    "a rule spawning texcount",
-    `import { execFileSync } from "node:child_process";
-     execFileSync("texcount", ["-brief", file]);`,
-  ],
-  [
-    "a rule spawning pdflatex",
-    `import { spawnSync } from "node:child_process";
-     spawnSync("pdflatex", [tex]);`,
-  ],
-  [
-    "importing child_process without running git",
-    `import { execFileSync } from "node:child_process";
-     export default {};`,
-  ],
-]) {
-  check(`quiet on ${label}`, processImports(src).length === 0);
-}
-
-// ── IV. quiet on sources that only MENTION it — what a grep cannot do ───────
-for (const [label, src] of [
-  [
-    "a comment naming git",
-    `// never reach for git cat-file here\nexport default {};`,
-  ],
-  ["a string literal", `export const why = "git cat-file is banned in rules";`],
-  [
-    "a reported message",
-    `export default { meta: { messages: { m: "run git cat-file? no" } } };`,
-  ],
-  [
-    "a program merely NAMED git-something",
-    `execFileSync("git-lfs-helper", []);`,
-  ],
-]) {
-  check(`quiet on ${label}`, processImports(src).length === 0);
-}
-
-console.log(`rules-are-content-only.harness: ${check.count} assertions passed`);