paperlint 5.0.0 → 6.0.0

package/lib/paper-config.ts

@@ -136,8 +136,10 @@ export const SETTINGS_KEYS: Readonly<Record<string, string>> = Object.freeze({
     "rule overrides: { id: severity } for every paper in scope, or ESLint blocks (files, ignores, rules) — paperlint lint",
   extends:
     "the venue preset: paperlint:<name> or ./path.jsonc — the pdf/ venue rules, paperlint build",
-  kind: "the kind of paper, whose page limit applies — pdf/limits",
+  kind: "the kind of paper, whose page limit applies — format/page-limit",
   pdf: "where the built PDF is, relative to the paper, when it is not paper.pdf — the facts",
+  identity:
+    "what identifies the authors — names, handles, emails, affiliations, own project names; a blind venue's PDF must not say any of them — anonymity/identity. The root's list and a paper's are joined",
   scripts: "how skill prose names the scripts — consumer.mjs",
   timezone: "the zone deadline anchors are written in — consumer.mjs",
   contactEmail: "the polite-pool address for citation lookups — consumer.mjs",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paperlint",
-  "version": "5.0.0",
+  "version": "6.0.0",
   "description": "A linter for scientific papers written in LaTeX: catches mistakes before you submit to a conference or journal.",
   "type": "module",
   "license": "MIT",

package/presets/acm-sigconf.jsonc

@@ -74,7 +74,9 @@
     // «font size is 9 pt for all body text»
     "body_pt": 9,
     // banal measures the MODE of the rendered text, not the declared size (measured 08-26: 9.30 at
-    // acmart's declared 9). Hence the tolerance — and hence why body size stays a nudge, not a gate.
+    // acmart's declared 9). Hence the tolerance: banal reads 0.3 pt high on every template measured
+    // (fixtures/accepted-papers/body-size.json), and 0.5 absorbs that while a paper one size off is
+    // still reported.
     "body_pt_tol": 0.5,
 
     // «font size of the references can be from 7 pt to 9 pt»

package/presets/aidc.jsonc

@@ -22,6 +22,10 @@
 {
   "extends": "paperlint:ieee-conference",
 
+  // «Submissions must be properly anonymized for double-blind review.» (the call above), and
+  // `"blind":true` in the portal's data. anonymity/identity then requires the paper's `identity`.
+  "blind": true,
+
   // What the venue is called in a paper's text (tex/venue-leftover): the workshop, and the
   // conference it is held at.
   "aliases": ["AIDC", "ACSAC"],
@@ -44,30 +48,25 @@
     "textblock_w_in": 7.0,
     "textblock_h_in": 9.02,
 
-    // 🔴 PAGE LIMITS ARE NOT GATED HERE, AND THAT IS A MEASUREMENT. banal splits pages into body
-    // and references by what is on them, and a page that holds ANY non-bibliography text counts as
-    // body. Measured 2026-09-27 on a [conference,compsoc] paper whose body ends at the foot of
-    // page 12:
+    // 🔴 THE PAGE LIMIT IS COUNTED BEFORE THE REFERENCES, NOT BY banal. banal splits pages into
+    // body and references by what is on them, and a page that holds ANY non-bibliography text
+    // counts as body. Measured 2026-09-27 on a [conference,compsoc] paper whose body ends at the
+    // foot of page 12:
     //   LLM Usage Statement before the references → body 13, references 0
     //   an appendix before the references         → body 13, references 2
     //   both placed after the references          → body right, the tail counted as references
     // AIDC counts neither in the limit («excluding references and appendices»; the ACSAC AI policy:
-    // the LLM Usage Statement «does not count towards the page limit»), and tex/required-section
-    // accepts the statement before or after the bibliography. A gate on banal's body count would
-    // therefore fail a correct 12-page paper — the realm.jsonc case again. The numbers below are
-    // data for humans, not an input to pdf/limits.
-    "page_limits_not_gated": {
-      "_": "Body pages, excluding references, appendices and the LLM Usage Statement. banal counts a page holding an appendix or the statement before the bibliography as body, so its body count is not this number.",
-      "regular": 12,
-      "short": 6,
-      "references_and_appendices": "unlimited",
-      "llm_usage_statement": "not counted (ACSAC AI policy)",
-    },
+    // the LLM Usage Statement «does not count towards the page limit»). So format/page-limit counts
+    // the body up to where the references start (`body_ends_at`): the page they start on counts
+    // when body text stands above the heading there, and the limit below is gated. An appendix
+    // ends the body too, wherever it sits, when hyperref anchors it (docs/rules/format/page-limit.md).
+    "body_ends_at": "references",
 
     // «Short position papers or work-in-progress (WIP) papers» share one limit, so one kind.
+    // References, appendices and the LLM Usage Statement: unlimited.
     "kinds": {
-      "regular": {},
-      "short": {},
+      "regular": { "body_pages_max": 12 },
+      "short": { "body_pages_max": 6 },
     },
   },
 }

package/presets/ieee-conference.jsonc

@@ -59,6 +59,14 @@
     "body_pt": 10,
     "body_pt_tol": 0.5,
 
+    // The class sets the bibliography in \footnotesize, 8 pt at 10pt and at 9pt (IEEEtran.cls,
+    // \thebibliography). Measured 2026-09-29 on the four built ACSAC papers in
+    // fixtures/accepted-papers (body-size.json): pdf.js reads the reference glyphs at 8.00 pt
+    // (7.97 without compsoc), banal gives 8.3 on all four. body_pt_tol widens it to 7.5-8.5, so a
+    // bibliography shrunk to \scriptsize (7.3) or grown to \small (9.3) is reported.
+    "ref_pt_min": 8,
+    "ref_pt_max": 8,
+
     // The Times clone. Headings and the title are set in the same family, so a `fonts_title` would
     // repeat this check and report a Computer Modern build twice.
     "fonts_text": "NimbusRomNo9L",

package/presets/venue-profile.schema.json

@@ -24,6 +24,10 @@
       "type": "string",
       "minLength": 1
     },
+    "blind": {
+      "description": "The venue reviews double-blind: its call says submissions must be anonymized. Read by `anonymity/identity`, which then requires the paper's `identity` and finds none of it in the PDF. Set only where the venue says so, with the quote. A child's value replaces its parent's.",
+      "type": "boolean"
+    },
     "aliases": {
       "description": "Other names the venue goes by in a paper's text — its acronym, its parent conference (`[\"AISec\", \"ACM CCS\"]`). Read by `tex/venue-leftover`: a paper that extends another venue and says one of these is flagged. Matched as whole words, case-sensitive. Collected along the `extends` chain, with `name`.",
       "type": "array",
@@ -105,6 +109,11 @@
           "type": "string",
           "minLength": 1
         },
+        "body_ends_at": {
+          "description": "How `format/page-limit` counts body pages. Absent: banal's body count (every page holding non-bibliography text). `references`: the pages up to where the body ends — at the references or the appendix, whichever comes first, found by hyperref's anchors and then the heading line — with that page counted when body text stands above the heading on it; for a venue whose limit excludes references and appendices (and what follows them, such as statements).",
+          "type": "string",
+          "enum": ["references"]
+        },
         "page_limits_not_gated": {
           "type": "object"
         },

package/skills/render-paper/extract-pdf-facts.harness.ts

@@ -119,8 +119,8 @@ try {
   const fonts = Fonts.safeParse(facts.fonts);
   const fontList = fonts.success ? fonts.data : [];
   check(
-    "the facts are schema 2, about paper.pdf, for the venue paperlint.json declares",
-    facts.schema === 2 &&
+    "the facts are schema 3, about paper.pdf, for the venue paperlint.json declares",
+    facts.schema === 3 &&
       facts.pdf === "paper.pdf" &&
       facts.venue === "agenticdev" &&
       facts.kind === "short",
@@ -236,5 +236,5 @@ try {
 }
 
 console.log(
-  `✓ ${String(check.count)} assertions passed — extract-pdf-facts: the exit-code contract, schema 2, and the no-no-yes font`,
+  `✓ ${String(check.count)} assertions passed — extract-pdf-facts: the exit-code contract, schema 3, and the no-no-yes font`,
 );

package/src/adapters/latex/index.ts

@@ -31,6 +31,7 @@ import { outlineOf } from "./outline.ts";
 import { parseLatex } from "./parse.ts";
 import { bodyProse } from "./prose.ts";
 import { renderedRuns } from "./rendered.ts";
+import { layoutOverridesOf } from "./layout.ts";
 
 export {
   documentClassOf,
@@ -51,6 +52,7 @@ export { outlineOf } from "./outline.ts";
 export { parseLatex, type ParsedTex } from "./parse.ts";
 export { bodyProse } from "./prose.ts";
 export { renderedRuns } from "./rendered.ts";
+export { layoutOverridesOf } from "./layout.ts";
 
 /** The `LatexReader` port over unified-latex: each call parses its source once. */
 export const latexReader: LatexReader = {
@@ -62,4 +64,5 @@ export const latexReader: LatexReader = {
   documentBody: (src) => documentBodyOf(parseLatex(src)),
   template: parseTemplate,
   withDocumentClass: (src, want) => replaceDocumentClass(parseLatex(src), want),
+  layoutOverrides: (src) => layoutOverridesOf(parseLatex(src)),
 };

package/src/adapters/latex/layout.ts

@@ -0,0 +1,106 @@
+/**
+ * Where a source changes the page layout its class sets for the whole document — the input of
+ * `format/layout-override`. Read from the parse tree, never the text: a command in a comment is not
+ * a command.
+ *
+ * What counts, each by its node:
+ *
+ *   \usepackage{geometry} · \RequirePackage{…,geometry}   the package that re-sets the margins
+ *   \geometry{…} · \newgeometry{…}                        its commands
+ *   \setlength / \addtolength on a layout length          \textheight \textwidth \topmargin …
+ *   \linespread{…} · \renewcommand{\baselinestretch}      the line spacing
+ *
+ * Local spacing — a negative `\vspace` or `\vskip` around one float — is not a layout the template
+ * sets, and no venue's call names it; it is not read.
+ *
+ * A comment and a `comment` environment are not read — the parser hands both back as text, not
+ * macros. Everything else is — the bibliography, math, floats — and a macro definition too: a
+ * `\newcommand` whose body sets a layout length does so wherever it is used. Conditionals are not
+ * evaluated.
+ */
+import type { LayoutOverride } from "../../domain/tex-document.ts";
+import {
+  collapse,
+  isList,
+  macroPlace,
+  mandatory,
+  textOf,
+  visited,
+  type Macro,
+} from "./nodes.ts";
+import type { ParsedTex } from "./parse.ts";
+
+/** The lengths the class sets for the page and the line; changing one changes the venue's layout. */
+export const LAYOUT_LENGTHS: ReadonlySet<string> = new Set([
+  "textheight",
+  "textwidth",
+  "topmargin",
+  "oddsidemargin",
+  "evensidemargin",
+  "columnsep",
+  "headsep",
+  "headheight",
+  "footskip",
+  "baselineskip",
+]);
+
+/** The macro a mandatory argument holds first, or undefined: `{\textheight}` → `textheight`. */
+function firstMacro(m: Macro, i: number): string | undefined {
+  const first = mandatory(m)[i]?.content.find((n) => n.type !== "whitespace");
+  return first?.type === "macro" ? first.content : undefined;
+}
+
+const argText = (m: Macro, i: number): string =>
+  collapse(textOf(mandatory(m)[i]?.content));
+
+/** What names a macro that overrides the layout; null: this use of it does not. */
+type Namer = (m: Macro) => string | null;
+
+const usesGeometry: Namer = (m) =>
+  argText(m, 0)
+    .split(",")
+    .map((p) => p.trim())
+    .includes("geometry")
+    ? `\\${m.content}{geometry}`
+    : null;
+
+const setsLayoutLength: Namer = (m) => {
+  const length = firstMacro(m, 0);
+  return length !== undefined && LAYOUT_LENGTHS.has(length)
+    ? `\\${m.content}{\\${length}}`
+    : null;
+};
+
+/** Each macro that may override the layout, and how to tell whether this use of it does. */
+const OVERRIDES: ReadonlyMap<string, Namer> = new Map<string, Namer>([
+  ["usepackage", usesGeometry],
+  ["RequirePackage", usesGeometry],
+  ["geometry", (m) => `\\${m.content}`],
+  ["newgeometry", (m) => `\\${m.content}`],
+  ["linespread", (m) => `\\linespread{${argText(m, 0)}}`],
+  ["setlength", setsLayoutLength],
+  ["addtolength", setsLayoutLength],
+  [
+    "renewcommand",
+    (m) =>
+      firstMacro(m, 0) === "baselinestretch"
+        ? "\\renewcommand{\\baselinestretch}"
+        : null,
+  ],
+]);
+
+/** How a message names a macro that overrides the layout, or null when it does not. */
+const overrideOf: Namer = (m) => OVERRIDES.get(m.content)?.(m) ?? null;
+
+/** Every layout override in the source, in document order. */
+export function layoutOverridesOf(t: ParsedTex): readonly LayoutOverride[] {
+  // Nothing is pruned: a comment, and a `comment` environment, reach the tree as leaves of text.
+  const lists = visited(t.root, () => false).filter(isList);
+  return lists.flatMap((list) =>
+    list.flatMap((n) => {
+      if (n.type !== "macro") return [];
+      const command = overrideOf(n);
+      return command === null ? [] : [{ command, place: macroPlace(n) }];
+    }),
+  );
+}

package/src/adapters/latex/nodes.ts

@@ -63,9 +63,17 @@ const NONE: Shown = { kind: "none" };
  */
 const SHOWN_ARGUMENT: ReadonlyMap<string, Shown> = new Map<string, Shown>([
   ["texorpdfstring", { kind: "argument", at: 0 }],
-  ...["color", "fontsize", "vspace", "hspace", "setlength", "addtolength"].map(
-    (m) => [m, NONE] as const,
-  ),
+  ...[
+    "color",
+    "fontsize",
+    "vspace",
+    "hspace",
+    "setlength",
+    "addtolength",
+    "linespread",
+    "geometry",
+    "newgeometry",
+  ].map((m) => [m, NONE] as const),
 ]);
 
 /** The text a (non-key) macro typesets: see `SHOWN_ARGUMENT`. */

package/src/adapters/latex/parse.ts

@@ -82,7 +82,11 @@ const LINK_SIGNATURES = Object.fromEntries(signed(["href"], "m m"));
  * Declarations unified-latex has no signature for: signed so their arguments (sizes, not text)
  * attach to them instead of standing beside them as groups a reader would seem to see.
  */
-const DECLARATION_SIGNATURES = Object.fromEntries(signed(["fontsize"], "m m"));
+const DECLARATION_SIGNATURES = Object.fromEntries([
+  ...signed(["fontsize"], "m m"),
+  // The layout commands `format/layout-override` reads: a spacing factor, geometry's key list.
+  ...signed(["linespread", "geometry", "newgeometry"], "m"),
+]);
 
 /**
  * Macros that define other macros or environments. A heading in a body is no section where it is

package/src/build.harness.mjs

@@ -289,8 +289,8 @@ try {
   if (existsSync(factsFile)) {
     const f = JSON.parse(readFileSync(factsFile, "utf8"));
     check(
-      "measure: the facts are schema 2, about paper.pdf, with the last page's heights",
-      f.schema === 2 &&
+      "measure: the facts are schema 3, about paper.pdf, with the last page's heights",
+      f.schema === 3 &&
         f.pdf === "paper.pdf" &&
         JSON.stringify(f.last_page_cols_pt) === "[400,400]",
     );

package/src/build.test.ts

@@ -115,6 +115,11 @@ const reader =
         },
         last,
         layout: [],
+        pageTexts: [],
+        links: [],
+        bibAnchorPage: null,
+        appendixAnchorPage: null,
+        metadata: {},
       },
     });
 const quiet = () => {};

package/src/cli.test.ts

@@ -578,3 +578,16 @@ test("`paperlint hook` with no name: exit 2, and the usage names an example", as
     err: "`hook` needs a name, e.g. `paperlint hook paper-edit-guard`",
   });
 });
+
+test("parseSettings refuses a root `identity` that is not a list of words, and takes one that is", () => {
+  const bad = parseSettings({ identity: "Ada" }, "paperlint.json", "/r");
+  assert.deepEqual(bad, {
+    ok: false,
+    error:
+      'paperlint.json: "identity" must be a list of strings, each with a letter or digit, got "Ada"',
+  });
+  assert.equal(
+    parseSettings({ identity: ["Ada Example"] }, "paperlint.json", "/r").ok,
+    true,
+  );
+});

package/src/cli.ts

@@ -49,12 +49,25 @@ import { banalInstaller, parseBanalSettings } from "./adapters/banal/index.ts";
 import { curlDownload } from "./adapters/curl/index.ts";
 import { latexReader } from "./adapters/latex/index.ts";
 import { hostDirs, nodeAdapters, nodeFiles } from "./adapters/node/index.ts";
-import { VENUE_RULE_LEVELS, venueRules } from "./venue-rules.ts";
-import { TEX_VENUE_RULE_LEVELS, texVenueRules } from "./tex-venue-rules.ts";
+import {
+  ANONYMITY_RULE_LEVELS,
+  anonymityRules,
+  PAGE_LIMIT_RULE_LEVELS,
+  pageLimitRules,
+  VENUE_RULE_LEVELS,
+  venueRules,
+} from "./venue-rules.ts";
+import {
+  FORMAT_RULE_LEVELS,
+  formatRules,
+  TEX_VENUE_RULE_LEVELS,
+  texVenueRules,
+} from "./tex-venue-rules.ts";
 import { claimProvenanceRule } from "./claim-provenance.ts";
 import { registerRule } from "./register.ts";
 import {
   paperRules,
+  identityField,
   stringFields,
   type PaperSettings,
 } from "./paper-settings.ts";
@@ -218,8 +231,9 @@ settings — paperlint.json, at two levels, one schema. Both are optional.
   blocks (files, ignores, rules) with globs relative to that file. Order, later wins: paperlint's
   own, the venue preset's, the root file's, the paper's. Optional rules (off unless turned on):
   pdf/last-page-balance. The venue rules (pdf/fresh, pdf/profile, pdf/fonts, pdf/geometry,
-  pdf/limits, pdf/body-size, pdf/measured) are on for every paper with a venue preset; set one to
-  "off" to skip it. An unknown key, in either file, is an error.
+  pdf/body-size, pdf/measured, format/page-limit, format/layout-override, anonymity/identity) are
+  on for every paper with a venue preset; set one to "off" to skip it. An unknown key, in either
+  file, is an error.
 `;
 
 /** The config the user would otherwise write by hand. The data comes from `opts`, the mechanism is here. */
@@ -262,6 +276,9 @@ export function buildConfig(
             ...venueRules({ files: nodeFiles, venuesDir: presetsDir() }),
           },
         },
+        anonymity: {
+          rules: anonymityRules({ files: nodeFiles, venuesDir: presetsDir() }),
+        },
       },
     },
     {
@@ -325,6 +342,16 @@ export function buildConfig(
         },
         paper: { rules: texPaperRules },
         bib: bibReachable,
+        format: {
+          rules: {
+            ...formatRules({
+              files: nodeFiles,
+              venuesDir: presetsDir(),
+              latex: latexReader,
+            }),
+            ...pageLimitRules({ files: nodeFiles, venuesDir: presetsDir() }),
+          },
+        },
       },
       language: "tex/latex",
       rules: {
@@ -340,7 +367,10 @@ export function buildConfig(
         "tex/acm-frontmatter-override": "error",
         // Silent for a paper whose paperlint.json names no venue (src/venue-rules.ts).
         ...VENUE_RULE_LEVELS,
+        ...ANONYMITY_RULE_LEVELS,
         ...TEX_VENUE_RULE_LEVELS,
+        ...FORMAT_RULE_LEVELS,
+        ...PAGE_LIMIT_RULE_LEVELS,
       },
     });
   // THE FILES A paper.tex INCLUDES FROM ITS BODY, each read on its own and reported at its own path
@@ -667,6 +697,8 @@ export function parseSettings(
     };
   const defaults = stringFields(raw);
   if (!defaults.ok) return { ok: false, error: `${where}: ${defaults.error}` };
+  const identity = identityField(raw);
+  if (!identity.ok) return { ok: false, error: `${where}: ${identity.error}` };
   const structure = Structure.safeParse(raw["structure"]);
   if (!structure.success)
     return {

package/src/domain/anonymity.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it } from "vitest";
+import {
+  findLeaks,
+  spellingsOf,
+  tokenPattern,
+  type Searchable,
+} from "./anonymity.ts";
+
+const page = (text: string, n = 1): Searchable => ({
+  place: { kind: "page", page: n },
+  text,
+});
+const found = (token: string, text: string): string[] =>
+  findLeaks([token], [page(text)]).map((l) => l.found);
+
+describe("findLeaks — the spellings of one name a PDF produces", () => {
+  it("plain, and in any case (the flags fold Unicode, no locale)", () => {
+    expect(found("Ada Example", "by Ada Example, 2026")).toEqual([
+      "Ada Example",
+    ]);
+    expect(found("Ada Example", "ADA EXAMPLE")).toEqual(["ADA EXAMPLE"]);
+  });
+
+  it("Cyrillic folds too", () => {
+    expect(found("Ада Пример", "АДА ПРИМЕР пишет")).toEqual(["АДА ПРИМЕР"]);
+    expect(found("АДА", "ада")).toEqual(["ада"]);
+  });
+
+  it("items joined without a space where kerning split a word", () => {
+    expect(found("Ada Example", "AdaExample")).toEqual(["AdaExample"]);
+  });
+
+  it("letter-spaced text", () => {
+    expect(found("Ada Example", "A d a  E x a m p l e")).toEqual([
+      "A d a  E x a m p l e",
+    ]);
+  });
+
+  it("a word hyphenated across a line break, and a name broken across lines", () => {
+    expect(found("Ada Example", "Ada Exam-\nple wrote")).toEqual([
+      "Ada Exam-\nple",
+    ]);
+    expect(found("Ada Example", "by Ada\nExample")).toEqual(["Ada\nExample"]);
+    expect(found("adaexample", "ada­example")).toEqual(["ada­example"]);
+  });
+
+  it("ligatures (NFKC on both sides)", () => {
+    expect(found("Fiona", "fiona")).toEqual(["fiona"]);
+    expect(found("fiona", "Fiona")).toEqual(["Fiona"]);
+  });
+
+  it("handles and addresses, as whole tokens", () => {
+    expect(found("adaexample", "https://github.com/adaexample/tool")).toEqual([
+      "adaexample",
+    ]);
+    expect(found("ada@example.org", "mail ada@example.org.")).toEqual([
+      "ada@example.org",
+    ]);
+  });
+
+  it("does not match inside another word", () => {
+    expect(found("Ada", "Canada and adamant")).toEqual([]);
+    expect(found("MIT", "submitted")).toEqual([]);
+  });
+
+  it("says nothing about a clean text", () => {
+    expect(found("Ada Example", "Anonymous Authors")).toEqual([]);
+  });
+});
+
+describe("findLeaks — places and tokens", () => {
+  it("reports each token once per place, with the place", () => {
+    const leaks = findLeaks(
+      ["Ada Example", "ada@example.org"],
+      [
+        page("Ada Example and Ada Example", 2),
+        {
+          place: { kind: "metadata", field: "Author" },
+          text: "ada@example.org",
+        },
+        {
+          place: {
+            kind: "link",
+            page: 3,
+            uri: "https://github.com/adaexample",
+          },
+          text: "https://github.com/adaexample",
+        },
+      ],
+    );
+    expect(leaks).toEqual([
+      {
+        token: "Ada Example",
+        place: { kind: "page", page: 2 },
+        found: "Ada Example",
+      },
+      {
+        token: "ada@example.org",
+        place: { kind: "metadata", field: "Author" },
+        found: "ada@example.org",
+      },
+      {
+        token: "Ada Example",
+        place: { kind: "link", page: 3, uri: "https://github.com/adaexample" },
+        found: "adaexample",
+      },
+    ]);
+  });
+
+  it("a token of separators only has no pattern and finds nothing", () => {
+    expect(tokenPattern(" - ")).toBeNull();
+    expect(findLeaks([" "], [page("anything at all")])).toEqual([]);
+  });
+});
+
+describe("findLeaks — one text, two tokens", () => {
+  it("is one leak, under the first token declared", () => {
+    expect(
+      findLeaks(["Ada Example", "adaexample"], [page("by AdaExample")]),
+    ).toEqual([
+      {
+        token: "Ada Example",
+        place: { kind: "page", page: 1 },
+        found: "AdaExample",
+      },
+    ]);
+  });
+});
+
+describe("spellingsOf — a personal name as a reference list prints it", () => {
+  it("adds initials and surname-first forms to a name of two to four words", () => {
+    expect(spellingsOf("Ada Example")).toEqual([
+      "Ada Example",
+      "A. Example",
+      "Example, Ada",
+      "Example, A.",
+    ]);
+    expect(spellingsOf("Ada Byron Example")).toEqual([
+      "Ada Byron Example",
+      "A. B. Example",
+      "Example, Ada Byron",
+      "Example, A. B.",
+    ]);
+  });
+
+  it("leaves a handle, an address, one word, or lowercase words alone", () => {
+    expect(spellingsOf("adaexample")).toEqual(["adaexample"]);
+    expect(spellingsOf("ada@example.org")).toEqual(["ada@example.org"]);
+    expect(spellingsOf("Example")).toEqual(["Example"]);
+    expect(spellingsOf("example tool")).toEqual(["example tool"]);
+    expect(spellingsOf("A B C D E")).toEqual(["A B C D E"]);
+  });
+
+  it("a self-citation's author list finds the declared name", () => {
+    expect(
+      found("Ada Example", "[3] A. Example and B. Other, “A tool,” 2025."),
+    ).toEqual(["A. Example"]);
+    expect(found("Ada Example", "Example, A., and Other, B. (2025)")).toEqual([
+      "Example, A.",
+    ]);
+    expect(found("Ada Example", "B. Example wrote")).toEqual([]);
+  });
+});