paperlint 6.2.3 → 7.0.0

package/src/new-paper.ts

@@ -27,6 +27,11 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { CONFIG_FILE } from "#lib/paper-config";
 import { isRecord } from "./domain/record.ts";
+import {
+  venuesNamedBy,
+  withoutVenues,
+  type NamedVenue,
+} from "./domain/venue-name.ts";
 
 export type PaperFormat = "tex" | "md";
 export const FORMATS: readonly PaperFormat[] = ["tex", "md"];
@@ -50,6 +55,9 @@ export const SOURCE_FILE: Readonly<Record<PaperFormat, string>> = {
   md: "paper.md",
 };
 
+/** The flag that lets `paperlint new` create a folder whose name names a venue. */
+export const ALLOW_VENUE_NAME = "--allow-venue-name";
+
 export const isFormat = (v: unknown): v is PaperFormat =>
   FORMATS.some((f) => f === v);
 
@@ -57,13 +65,30 @@ export const isFormat = (v: unknown): v is PaperFormat =>
  * Why a name is refused, or null. `[a-z0-9._-]+` is the charset; a LEADING dot is refused on top
  * of it, because discovery skips dot-directories — a paper named `.x` would be created and then
  * never linted, which is worse than a refusal.
+ *
+ * A name that names a venue — one of `venues`' names as whole words (`aisec-2026`) — is refused
+ * too, the paper's own venue included: a paper that is rejected goes to another venue and keeps its
+ * folder, so the name goes stale, and nothing at creation time knows the paper will not move. A
+ * folder made by hand, and one made with `--allow-venue-name` (a whole word can be the work's own:
+ * a paper about realms), is what `paper/folder-venue-leftover` judges once the venue changes. The
+ * flag passes no `venues`, so it skips this refusal and no other.
  */
-export function nameProblem(name: string): string | null {
+export function nameProblem(
+  name: string,
+  venues: readonly NamedVenue[],
+): string | null {
   if (!/^[a-z0-9._-]+$/.test(name))
     return `\`${name}\` — a paper name may hold only a-z, 0-9, dot, underscore and hyphen (it becomes a path and a shell argument)`;
   if (name.startsWith("."))
     return `\`${name}\` — a name starting with a dot is skipped by paper discovery, so it would never be linted`;
-  return null;
+  const named = venuesNamedBy(name, venues);
+  if (named.length === 0) return null;
+  const which = named.map((n) => `"${n.name}"`).join(", ");
+  const instead = withoutVenues(name, venues);
+  return [
+    `\`${name}\` — the paper folder names a venue (${which}); venues change on resubmission, so name it after the work${instead === null ? "" : ` (e.g. "${instead}")`}`,
+    `    if the venue really belongs in the name, rerun \`paperlint new\` with ${ALLOW_VENUE_NAME}`,
+  ].join("\n");
 }
 
 export interface FileOutcome {
@@ -180,17 +205,23 @@ function fromTemplate(
     : edited;
 }
 
+/** What `newPaper` is told besides the name: the venues a name may not name, and what to write. */
+export interface NewPaperOptions {
+  readonly packageTemplates?: string;
+  readonly venue?: VenueSetting | null;
+  /** Every venue paperlint knows (`shippedVenueNames`): a name naming one is refused. */
+  readonly venues: readonly NamedVenue[];
+}
+
 // Documented in README.md#getting-started — update it when this changes.
 export function newPaper(
   papersRoot: string,
   name: string,
   format: PaperFormat,
-  {
-    packageTemplates = PACKAGE_TEMPLATES,
-    venue = null,
-  }: { packageTemplates?: string; venue?: VenueSetting | null } = {},
+  opts: NewPaperOptions,
 ): NewPaperResult {
-  const problem = nameProblem(name);
+  const { packageTemplates = PACKAGE_TEMPLATES, venue = null } = opts;
+  const problem = nameProblem(name, opts.venues);
   if (problem) return { ok: false, reason: problem };
   const dir = join(papersRoot, name);
   const fresh = !existsSync(dir);

package/src/paper-settings-commands.test.ts

@@ -14,6 +14,7 @@ import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 import { run, toolchainTex } from "./cli.ts";
 import { lintReport } from "../test/lint-report.ts";
+import { venuePreset } from "../test/support.ts";
 
 const dirs: string[] = [];
 afterEach(() => {
@@ -203,7 +204,7 @@ describe("papersDir — optional, `papers` by default", () => {
 });
 
 describe("paperlint lint — the venue preset's rules", () => {
-  it("agenticdev's preset turns pdf/last-page-balance on for its paper alone", async () => {
+  it("agenticdev's preset turns pdf/last-page-balance and tex/heading-case on for its paper alone", async () => {
     const root = project({
       "papers/a/paperlint.json": JSON.stringify({
         extends: "paperlint:agenticdev",
@@ -219,7 +220,13 @@ describe("paperlint lint — the venue preset's rules", () => {
           // Scoped to the paper by `basePath` alone: which of its files the rule reaches is decided
           // once, by narrowing to paperlint's owned scopes (#101), not by a copy of their globs.
           basePath: join(root, "papers/a"),
-          rules: { "pdf/last-page-balance": ["error", { tolerancePt: 120 }] },
+          rules: {
+            "pdf/last-page-balance": ["error", { tolerancePt: 120 }],
+            "tex/heading-case": [
+              "error",
+              { title: "chicago-headline", headings: "chicago-headline" },
+            ],
+          },
         },
       ],
       own: [],
@@ -256,6 +263,10 @@ describe("paperlint lint — the paper over its preset, and the project's own pr
     // The preset's block comes first and the paper's own after it: the later block wins.
     expect(blocks.ok && blocks.value.preset[0]?.rules).toEqual({
       "pdf/last-page-balance": ["error", { tolerancePt: 120 }],
+      "tex/heading-case": [
+        "error",
+        { title: "chicago-headline", headings: "chicago-headline" },
+      ],
     });
     expect(blocks.ok && blocks.value.own[0]?.rules).toEqual({
       "pdf/last-page-balance": "off",
@@ -264,10 +275,12 @@ describe("paperlint lint — the paper over its preset, and the project's own pr
 
   it("a project's own preset, by relative path: its rules apply, an unknown rule id is refused", async () => {
     const root = project({
-      "venues/usenix-sec.jsonc": JSON.stringify({
-        extends: "paperlint:acm-sigconf",
-        rules: { "pdf/no-such-rule": "error" },
-      }),
+      "venues/usenix-sec.jsonc": JSON.stringify(
+        venuePreset("usenix-sec", {
+          extends: "paperlint:acm-sigconf",
+          rules: { "pdf/no-such-rule": "error" },
+        }),
+      ),
       "papers/a/paperlint.json": JSON.stringify({
         extends: "../../venues/usenix-sec.jsonc",
       }),
@@ -294,10 +307,12 @@ describe("paperlint lint — the paper over its preset, and the project's own pr
 describe("paperlint toolchain — installs what the project's own presets need", () => {
   it("the shipped union plus a relative preset's tex packages", () => {
     const root = project({
-      "venues/usenix-sec.jsonc": JSON.stringify({
-        extends: "paperlint:acm-sigconf",
-        tex: { packages: { usenix: ["usenix.sty"] } },
-      }),
+      "venues/usenix-sec.jsonc": JSON.stringify(
+        venuePreset("usenix-sec", {
+          extends: "paperlint:acm-sigconf",
+          tex: { packages: { usenix: ["usenix.sty"] } },
+        }),
+      ),
       "papers/a/paperlint.json": JSON.stringify({
         extends: "../../venues/usenix-sec.jsonc",
       }),

package/src/paper-settings.test.ts

@@ -32,6 +32,7 @@ describe("parsePaperSettings", () => {
         rules: null,
         identity: null,
         talk: null,
+        submission: null,
       },
     });
     expect(parsePaperSettings({})).toEqual({
@@ -43,6 +44,7 @@ describe("parsePaperSettings", () => {
         rules: null,
         identity: null,
         talk: null,
+        submission: null,
       },
     });
   });
@@ -57,6 +59,7 @@ describe("parsePaperSettings", () => {
         rules: null,
         identity: null,
         talk: null,
+        submission: null,
       },
     });
   });
@@ -155,7 +158,13 @@ describe("readPaperSettings — a root paperlint.json that cannot be used", () =
 });
 
 /** The fields a case does not set. */
-const UNSET = { pdf: null, rules: null, identity: null, talk: null };
+const UNSET = {
+  pdf: null,
+  rules: null,
+  identity: null,
+  talk: null,
+  submission: null,
+};
 
 describe("readPaperSettings — the root paperlint.json's defaults, the paper's file over them", () => {
   const ROOT = "/work";
@@ -210,6 +219,7 @@ describe("readPaperSettings — the root paperlint.json's defaults, the paper's
       rules: { "pdf/fonts": "off" },
       identity: null,
       talk: null,
+      submission: null,
     });
   });
 
@@ -253,6 +263,7 @@ describe("paperRules — `rules` in paperlint.json", () => {
     rules,
     identity: null,
     talk: null,
+    submission: null,
   });
 
   it("no rules: none", () => {

package/src/paper-settings.ts

@@ -4,7 +4,7 @@
  * One file name at two levels, one schema (lib/paper-config.mjs → SETTINGS_KEYS):
  *
  *   paperlint.json                 the project (optional): papersDir, rules, defaults
- *   <paper>/paperlint.json         this paper: { extends, kind, pdf, rules }
+ *   <paper>/paperlint.json         this paper: { extends, kind, pdf, rules, identity, talk, submission }
  *   a venue preset                 `paperlint:<name>` (shipped) or `./x.jsonc` (src/presets.ts)
  *
  * The paper's `extends`, `kind` and `pdf` win over the root's; with no own value, the root's is
@@ -32,6 +32,10 @@ import {
 } from "./rules-config.ts";
 import { messageOf } from "./domain/text.ts";
 import { parsePaperTalk, type PaperTalk } from "./domain/talk.ts";
+import {
+  parsePaperSubmission,
+  type PaperSubmission,
+} from "./domain/submission.ts";
 
 /** What one paper declares. Every absent field is null. */
 export interface PaperSettings {
@@ -54,6 +58,8 @@ export interface PaperSettings {
   readonly identity: readonly string[] | null;
   /** How this paper is presented (`talk/*`); null when it declares no talk. Never the root's. */
   readonly talk: PaperTalk | null;
+  /** Which submission on the venue's portal is this paper's; null when it says none. Never the root's. */
+  readonly submission: PaperSubmission | null;
 }
 
 /** Why a paper's settings cannot be read. */
@@ -112,17 +118,25 @@ export function identityField(
       );
 }
 
-/** `rules` (checked for shape only) and `talk`, each null when absent. */
+/** `rules` (checked for shape only), `talk` and `submission`, each null when absent. */
 function rulesAndTalk(
   json: Readonly<Record<string, unknown>>,
-): Result<Pick<PaperSettings, "rules" | "talk">, string> {
+): Result<Pick<PaperSettings, "rules" | "talk" | "submission">, string> {
   const rules = json["rules"];
   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`,
     );
   const talk = parsePaperTalk(json["talk"]);
-  return talk.ok ? ok({ rules: rules ?? null, talk: talk.value }) : talk;
+  if (!talk.ok) return talk;
+  const submission = parsePaperSubmission(json["submission"]);
+  return submission.ok
+    ? ok({
+        rules: rules ?? null,
+        talk: talk.value,
+        submission: submission.value,
+      })
+    : submission;
 }
 
 /** The parsed JSON of `paperlint.json` → the settings, or one line saying what is wrong. Pure. */
@@ -232,7 +246,12 @@ function merge(
   paper: PaperSettings | null,
 ): PaperSettings | null {
   const r = root ?? NO_DEFAULTS;
-  const p = paper ?? { ...NO_DEFAULTS, rules: null, talk: null };
+  const p = paper ?? {
+    ...NO_DEFAULTS,
+    rules: null,
+    talk: null,
+    submission: null,
+  };
   const merged: PaperSettings = {
     extends: p.extends ?? r.extends,
     kind: p.kind ?? r.kind,
@@ -240,6 +259,7 @@ function merge(
     rules: p.rules,
     identity: joined(r.identity, p.identity),
     talk: p.talk,
+    submission: p.submission,
   };
   return paper === null && Object.values(merged).every((v) => v === null)
     ? null

package/src/parse-args.test.ts

@@ -35,6 +35,25 @@ describe("parseArgs — `--flag=value` is the same as `--flag value`", () => {
   });
 });
 
+describe("parseArgs — the switches, each turning one field on", () => {
+  it.each([
+    ["--json", "json"],
+    ["--fix", "fix"],
+    ["--all", "all"],
+    ["--dry-run", "dryRun"],
+    ["--check", "check"],
+    ["--yes", "yes"],
+    ["-y", "yes"],
+    ["--no-hooks", "noHooks"],
+    ["--allow-venue-name", "allowVenueName"],
+  ] as const)("%s → %s", (flag, key) => {
+    const off = parseArgs(["new", "x"]);
+    const on = parseArgs(["new", "x", flag]);
+    expect(off[key]).toBe(false);
+    expect(on).toEqual({ ...off, [key]: true });
+  });
+});
+
 describe("an unknown flag is refused, not read as a path", () => {
   it("exits 2 and names the flag", async () => {
     const err: string[] = [];

package/src/ports/latex.ts

@@ -12,6 +12,7 @@ import type {
   Passage,
   Span,
   TextRun,
+  TitledHeading,
 } from "../domain/tex-document.ts";
 
 export interface LatexReader {
@@ -19,6 +20,12 @@ export interface LatexReader {
   readonly documentClass: (src: string) => ClassLine;
   /** Its sections, where the back matter begins, and where the document ends. */
   readonly outline: (src: string) => Outline;
+  /**
+   * Its `\title` and the titles of its `\section`, `\subsection`, `\subsubsection`, `\paragraph`
+   * and `\subparagraph` (starred or not, and each optional short title), each as the text the case
+   * judge reads: in document order.
+   */
+  readonly headings: (src: string) => readonly TitledHeading[];
   /** The text a reader sees: prose, the author block, footnotes — not comments, keys, math, code. */
   readonly renderedRuns: (src: string) => readonly TextRun[];
   /**

package/src/ports/submission-portal.ts

@@ -0,0 +1,26 @@
+/**
+ * A conference portal holding a paper's submission — the port `paperlint submission` talks through.
+ * Shaped by what the command needs (read one submission, send one change), not by any portal's API;
+ * one adapter per portal kind (`src/adapters/hotcrp/`).
+ */
+import type { Result } from "../domain/result.ts";
+import type {
+  PortalFailure,
+  SubmissionChange,
+  SubmissionView,
+  UpdateOutcome,
+} from "../domain/submission.ts";
+
+export interface SubmissionPortal {
+  /** The submission as the portal holds it now. */
+  show(id: number): Promise<Result<SubmissionView, PortalFailure>>;
+  /**
+   * Send a change. Without `save` the portal only checks it (a dry run) and keeps nothing; an
+   * answer the portal gave — valid or not — is an outcome, not a failure.
+   */
+  update(
+    id: number,
+    change: SubmissionChange,
+    o: { readonly save: boolean },
+  ): Promise<Result<UpdateOutcome, PortalFailure>>;
+}

package/src/preset-card-rule.test.ts

@@ -0,0 +1,266 @@
+/**
+ * `preset/card-rules` through real ESLint, on a copy of the shipped presets and the rule pages: the
+ * section a card must hold, the findings for each way a card can be wrong, and what `--fix` writes.
+ */
+import {
+  cpSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { ESLint } from "eslint";
+import markdown from "@eslint/markdown";
+import { describe, expect, it } from "vitest";
+import { nodeFiles } from "./adapters/node/index.ts";
+import { eslintConfig } from "./cli.ts";
+import { presetsDir } from "./package-dirs.ts";
+import {
+  entryParts,
+  presetCardRules,
+  SECTION_END,
+  SECTION_START,
+} from "./preset-card-rule.ts";
+import { useTempDir } from "../test/support.ts";
+
+const REPO = join(presetsDir(), "..");
+const root = useTempDir("paperlint-card-rule-");
+cpSync(presetsDir(), join(root, "presets"), { recursive: true });
+cpSync(join(REPO, "docs", "rules"), join(root, "docs", "rules"), {
+  recursive: true,
+});
+cpSync(join(REPO, "docs", "rules.md"), join(root, "docs", "rules.md"));
+const P = join(root, "presets");
+
+const eslint = (fix = false) =>
+  new ESLint({
+    cwd: root,
+    fix,
+    overrideConfigFile: true,
+    // Through cli.ts's one adapter from paperlint's blocks to ESLint's type (`eslintConfig`).
+    overrideConfig: eslintConfig([
+      {
+        files: ["presets/*.md"],
+        plugins: {
+          markdown,
+          preset: {
+            rules: presetCardRules({
+              files: nodeFiles,
+              venuesDir: P,
+              docsRoot: root,
+            }),
+          },
+        },
+        language: "markdown/gfm",
+        rules: { "preset/card-rules": "error" },
+      },
+    ]),
+  });
+
+/** The findings for one card, as `messageId`-free text: rule id and message. */
+async function findings(card: string): Promise<string[]> {
+  const [r] = await eslint().lintFiles([join(P, card)]);
+  return (r?.messages ?? []).map((m) => `${String(m.ruleId)}: ${m.message}`);
+}
+
+/** The card after `eslint --fix`, written to disk as ESLint would. */
+async function fixed(card: string): Promise<string> {
+  const results = await eslint(true).lintFiles([join(P, card)]);
+  await ESLint.outputFixes(results);
+  return readFileSync(join(P, card), "utf8");
+}
+
+/** The generated section of a card's text, markers included. */
+const sectionOf = (text: string): string =>
+  text.slice(
+    text.indexOf(SECTION_START),
+    text.indexOf(SECTION_END) + SECTION_END.length,
+  );
+
+const STALE =
+  "preset/card-rules: the rules section does not match the preset beside this card — run `npx eslint --fix` on this file to rewrite it from the preset";
+
+describe("the shipped cards", () => {
+  it("every shipped card holds the section its preset resolves to", async () => {
+    const results = await eslint().lintFiles([join(P, "*.md")]);
+    // Guards: a glob that matched nothing lints nothing and reports clean.
+    expect(results.map((r) => r.filePath.slice(P.length + 1)).sort()).toEqual([
+      "acm-sigconf.md",
+      "agenticdev.md",
+      "aidc.md",
+      "aisec.md",
+      "ieee-conference.md",
+      "realm.md",
+      "tex-base.md",
+    ]);
+    expect(results.flatMap((r) => r.messages)).toEqual([]);
+  });
+
+  it("agenticdev: its own rules, linked to their page or to the index, and what it extends", async () => {
+    const text = readFileSync(join(P, "agenticdev.md"), "utf8");
+    writeFileSync(
+      join(P, "agenticdev.md"),
+      text.replace(sectionOf(text), `${SECTION_START}\n${SECTION_END}`),
+    );
+    expect(await findings("agenticdev.md")).toEqual([STALE]);
+    // Guards: --fix writes the resolved preset — the section is the generated output, compared whole.
+    expect(sectionOf(await fixed("agenticdev.md"))).toBe(
+      [
+        SECTION_START,
+        "<!-- prettier-ignore-start -->",
+        "<!-- Generated from agenticdev.jsonc by `npx eslint --fix` (rule preset/card-rules). Edit the preset, not this section. -->",
+        "",
+        "**`paperlint:agenticdev`** — venue preset for AgenticDev · call for papers: <https://conf.researchr.org/home/ase-2026/agenticdev-2026> · extends `paperlint:acm-sigconf`",
+        "",
+        "| rule | severity | options | set in |",
+        "| --- | --- | --- | --- |",
+        '| [`pdf/last-page-balance`](../docs/rules.md) | error | `{"tolerancePt":120}` | this preset |',
+        '| [`tex/heading-case`](../docs/rules/tex/heading-case.md) | error | `{"title":"chicago-headline","headings":"chicago-headline"}` | this preset |',
+        "",
+        "<!-- prettier-ignore-end -->",
+        SECTION_END,
+      ].join("\n"),
+    );
+    expect(await findings("agenticdev.md")).toEqual([]);
+  });
+});
+
+describe("the origin column: set here, or inherited from the file of the chain that set it", () => {
+  it("a venue over agenticdev: its own rule is its own, agenticdev's are inherited", async () => {
+    writeFileSync(
+      join(P, "fixture-venue.jsonc"),
+      JSON.stringify({
+        type: "venue",
+        name: "Fixture",
+        url: "https://example.org/cfp",
+        extends: "paperlint:agenticdev",
+        rules: { "pdf/body-size": "off", "tex/register": ["warn", "a|b"] },
+      }),
+    );
+    writeFileSync(join(P, "fixture-venue.md"), "# Fixture\n");
+    expect(await findings("fixture-venue.md")).toEqual([
+      `preset/card-rules: this card has no generated rules section — run \`npx eslint --fix\` on this file to append one (between ${SECTION_START} and ${SECTION_END})`,
+    ]);
+    const text = await fixed("fixture-venue.md");
+    // Guards: an inherited rule names its parent, an own rule says so; an entry without options
+    // shows a dash, and a `|` in the options is escaped so the table keeps its columns.
+    expect(text.split("\n").filter((l) => l.startsWith("| ["))).toEqual([
+      "| [`pdf/body-size`](../docs/rules/pdf/body-size.md) | off | — | this preset |",
+      '| [`pdf/last-page-balance`](../docs/rules.md) | error | `{"tolerancePt":120}` | inherited from `paperlint:agenticdev` |',
+      '| [`tex/heading-case`](../docs/rules/tex/heading-case.md) | error | `{"title":"chicago-headline","headings":"chicago-headline"}` | inherited from `paperlint:agenticdev` |',
+      '| [`tex/register`](../docs/rules/tex/register.md) | warn | `"a\\|b"` | this preset |',
+    ]);
+    // Appended after one blank line to a card that ended with a newline.
+    expect(text.startsWith(`# Fixture\n\n${SECTION_START}\n`)).toBe(true);
+    expect(await findings("fixture-venue.md")).toEqual([]);
+  });
+
+  it("a card without a final newline gets one before the appended section", async () => {
+    writeFileSync(join(P, "fixture-venue.md"), "# Fixture");
+    expect(
+      (await fixed("fixture-venue.md")).startsWith(
+        `# Fixture\n\n${SECTION_START}\n`,
+      ),
+    ).toBe(true);
+  });
+});
+
+describe("a chain that leaves presets/", () => {
+  it("a rule set by a preset outside presets/ names that file by its path from the card", async () => {
+    mkdirSync(join(root, "shared"), { recursive: true });
+    writeFileSync(
+      join(root, "shared", "fixture-base.jsonc"),
+      JSON.stringify({
+        type: "family",
+        extends: "paperlint:acm-sigconf",
+        rules: { "pdf/body-size": "warn" },
+      }),
+    );
+    writeFileSync(
+      join(P, "fixture-outside.jsonc"),
+      JSON.stringify({
+        type: "venue",
+        name: "Outside",
+        url: "https://example.org/cfp",
+        extends: "../shared/fixture-base.jsonc",
+      }),
+    );
+    writeFileSync(join(P, "fixture-outside.md"), "# Outside\n");
+    // Guards: a file of the chain that is not a shipped preset is not given a `paperlint:` name
+    // that would resolve nowhere; it is the path a reader can open from the card.
+    expect(
+      (await fixed("fixture-outside.md"))
+        .split("\n")
+        .filter((l) => l.startsWith("| [")),
+    ).toEqual([
+      "| [`pdf/body-size`](../docs/rules/pdf/body-size.md) | warn | — | inherited from `../shared/fixture-base.jsonc` |",
+    ]);
+    rmSync(join(P, "fixture-outside.jsonc"));
+    rmSync(join(P, "fixture-outside.md"));
+  });
+});
+
+describe("a family the shipped presets do not extend", () => {
+  it("says so, and that its chain sets no rule", async () => {
+    writeFileSync(
+      join(P, "fixture-family.jsonc"),
+      JSON.stringify({ type: "family", extends: "paperlint:acm-sigconf" }),
+    );
+    writeFileSync(join(P, "fixture-family.md"), "# Family\n");
+    expect(
+      sectionOf(await fixed("fixture-family.md"))
+        .split("\n")
+        .slice(4, 7),
+    ).toEqual([
+      "**`paperlint:fixture-family`** — template family, no venue of its own · extends `paperlint:acm-sigconf` · extended by no shipped preset",
+      "",
+      "No preset of this chain sets a rule: under it, every rule keeps paperlint's default.",
+    ]);
+    rmSync(join(P, "fixture-family.jsonc"));
+    rmSync(join(P, "fixture-family.md"));
+  });
+});
+
+describe("a card that cannot be judged, or whose markers are not a pair", () => {
+  it("one marker without the other is reported, and not fixed", async () => {
+    for (const marker of [SECTION_START, SECTION_END]) {
+      writeFileSync(join(P, "fixture-venue.md"), `# Fixture\n\n${marker}\n`);
+      expect(await findings("fixture-venue.md")).toEqual([
+        `preset/card-rules: the generated rules section needs both markers, ${SECTION_START} and ${SECTION_END}, each on its own line`,
+      ]);
+      expect(await fixed("fixture-venue.md")).toBe(`# Fixture\n\n${marker}\n`);
+    }
+  });
+
+  it("a card with no preset beside it names the file it looked for", async () => {
+    writeFileSync(join(P, "orphan.md"), "# Orphan\n");
+    expect(await findings("orphan.md")).toEqual([
+      `preset/card-rules: a preset card describes the preset beside it, and there is none: ${join(P, "orphan.jsonc")}`,
+    ]);
+    rmSync(join(P, "orphan.md"));
+  });
+
+  it("a card beside a preset that does not resolve says why", async () => {
+    writeFileSync(
+      join(P, "broken.jsonc"),
+      JSON.stringify({ type: "family", extends: "x" }),
+    );
+    writeFileSync(join(P, "broken.md"), "# Broken\n");
+    expect(await findings("broken.md")).toEqual([
+      `preset/card-rules: the preset beside this card does not resolve, so its rules cannot be listed: "extends": "x" — a preset is \`paperlint:<name>\` (shipped) or a path starting with ./ or ../ (your own); npm presets: not yet supported. Did you mean "paperlint:x"?`,
+    ]);
+    rmSync(join(P, "broken.jsonc"));
+    rmSync(join(P, "broken.md"));
+  });
+});
+
+describe("entryParts", () => {
+  it.each<[unknown, { severity: string; options: string }]>([
+    ["error", { severity: "error", options: "" }],
+    [2, { severity: "2", options: "" }],
+    [["warn", { a: 1 }, "b"], { severity: "warn", options: '{"a":1}, "b"' }],
+  ])("%j", (entry, want) => {
+    expect(entryParts(entry)).toEqual(want);
+  });
+});