paperlint 2.1.0 → 3.1.0

package/src/paper-settings.test.ts

@@ -1,12 +1,12 @@
 /**
- * `<paper>/paperlint.json` — the per-paper settings file (it was `venue.json` before 2.1.0): parsed
- * strictly, the old name never read, the move planned from bytes, and `rules` turned into an ESLint
- * block for that paper alone.
+ * `<paper>/paperlint.json` — the per-paper settings file: parsed strictly, merged over the root
+ * `paperlint.json`'s defaults, and `rules` turned into an ESLint block for that paper alone.
  */
 import { describe, expect, it } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
+import type { AbsolutePath } from "./domain/paths.ts";
+import { findProjectRoot } from "../lib/paper-config.mjs";
 import {
-  migrationOf,
   paperRules,
   parsePaperSettings,
   readPaperSettings,
@@ -16,9 +16,8 @@ const PAPER = "/work/papers/p";
 const SHIPPED = new Set([
   "pdf/last-page-balance",
   "pdf/profile",
-  "paper/typography",
+  "paper/section-word",
 ]);
-const enc = (s: string) => new TextEncoder().encode(s);
 
 describe("parsePaperSettings", () => {
   it("reads extends, kind, pdf and rules; every absent field is null", () => {
@@ -58,10 +57,10 @@ describe("parsePaperSettings — optional keys", () => {
     [
       "an unknown key (a typo is not silent)",
       { venu: "aisec" },
-      /unknown key "venu".*extends, kind, pdf, rules/,
+      /unknown key "venu" — known keys: papersDir, structure, rules, extends, kind, pdf/,
     ],
     [
-      "the pre-2.1.0 comment key `_`",
+      "a comment key other than `$comment`",
       { extends: "paperlint:aisec", _: "note" },
       /unknown key "_"/,
     ],
@@ -76,10 +75,15 @@ describe("parsePaperSettings — optional keys", () => {
       /"extends" must be a non-empty string/,
     ],
     [
-      "rules that are not an object",
-      { rules: ["pdf/profile"] },
+      "rules that are neither an object nor a list of blocks",
+      { rules: "pdf/profile" },
       /"rules" must be an object/,
     ],
+    [
+      "🔴 papersDir — a project setting, refused in a paper's file",
+      { papersDir: "papers" },
+      /"papersDir" is a project setting — set it in the root paperlint\.json/,
+    ],
     ["not an object at all", ["aisec"], /must be a JSON object/],
   ])("refuses %s", (_, json, why) => {
     const r = parsePaperSettings(json);
@@ -104,21 +108,6 @@ describe("readPaperSettings", () => {
     expect(r.ok && r.value?.extends).toBe("paperlint:aisec");
   });
 
-  it("🔴 a venue.json alone is NOT read — it is named, with the command that moves it", () => {
-    const files = memoryFiles({ [`${PAPER}/venue.json`]: '{"venue":"aisec"}' });
-    const r = readPaperSettings(files, PAPER);
-    expect(r).toEqual({ ok: false, error: { kind: "legacy" } });
-  });
-
-  it("paperlint.json wins when both exist — the leftover is doctor's to report", () => {
-    const files = memoryFiles({
-      [`${PAPER}/venue.json`]: '{"venue":"realm"}',
-      [`${PAPER}/paperlint.json`]: '{"extends":"paperlint:aisec"}',
-    });
-    const r = readPaperSettings(files, PAPER);
-    expect(r.ok && r.value?.extends).toBe("paperlint:aisec");
-  });
-
   it("not JSON: broken, with the parser's reason", () => {
     const files = memoryFiles({
       [`${PAPER}/paperlint.json`]: "{ extends: aisec",
@@ -129,52 +118,92 @@ describe("readPaperSettings", () => {
   });
 });
 
-describe("migrationOf — what `paperlint init` does with a paper's files", () => {
-  const plan = (legacy: string | null, current: string | null) =>
-    migrationOf(
-      legacy === null ? null : enc(legacy),
-      current === null ? null : enc(current),
-    );
+describe("readPaperSettings — the root paperlint.json's defaults, the paper's file over them", () => {
+  const ROOT = "/work";
+  const withFiles = (f: Record<string, string>) =>
+    memoryFiles({ [`${ROOT}/package.json`]: "{}", ...f });
+  const read = (f: Record<string, string>) => {
+    const r = readPaperSettings(withFiles(f), PAPER);
+    if (!r.ok) throw new Error(r.error.why);
+    return r.value;
+  };
+
+  it("no file at either level: null", () => {
+    expect(read({})).toBeNull();
+  });
 
-  it.each([
-    ["no venue.json", null, null, "none"],
-    [
-      "no venue.json, paperlint.json present",
-      null,
-      '{"extends":"paperlint:a"}',
-      "none",
-    ],
-    ["venue.json only", '{"venue":"a"}', null, "move"],
-    [
-      "both, and paperlint.json already says the same (spacing differs)",
-      '{"venue":"a","kind":"short"}',
-      '{ "extends": "paperlint:a", "kind": "short" }\n',
-      "drop-legacy",
-    ],
-    [
-      "both, different",
-      '{"venue":"a"}',
-      '{"extends":"paperlint:b"}',
-      "conflict",
-    ],
-    ["venue.json that is not JSON", "{", null, "broken"],
-    ["venue.json that is not an object", "[]", null, "broken"],
-  ])("%s → %s", (_, legacy, current, want) => {
-    expect(plan(legacy, current).kind).toBe(want);
+  it("root only: its extends and kind are this paper's", () => {
+    expect(
+      read({
+        [`${ROOT}/paperlint.json`]:
+          '{"papersDir":"papers","extends":"paperlint:agenticdev","kind":"short"}',
+      }),
+    ).toEqual({
+      extends: "paperlint:agenticdev",
+      kind: "short",
+      pdf: null,
+      rules: null,
+    });
   });
 
-  it('the move rewrites "venue": "x" to "extends": "paperlint:x", and "_" to "$comment"', () => {
-    const r = plan(
-      '{"venue":"aisec","kind":"research","pdf":"b.pdf","_":"note"}',
-      null,
-    );
-    expect(r.kind === "move" && JSON.parse(r.text)).toEqual({
+  it("paper only: its own values", () => {
+    expect(
+      read({ [`${PAPER}/paperlint.json`]: '{"extends":"paperlint:aisec"}' }),
+    ).toEqual({
       extends: "paperlint:aisec",
+      kind: null,
+      pdf: null,
+      rules: null,
+    });
+  });
+
+  it("🔴 both: the paper's value wins, an absent one falls back to the root's, and `\"extends\": null` is absent", () => {
+    expect(
+      read({
+        [`${ROOT}/paperlint.json`]:
+          '{"extends":"paperlint:agenticdev","kind":"short","rules":{"pdf/profile":"off"}}',
+        [`${PAPER}/paperlint.json`]:
+          '{"extends":null,"kind":"research","rules":{"pdf/fonts":"off"}}',
+      }),
+    ).toEqual({
+      extends: "paperlint:agenticdev",
       kind: "research",
-      pdf: "b.pdf",
-      $comment: "note",
+      pdf: null,
+      // The root's rules are the project's blocks (cli.ts), not this paper's.
+      rules: { "pdf/fonts": "off" },
     });
   });
+
+  it("papersDir in a paper's file: broken, naming the root file as its place", () => {
+    const r = readPaperSettings(
+      withFiles({ [`${PAPER}/paperlint.json`]: '{"papersDir":"x"}' }),
+      PAPER,
+    );
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.error.why).toMatch(/project setting/);
+  });
+});
+
+describe("findProjectRoot — where the root paperlint.json is looked for", () => {
+  const ROOT = "/work";
+  const withFiles = (f: Record<string, string>) =>
+    memoryFiles({ [`${ROOT}/package.json`]: "{}", ...f });
+
+  it("🔴 from INSIDE a paper, the project root is not the paper: its paperlint.json sits beside paper.tex", () => {
+    const files = withFiles({
+      [`${PAPER}/paper.tex`]: "x",
+      [`${PAPER}/paperlint.json`]: '{"kind":"research"}',
+      [`${ROOT}/paperlint.json`]: '{"extends":"paperlint:aisec"}',
+    });
+    const isFile = (p: string) => files.isFile(p as AbsolutePath);
+    expect(findProjectRoot(PAPER, isFile)).toBe(ROOT);
+    // No root file anywhere: the package.json directory.
+    expect(findProjectRoot(PAPER, (p) => p === `${ROOT}/package.json`)).toBe(
+      ROOT,
+    );
+    // Neither: where the walk started.
+    expect(findProjectRoot(PAPER, () => false)).toBe(PAPER);
+  });
 });
 
 describe("paperRules — `rules` in paperlint.json", () => {

package/src/paper-settings.ts

@@ -1,27 +1,26 @@
 /**
- * `<paper>/paperlint.json` — ONE PAPER'S SETTINGS, parsed at the boundary.
+ * `<paper>/paperlint.json` — ONE PAPER'S SETTINGS, parsed at the boundary, merged over the root's.
  *
- * The middle of three levels, each named after the tool (lib/paper-config.mjs):
+ * One file name at two levels, one schema (lib/paper-config.mjs → SETTINGS_KEYS):
  *
- *   package.json → "paperlint"     the project
+ *   paperlint.json                 the project (optional): papersDir, rules, defaults
  *   <paper>/paperlint.json         this paper: { extends, kind, pdf, rules }
  *   a venue preset                 `paperlint:<name>` (shipped) or `./x.jsonc` (src/presets.ts)
  *
- * Every reader — the build, the facts writer, the venue rules, `paperlint lint` — goes through
- * `readPaperSettings`, so there is one answer to "what does this paper declare".
+ * The paper's `extends`, `kind` and `pdf` win over the root's; with no own value, the root's is
+ * the default. Every reader — the build, the facts writer, the venue rules, `paperlint lint` —
+ * goes through `readPaperSettings`, so there is one answer to "what does this paper declare".
  *
  * 🔴 STRICT. An unknown key is an error naming the known ones: `"venu": "aisec"` would otherwise
- * read as "no preset", and every venue check would be silently off.
- *
- * 🔴 THE OLD NAME IS NOT READ. Before 2.1.0 the file was `venue.json`. A fallback would keep it
- * working forever and leave two names for one file; instead a `venue.json` with no `paperlint.json`
- * is an error that names `npx paperlint init`, which moves it (`migrationOf` plans that move).
+ * read as "no preset", and every venue check would be silently off. A project-only key
+ * (`papersDir`, …) in a paper's file is refused too: it would be read nowhere.
  */
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import {
-  LEGACY_PAPER_SETTINGS_FILE,
-  PAPER_SETTINGS_FILE,
-  PAPER_SETTINGS_KEYS,
+  CONFIG_FILE,
+  ROOT_ONLY_KEYS,
+  SETTINGS_KEYS,
+  findProjectRoot,
 } from "../lib/paper-config.mjs";
 import type { AbsolutePath } from "./domain/paths.ts";
 import { err, ok, type Result } from "./domain/result.ts";
@@ -40,16 +39,17 @@ export interface PaperSettings {
   readonly kind: string | null;
   /** The built PDF relative to the paper, when it is not `paper.pdf`. */
   readonly pdf: string | null;
-  /** Rule overrides for this paper alone, NOT yet checked against the shipped rules. */
-  readonly rules: Readonly<Record<string, unknown>> | null;
+  /**
+   * Rule overrides for this paper alone — `{ id: severity }` or ESLint blocks — NOT yet checked
+   * against the shipped rules.
+   */
+  readonly rules: Readonly<Record<string, unknown>> | readonly unknown[] | null;
 }
 
 /** Why a paper's settings cannot be read. */
-export type SettingsProblem =
-  | { readonly kind: "broken"; readonly why: string }
-  | { readonly kind: "legacy" };
+export type SettingsProblem = { readonly kind: "broken"; readonly why: string };
 
-const KNOWN = Object.keys(PAPER_SETTINGS_KEYS);
+const KNOWN = Object.keys(SETTINGS_KEYS);
 const STRING_FIELDS = ["extends", "kind", "pdf"] as const;
 
 const isObject = (v: unknown): v is Readonly<Record<string, unknown>> =>
@@ -68,8 +68,8 @@ function stringField(
     : err(`"${k}" must be a non-empty string, got ${JSON.stringify(v)}`);
 }
 
-/** `extends`, `kind` and `pdf`, each null when absent. */
-function stringFields(
+/** `extends`, `kind` and `pdf`, each null when absent. The root file's defaults parse the same way. */
+export function stringFields(
   d: Readonly<Record<string, unknown>>,
 ): Result<Pick<PaperSettings, (typeof STRING_FIELDS)[number]>, string> {
   const out: Record<string, string | null> = {};
@@ -93,11 +93,18 @@ export function parsePaperSettings(
   const unknown = Object.keys(json).filter((k) => !KNOWN.includes(k));
   if (unknown.length > 0)
     return err(`unknown key "${unknown[0]}" — known keys: ${KNOWN.join(", ")}`);
+  const project = Object.keys(json).filter((k) => ROOT_ONLY_KEYS.includes(k));
+  if (project.length > 0)
+    return err(
+      `"${project[0]}" is a project setting — set it in the root ${CONFIG_FILE}, not in a paper's`,
+    );
   const fields = stringFields(json);
   if (!fields.ok) return fields;
   const rules = json["rules"];
-  if (rules !== undefined && !isObject(rules))
-    return err(`"rules" must be an object of rule id → severity`);
+  if (rules !== undefined && !isObject(rules) && !Array.isArray(rules))
+    return err(
+      `"rules" must be an object of rule id → severity, or a list of ESLint blocks`,
+    );
   return ok({
     ...fields.value,
     rules: rules ?? null,
@@ -106,101 +113,96 @@ export function parsePaperSettings(
 
 const at = (p: string): AbsolutePath => p as AbsolutePath;
 
-/**
- * A paper's settings: null when it has no `paperlint.json`; the problem when the file does not parse
- * or only the pre-2.1.0 `venue.json` is there. Reads through `files` only; never throws.
- */
-export function readPaperSettings(
+/** A JSON file through `files`: undefined when absent, the problem when it does not parse. */
+function readJson(
   files: Files,
-  paperDir: string,
-): Result<PaperSettings | null, SettingsProblem> {
-  const bytes = files.readBytes(at(join(paperDir, PAPER_SETTINGS_FILE)));
-  if (bytes === null)
-    return files.readBytes(at(join(paperDir, LEGACY_PAPER_SETTINGS_FILE))) ===
-      null
-      ? ok(null)
-      : err({ kind: "legacy" });
-  let json: unknown;
+  path: string,
+): Result<unknown, SettingsProblem> {
+  const bytes = files.readBytes(at(path));
+  if (bytes === null) return ok(undefined);
   try {
-    json = JSON.parse(new TextDecoder().decode(bytes));
+    return ok(JSON.parse(new TextDecoder().decode(bytes)));
   } catch (e) {
     return err({ kind: "broken", why: `not JSON (${(e as Error).message})` });
   }
-  const parsed = parsePaperSettings(json);
-  return parsed.ok ? parsed : err({ kind: "broken", why: parsed.error });
 }
 
-// ── the move from venue.json ────────────────────────────────────────────────────────────
-
-/** What `paperlint init` does with one paper's files. */
-export type Migration =
-  /** No `venue.json`: nothing to do. */
-  | { readonly kind: "none" }
-  /** Only `venue.json`: write `text` as `paperlint.json`, delete `venue.json`. */
-  | { readonly kind: "move"; readonly text: string }
-  /** Both, and `paperlint.json` already says the same: the old one is a leftover, delete it. */
-  | { readonly kind: "drop-legacy" }
-  /** Both, and they differ: refuse — there is no way to know which one the author means. */
-  | { readonly kind: "conflict" }
-  /** `venue.json` is not a JSON object: refuse, naming why. */
-  | { readonly kind: "broken"; readonly why: string };
-
 /**
- * A `venue.json` object → the `paperlint.json` object that says the same, in one move:
- * `"venue": "aisec"` becomes `"extends": "paperlint:aisec"` (the only presets that existed were the
- * shipped ones), and the `"_"` some files used as a comment becomes `"$comment"`. Every other key
- * is carried as it is — an unknown one is then refused by name, as in any `paperlint.json`. Pure.
+ * The root file's defaults for every paper — `extends`, `kind`, `pdf` — found by walking up from
+ * the paper's parent. None when there is no root file, or it is not an object; a root file that
+ * is wrong in another way is reported by `paperlint lint`, which parses it strictly.
  */
-export function fromLegacy(
-  legacy: Readonly<Record<string, unknown>>,
-): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  for (const [k, v] of Object.entries(legacy)) {
-    if (k === "venue" && typeof v === "string")
-      out["extends"] = `paperlint:${v}`;
-    else if (k === "_") out["$comment"] = v;
-    else out[k] = v;
-  }
-  return out;
+function rootDefaults(
+  files: Files,
+  paperDir: string,
+): Result<Defaults | null, SettingsProblem> {
+  const root = findProjectRoot(dirname(paperDir), (p) => files.isFile(at(p)));
+  const json = readJson(files, join(root, CONFIG_FILE));
+  if (!json.ok) return json;
+  if (!isObject(json.value)) return ok(null);
+  const fields = stringFields(json.value);
+  return fields.ok
+    ? fields
+    : err({ kind: "broken", why: `the root ${CONFIG_FILE}: ${fields.error}` });
 }
 
-const jsonOf = (b: Uint8Array): unknown => {
-  try {
-    return JSON.parse(new TextDecoder().decode(b));
-  } catch {
-    return undefined;
-  }
-};
+/**
+ * A paper's settings, its own `paperlint.json` merged over the root's defaults: null when neither
+ * says anything; the problem when a file does not parse. Reads through `files` only; never throws.
+ */
+export function readPaperSettings(
+  files: Files,
+  paperDir: string,
+): Result<PaperSettings | null, SettingsProblem> {
+  const own = readJson(files, join(paperDir, CONFIG_FILE));
+  if (!own.ok) return own;
+  const parsed =
+    own.value === undefined ? ok(null) : parsePaperSettings(own.value);
+  if (!parsed.ok) return err({ kind: "broken", why: parsed.error });
+  const defaults = rootDefaults(files, paperDir);
+  if (!defaults.ok) return defaults;
+  return ok(merge(defaults.value, parsed.value));
+}
 
-/** The move, planned from the two files' bytes (null = absent). Pure. */
-export function migrationOf(
-  legacy: Uint8Array | null,
-  current: Uint8Array | null,
-): Migration {
-  if (legacy === null) return { kind: "none" };
-  const old = jsonOf(legacy);
-  if (!isObject(old)) return { kind: "broken", why: "it is not a JSON object" };
-  const next = fromLegacy(old);
-  if (current === null)
-    return { kind: "move", text: `${JSON.stringify(next, null, 2)}\n` };
-  return JSON.stringify(jsonOf(current)) === JSON.stringify(next)
-    ? { kind: "drop-legacy" }
-    : { kind: "conflict" };
+type Defaults = Pick<PaperSettings, "extends" | "kind" | "pdf">;
+const NO_DEFAULTS: Defaults = { extends: null, kind: null, pdf: null };
+
+/** The paper's own values win; each absent one falls back to the root's. */
+function merge(
+  root: Defaults | null,
+  paper: PaperSettings | null,
+): PaperSettings | null {
+  const r = root ?? NO_DEFAULTS;
+  const p = paper ?? { ...NO_DEFAULTS, rules: null };
+  const merged: PaperSettings = {
+    extends: p.extends ?? r.extends,
+    kind: p.kind ?? r.kind,
+    pdf: p.pdf ?? r.pdf,
+    rules: p.rules,
+  };
+  return paper === null && Object.values(merged).every((v) => v === null)
+    ? null
+    : merged;
 }
 
 // ── the paper's rule overrides ──────────────────────────────────────────────────────────
 
 /**
  * `rules` → the parsed entries (rule id → severity or `[severity, options]`), or the error naming
- * the file. Null when the paper sets none. The block they go into is built where the config is
- * (`paperRuleBlocks` in cli.ts), which also knows which files a paper's rules may reach.
+ * the file. Null when the paper sets none. Blocks (the list form) are parsed by the caller, which
+ * knows the file globs they are relative to (`paperRuleBlocks` in cli.ts).
  */
 export function paperRules(
   paperDir: string,
   settings: PaperSettings,
   shipped: ReadonlySet<string>,
 ): Parsed<Record<string, RuleEntry> | null> {
-  if (settings.rules === null) return { ok: true, value: null };
-  const where = `${join(paperDir, PAPER_SETTINGS_FILE)} → "rules"`;
-  return parseRuleEntries(settings.rules, where, shipped);
+  if (settings.rules === null || Array.isArray(settings.rules))
+    return { ok: true, value: null };
+  const where = `${join(paperDir, CONFIG_FILE)} → "rules"`;
+  return parseRuleEntries(
+    settings.rules as Readonly<Record<string, unknown>>,
+    where,
+    shipped,
+  );
 }

package/src/parse-args.test.ts

@@ -0,0 +1,48 @@
+/**
+ * `--flag=value` and unknown flags — the command line the CI action actually writes.
+ *
+ * action.yml runs `npx paperlint lint $PATHS --max-warnings="$MAXWARN" --json`. The parser knew
+ * only `--max-warnings <n>`, so `--max-warnings=-1` fell through to the list of PATHS: ESLint was
+ * handed a file named `--max-warnings=-1`, found nothing for it, and the run reported "nothing was
+ * linted under papers, --max-warnings=-1". Any flag the parser did not know became a path the same
+ * way, silently.
+ */
+import { describe, expect, it } from "vitest";
+import { parseArgs, run } from "./cli.ts";
+
+describe("parseArgs — `--flag=value` is the same as `--flag value`", () => {
+  it("🔴 the action's own command line: `--max-warnings=-1` is a threshold, not a path", () => {
+    const a = parseArgs(["lint", "papers", "--max-warnings=-1", "--json"]);
+    // Guards: the defect — the flag landed in `paths`.
+    expect(a.paths).toEqual(["papers"]);
+    expect(a.maxWarnings).toBe(-1);
+  });
+
+  it.each([
+    ["--config=o.json", "config", "o.json"],
+    ["--venue=agenticdev", "venue", "agenticdev"],
+    ["--kind=short", "kind", "short"],
+    ["--format=md", "format", "md"],
+    ["--paper=p", "paper", "p"],
+  ] as const)("%s", (flag, key, value) => {
+    const a = parseArgs(["new", "x", flag]);
+    expect(a[key]).toBe(value);
+    expect(a.paths).toEqual(["x"]);
+  });
+
+  it("an empty value after `=` is a missing value, refused like `--config` with none", () => {
+    expect(parseArgs(["lint", "--config="]).missingValue).toBe("--config");
+  });
+});
+
+describe("an unknown flag is refused, not read as a path", () => {
+  it("exits 2 and names the flag", async () => {
+    const err: string[] = [];
+    const code = await run(["lint", "--frobnicate"], {
+      log: () => {},
+      err: (s: string) => err.push(s),
+    });
+    expect(code).toBe(2);
+    expect(err.join("\n")).toMatch(/unknown flag `--frobnicate`/);
+  });
+});

package/src/ports/check-references.ts

@@ -0,0 +1,28 @@
+/**
+ * Checking a paper's references online — shaped by what the build records, not by what DBLP or
+ * Crossref answer. The adapter (`adapters/references/`) runs the package's two checkers; a test
+ * passes a function.
+ */
+
+/** What one bibliography entry came to. */
+export interface EntryVerdict {
+  readonly key: string;
+  /**
+   * Does the cited work exist, and does its title match? `false` only on a positive disproof (an
+   * identifier that resolves to nothing or to another work); a work that simply was not found is
+   * `unresolvable`, never `false`.
+   */
+  readonly exists: "true" | "false" | "unresolvable";
+  /** Are the authors those of the version cited (not the preprint's)? */
+  readonly authors: "match" | "mismatch" | "skipped" | "unchecked";
+  /** Why, in one line, when either is not a plain pass. */
+  readonly why?: string;
+}
+
+export type ReferencesCheck =
+  | { readonly kind: "checked"; readonly entries: readonly EntryVerdict[] }
+  /** Nothing could be asked — no network, every service down. Never a pass. */
+  | { readonly kind: "not-checked"; readonly why: string };
+
+/** The bibliography's text (BibTeX) → the verdicts. Never throws: a failure is `not-checked`. */
+export type CheckReferences = (bib: string) => Promise<ReferencesCheck>;

package/src/presets.ts

@@ -47,11 +47,7 @@ import {
   type PaperSettings,
   type SettingsProblem,
 } from "./paper-settings.ts";
-import {
-  LEGACY_PAPER_SETTINGS_FILE,
-  LEGACY_PAPER_SETTINGS_MESSAGE,
-  PAPER_SETTINGS_FILE,
-} from "../lib/paper-config.mjs";
+import { CONFIG_FILE } from "../lib/paper-config.mjs";
 
 /** The prefix of a shipped preset's spec. */
 export const SHIPPED_PREFIX = "paperlint:";
@@ -268,7 +264,7 @@ export type PaperPreset =
       readonly settings: PaperSettings;
       readonly preset: Preset;
     }
-  /** `paperlint.json` does not parse, or only a pre-2.1.0 `venue.json` is there. */
+  /** `paperlint.json` does not parse. */
   | { readonly kind: "settings-problem"; readonly problem: SettingsProblem }
   /** `extends` does not resolve. */
   | {
@@ -283,11 +279,7 @@ export function paperPreset(paperDir: string, deps: PresetDeps): PaperPreset {
   if (!read.ok) return { kind: "settings-problem", problem: read.error };
   const settings = read.value;
   if (settings?.extends == null) return { kind: "none", settings };
-  const r = resolvePreset(
-    settings.extends,
-    join(paperDir, PAPER_SETTINGS_FILE),
-    deps,
-  );
+  const r = resolvePreset(settings.extends, join(paperDir, CONFIG_FILE), deps);
   return r.ok
     ? { kind: "resolved", settings, preset: r.value }
     : { kind: "preset-problem", settings, problem: r.error };
@@ -299,9 +291,7 @@ export function paperPresetProblem(
   p: PaperPreset,
 ): string | null {
   if (p.kind === "preset-problem")
-    return `${join(paperDir, PAPER_SETTINGS_FILE)}: ${presetProblemText(p.problem)}`;
+    return `${join(paperDir, CONFIG_FILE)}: ${presetProblemText(p.problem)}`;
   if (p.kind !== "settings-problem") return null;
-  return p.problem.kind === "legacy"
-    ? `${join(paperDir, LEGACY_PAPER_SETTINGS_FILE)}: ${LEGACY_PAPER_SETTINGS_MESSAGE}`
-    : `${join(paperDir, PAPER_SETTINGS_FILE)}: ${p.problem.why}`;
+  return `${join(paperDir, CONFIG_FILE)}: ${p.problem.why}`;
 }