paperlint 5.0.0 → 6.0.0

package/src/domain/anonymity.ts

@@ -0,0 +1,129 @@
+/**
+ * WHO WROTE THIS PAPER, FOUND IN THE PAPER — the matching `anonymity/identity` judges a blind submission
+ * by. A rule cannot know who the author is, so the author DECLARES it (`identity` in
+ * `paperlint.json`); given that list, finding it is mechanical, and this module is the mechanism.
+ *
+ * ── WHAT A MATCH TOLERATES, AND WHY EACH ─────────────────────────────────────────
+ * PDF text is not the source text. pdf.js hands back runs of glyphs, and the same name comes out
+ * in several spellings of the same letters:
+ *
+ *   ligatures        `fi` for `fi`                    → both sides NFKC-normalized
+ *   case             `ADA EXAMPLE` in small caps       → Unicode case folding (the `iu` flags: no
+ *                                                         locale is consulted, Cyrillic folds too)
+ *   kerning splits   `Ex` `ample` as two items         → the page text joins items without a space
+ *   letter-spacing   `A d a  E x a m p l e`            → whitespace may stand between any two letters
+ *   line breaks      `Ada` ⏎ `Example`, `Exam-` ⏎ `ple` → so may a hyphen and a line break
+ *   soft hyphens     U+00AD inside a word              → treated like a hyphen
+ *   a reference list `A. Example`, `Example, A.`       → a personal name's bibliographic forms
+ *                                                         are searched too (`spellingsOf`)
+ *
+ * Only the ENDS of a token are anchored: the letter or digit before its first character and after
+ * its last must be absent, so `Ada` does not match inside `Canada`. Between its characters anything
+ * of the above may stand. The token's own spaces and hyphens are separators too, so
+ * `Ada Example` also finds `Ada-Example` and `AdaExample` — the same person.
+ */
+
+/** Where a declared string was found: a page's text, a metadata field, or a link's target. */
+export type LeakPlace =
+  | { readonly kind: "page"; readonly page: number }
+  | { readonly kind: "metadata"; readonly field: string }
+  | { readonly kind: "link"; readonly page: number; readonly uri: string };
+
+/** One text to search, and where it came from. */
+export interface Searchable {
+  readonly place: LeakPlace;
+  readonly text: string;
+}
+
+/** One declared string found in one place, with the text it matched as it stands there. */
+export interface Leak {
+  readonly token: string;
+  readonly place: LeakPlace;
+  readonly found: string;
+}
+
+/** What may stand between two characters of a token: whitespace, hyphens, soft hyphens. */
+const SEPARATOR = "[\\s\\u00AD-]*";
+const BEFORE = "(?<![\\p{L}\\p{N}])";
+const AFTER = "(?![\\p{L}\\p{N}])";
+
+/** `c` as a pattern that matches it literally. */
+const literal = (c: string): string =>
+  c.replace(/[.*+?^${}()|[\]\\/]/gu, "\\$&");
+
+/** The characters of a token that must appear: NFKC, without its own separators. */
+const lettersOf = (token: string): readonly string[] =>
+  token
+    .normalize("NFKC")
+    .replace(/[\s\u00AD-]/gu, "")
+    .match(/./gsu) ?? [];
+
+/** A word of a personal name: letters, with an apostrophe or a hyphen inside. */
+const NAME_WORD = /^\p{Lu}[\p{L}'’-]*$/u;
+
+/**
+ * The spellings a bibliography gives a personal name, besides the name itself. A token of two to
+ * four capitalized words (`Ada Example`, `Ada B. Example` is not one: an initial is not a word)
+ * is read as given names and a surname, and the reference list's forms are added: initials
+ * (`A. Example`), surname first (`Example, Ada`, `Example, A.`). A token that is not a name — a
+ * handle, an address, one word — has only itself.
+ */
+export function spellingsOf(token: string): readonly string[] {
+  const words = token.trim().split(/\s+/u);
+  if (
+    words.length < 2 ||
+    words.length > 4 ||
+    !words.every((w) => NAME_WORD.test(w))
+  )
+    return [token];
+  const surname = words.slice(-1).join("");
+  const given = words.slice(0, -1);
+  const initials = given.map((w) => `${w.slice(0, 1)}.`).join(" ");
+  return [
+    token,
+    `${initials} ${surname}`,
+    `${surname}, ${given.join(" ")}`,
+    `${surname}, ${initials}`,
+  ];
+}
+
+/** One spelling as a pattern body: its characters, separators allowed between any two. */
+const bodyOf = (spelling: string): string =>
+  lettersOf(spelling).map(literal).join(SEPARATOR);
+
+/**
+ * A declared token as the pattern that finds it and its bibliographic spellings (see the module
+ * header), or null for a token with nothing but separators in it — which would match everywhere,
+ * and is refused where it is read.
+ */
+export function tokenPattern(token: string): Readonly<RegExp> | null {
+  if (lettersOf(token).length === 0) return null;
+  const bodies = spellingsOf(token).map(bodyOf).join("|");
+  return new RegExp(`${BEFORE}(?:${bodies})${AFTER}`, "iu");
+}
+
+/**
+ * Every token found in the sources, once per place: its first match there. Two tokens that match
+ * the same text in the same place (`Ada Example` and `adaexample` both finding `AdaExample`) are one
+ * leak, reported under the first token declared. Pure.
+ */
+export function findLeaks(
+  tokens: readonly string[],
+  sources: readonly Searchable[],
+): readonly Leak[] {
+  const patterns = tokens.flatMap((token) => {
+    const re = tokenPattern(token);
+    return re === null ? [] : [{ token, re }];
+  });
+  return sources.flatMap((s) => {
+    const text = s.text.normalize("NFKC");
+    const leaks = patterns.flatMap(({ token, re }) => {
+      const m = re.exec(text);
+      return m === null ? [] : [{ token, place: s.place, found: m[0] }];
+    });
+    const key = (l: Leak): string => l.found.toLowerCase();
+    return leaks.filter(
+      (l, i) => leaks.findIndex((x) => key(x) === key(l)) === i,
+    );
+  });
+}

package/src/domain/body-pages.test.ts

@@ -0,0 +1,300 @@
+import { describe, expect, it } from "vitest";
+import {
+  bodyEnd,
+  isAppendixHeading,
+  isReferencesHeading,
+} from "./body-pages.ts";
+
+describe("isReferencesHeading", () => {
+  it.each([
+    "References",
+    "REFERENCES",
+    "R EFERENCES",
+    "Bibliography",
+    "7 References",
+    "VII. REFERENCES",
+    "  References  ",
+  ])("%j is a heading", (line) => {
+    expect(isReferencesHeading(line)).toBe(true);
+  });
+
+  it.each(["See the references below", "References to prior work", "Refs", ""])(
+    "%j is not",
+    (line) => {
+      expect(isReferencesHeading(line)).toBe(false);
+    },
+  );
+});
+
+describe("bodyEnd", () => {
+  it("a heading below body text on its page: that page is a body page", () => {
+    expect(
+      bodyEnd([
+        "Intro\nbody",
+        "more body",
+        "end of the body\nReferences\n[1] A.",
+        "Appendix",
+      ]),
+    ).toEqual({ kind: "found", by: "references", page: 3, bodyPages: 3 });
+  });
+
+  it("a heading that is the first text of its page: the body ends on the page before", () => {
+    expect(bodyEnd(["Intro\nbody", "more body", "References\n[1] A."])).toEqual(
+      { kind: "found", by: "references", page: 3, bodyPages: 2 },
+    );
+  });
+
+  it("empty lines and a bare page number above the heading are not body", () => {
+    expect(bodyEnd(["body", "\n  \n7\nR EFERENCES\n[1] x"])).toEqual({
+      kind: "found",
+      by: "references",
+      page: 2,
+      bodyPages: 1,
+    });
+  });
+
+  it("a statement or appendix after the references is not counted", () => {
+    expect(
+      bodyEnd([
+        "body",
+        "R EFERENCES\n[1] x\nLLM Usage Statement",
+        "Appendix A",
+      ]),
+    ).toEqual({ kind: "found", by: "references", page: 2, bodyPages: 1 });
+  });
+
+  it("no heading on any page is said, not guessed", () => {
+    expect(bodyEnd(["body", "more"])).toEqual({ kind: "missing" });
+    expect(bodyEnd([])).toEqual({ kind: "missing" });
+  });
+});
+
+describe("bodyEnd: a «References» line that is not the heading", () => {
+  const BODY = [
+    "Intro\nbody",
+    "Related work\nReferences\nto prior work are many.",
+  ];
+
+  it("🔴 a bare «References» line in the body loses to a heading followed by [1]", () => {
+    expect(
+      bodyEnd([...BODY, "more body", "last body line\nReferences\n[1] A."]),
+    ).toEqual({ kind: "found", by: "references", page: 4, bodyPages: 4 });
+  });
+
+  it("🔴 with hyperref's anchor, a bare «References» on an earlier page is ignored", () => {
+    expect(
+      bodyEnd([...BODY, "References\n[1] A.", "Appendix"], {
+        bib: 3,
+        appendix: null,
+      }),
+    ).toEqual({ kind: "found", by: "references", page: 3, bodyPages: 2 });
+  });
+
+  it("🔴 a table header «References» above the heading on the anchor's page: the heading is the confirmed one", () => {
+    expect(
+      bodyEnd(["body", "TABLE 2\nTool\nReferences\nx\nReferences\n[1] A."], {
+        bib: 2,
+        appendix: null,
+      }),
+    ).toEqual({ kind: "found", by: "references", page: 2, bodyPages: 2 });
+  });
+
+  it("with an anchor and no [1] after the heading, the last heading line on the anchor's page is taken", () => {
+    expect(
+      bodyEnd(["body", "Tool\nReferences\nx\nReferences\nAbel, A."], {
+        bib: 2,
+        appendix: null,
+      }),
+    ).toEqual({ kind: "found", by: "references", page: 2, bodyPages: 2 });
+    expect(
+      bodyEnd(["body", "References\nAbel, A. (2020)."], {
+        bib: 2,
+        appendix: null,
+      }),
+    ).toEqual({ kind: "found", by: "references", page: 2, bodyPages: 1 });
+  });
+
+  it("without an anchor or a confirmed heading, the first bare heading is the fallback", () => {
+    expect(bodyEnd(["body", "References\nAbel, A. (2020)."])).toEqual({
+      kind: "found",
+      by: "references",
+      page: 2,
+      bodyPages: 1,
+    });
+  });
+});
+
+describe("bodyEnd: the two signals disagree", () => {
+  it("the anchor's page has no heading line: said, with the anchor", () => {
+    expect(
+      bodyEnd(["body", "References\n[1] A.", "[2] B."], {
+        bib: 3,
+        appendix: null,
+      }),
+    ).toEqual({
+      kind: "disagree",
+      what: "references",
+      heading: null,
+      anchor: 3,
+    });
+  });
+
+  it("a confirmed heading on another page than the anchor's: said, with both", () => {
+    expect(
+      bodyEnd(["body\nReferences\n[1] quoted", "References\n[1] A."], {
+        bib: 2,
+        appendix: null,
+      }),
+    ).toEqual({ kind: "disagree", what: "references", heading: 1, anchor: 2 });
+  });
+
+  it("an anchor past the last page is a disagreement, not a crash", () => {
+    expect(bodyEnd(["References\n[1] A."], { bib: 5, appendix: null })).toEqual(
+      {
+        kind: "disagree",
+        what: "references",
+        heading: null,
+        anchor: 5,
+      },
+    );
+  });
+});
+
+describe("bodyEnd: running headers and footers are not body", () => {
+  /** A page of an ACM-style paper: a running header, then `text`. */
+  const page = (n: number, text: string) =>
+    `Conf '26, June ${String(n)}, Place\nAuthors\n${text}`;
+
+  it("🔴 a heading at the top of its page, under a running header: the page is not body", () => {
+    const pages = [1, 2, 3].map((n) => page(n, `body ${String(n)}`));
+    expect(bodyEnd([...pages, page(4, "References\n[1] A.")])).toEqual({
+      kind: "found",
+      by: "references",
+      page: 4,
+      bodyPages: 3,
+    });
+  });
+
+  it("body text under the header and above the heading still makes the page body", () => {
+    const pages = [1, 2, 3].map((n) => page(n, `body ${String(n)}`));
+    expect(
+      bodyEnd([...pages, page(4, "the end of the body\nReferences\n[1] A.")]),
+    ).toEqual({ kind: "found", by: "references", page: 4, bodyPages: 4 });
+  });
+
+  it("a line on only two pages is not a running header: it counts as body", () => {
+    expect(bodyEnd(["Setup\nbody", "x", "Setup\nReferences\n[1] A."])).toEqual({
+      kind: "found",
+      by: "references",
+      page: 3,
+      bodyPages: 3,
+    });
+  });
+});
+
+describe("isAppendixHeading", () => {
+  it.each([
+    "Appendix A.",
+    "APPENDIX",
+    "A PPENDIX B",
+    "Appendices",
+    "Appendix 1:",
+  ])("%j is a heading", (line) => {
+    expect(isAppendixHeading(line)).toBe(true);
+  });
+  it.each([
+    "Appendix A shows the rest.",
+    "See the appendix",
+    "Appendix A Proofs",
+    "",
+  ])("%j is not", (line) => {
+    expect(isAppendixHeading(line)).toBe(false);
+  });
+});
+
+describe("bodyEnd: an appendix before the references ends the body", () => {
+  const PAGES = [
+    "body",
+    "more body",
+    "the conclusion ends here",
+    "Appendix A.\nDetailed results\nTABLE 3",
+    "References\n[1] A.",
+  ];
+
+  it("🔴 the appendix at the top of its page, the references after it: the body ends on the page before", () => {
+    expect(bodyEnd(PAGES, { bib: 5, appendix: 4 })).toEqual({
+      kind: "found",
+      by: "appendix",
+      page: 4,
+      bodyPages: 3,
+    });
+  });
+
+  it("an appendix that starts below the conclusion on its page: that page is body", () => {
+    const pages = [...PAGES];
+    pages[3] = "the conclusion ends here\nAppendix A.\nDetails";
+    expect(bodyEnd(pages, { bib: 5, appendix: 4 })).toEqual({
+      kind: "found",
+      by: "appendix",
+      page: 4,
+      bodyPages: 4,
+    });
+  });
+
+  it("an appendix after the references changes nothing", () => {
+    expect(
+      bodyEnd(["body", "end\nReferences\n[1] A.", "Appendix A.\nx"], {
+        bib: 2,
+        appendix: 3,
+      }),
+    ).toEqual({ kind: "found", by: "references", page: 2, bodyPages: 2 });
+  });
+
+  it("the appendix and the references on one page: the heading that comes first ends the body", () => {
+    expect(
+      bodyEnd(["body", "end\nAppendix A.\nx\nReferences\n[1] A."], {
+        bib: 2,
+        appendix: 2,
+      }),
+    ).toEqual({ kind: "found", by: "appendix", page: 2, bodyPages: 2 });
+  });
+
+  it("an appendix and no references heading at all: the appendix ends the body", () => {
+    expect(
+      bodyEnd(["body", "Appendix\nx"], { bib: null, appendix: 2 }),
+    ).toEqual({
+      kind: "found",
+      by: "appendix",
+      page: 2,
+      bodyPages: 1,
+    });
+  });
+});
+
+describe("bodyEnd: where the appendix is not taken, or not found", () => {
+  it("without hyperref's anchor the appendix is not looked for: a sentence can end on «Appendix A.»", () => {
+    expect(
+      bodyEnd(["body, detailed in\nAppendix A.", "end\nReferences\n[1] A."]),
+    ).toEqual({ kind: "found", by: "references", page: 2, bodyPages: 2 });
+  });
+
+  it("hyperref anchors the appendix on a page with no line reading «Appendix»: said", () => {
+    expect(
+      bodyEnd(["body", "A Proofs\nx"], { bib: null, appendix: 2 }),
+    ).toEqual({
+      kind: "disagree",
+      what: "appendix",
+      heading: null,
+      anchor: 2,
+    });
+  });
+
+  it("an appendix anchor past the last page is a disagreement, not a crash", () => {
+    expect(bodyEnd(["body"], { bib: null, appendix: 4 })).toEqual({
+      kind: "disagree",
+      what: "appendix",
+      heading: null,
+      anchor: 4,
+    });
+  });
+});

package/src/domain/body-pages.ts

@@ -0,0 +1,223 @@
+/**
+ * HOW MANY PAGES THE BODY TAKES, counted from what the PDF says rather than from how banal
+ * classifies its pages. A venue that limits the body «excluding references and appendices» (AIDC)
+ * cannot be judged on banal's body count: banal calls any page holding non-bibliography text body,
+ * so an LLM Usage Statement or an appendix placed after the bibliography is counted as body, and a
+ * correct paper fails (measured, `presets/aidc.jsonc`).
+ *
+ * ── WHERE THE BODY ENDS: AT THE REFERENCES, OR AT THE APPENDIX, WHICHEVER COMES FIRST ──────
+ * «Excluding references and appendices» excludes an appendix wherever it sits, so the body ends at
+ * the first of the two. Each is found by a structural signal first:
+ *
+ *   references  the page of the first bibliography entry, from the destination hyperref writes for
+ *               every `\bibitem` (`cite.<key>`); then, on that page, the heading line: a line that
+ *               reads «References» or «Bibliography» (any case, optionally numbered), the one
+ *               CONFIRMED by a next line opening the first entry, `[1]`, else the last one there.
+ *               Without hyperref: the first confirmed heading, else the first bare one — a table
+ *               header or a subsection titled «References» reads the same, so it is a fallback.
+ *   appendix    the page hyperref anchored the appendix on (an `appendix.<letter>` destination, or a
+ *               bookmark titled «Appendix…»); then, on that page, the line reading «Appendix»,
+ *               «Appendix A.», «APPENDIX» or «Appendices». Without hyperref the appendix is not
+ *               looked for: a sentence can end on a line reading «Appendix A.», and nothing tells
+ *               it from the heading.
+ *
+ * A structural signal whose page has no heading line, or a confirmed references heading on another
+ * page than hyperref's first entry, is a disagreement, and it is said rather than resolved by
+ * picking one.
+ *
+ * ── THE PAGE THE BODY ENDS ON ──────────────────────────────────────────────────────
+ * Body text above the heading on that page makes it a body page: a body that runs half a page past
+ * the limit is over the limit, and the count must flag it rather than let a desk reject through.
+ * Only when the heading is the first text of its page does the body end on the page before. A line
+ * with no letter (a page number) is not body text, and neither is a running header or footer — a
+ * line that repeats, digits aside, on at least three pages and a third of them.
+ */
+
+/** What ends the body. */
+export type BodyEndsAt = "references" | "appendix";
+
+/** Where hyperref anchored the bibliography's first entry and the appendix: 1-based pages, or null. */
+export interface Anchors {
+  readonly bib: number | null;
+  readonly appendix: number | null;
+}
+
+/** Where the body ends, that no page says, or that a structural signal and the text disagree. */
+export type BodyEnd =
+  | {
+      readonly kind: "found";
+      readonly by: BodyEndsAt;
+      /** 1-based page holding the heading that ends the body. */
+      readonly page: number;
+      /** The body, as the venue counts it: the heading's page too, when body text stands above it. */
+      readonly bodyPages: number;
+    }
+  | { readonly kind: "missing" }
+  | {
+      readonly kind: "disagree";
+      readonly what: BodyEndsAt;
+      /** The page of the first confirmed references heading, or null when the anchor's page has no heading. */
+      readonly heading: number | null;
+      /** The page hyperref anchored it on. */
+      readonly anchor: number;
+    };
+
+/**
+ * A line that is a references heading: `References` or `Bibliography`, in any case (IEEEtran sets
+ * `REFERENCES` in small caps, which pdf.js may split as `R EFERENCES`), optionally numbered
+ * (`7 References`, `VII. REFERENCES`). The line is compared with every space removed.
+ */
+const HEADING = /^(?:(?:\d+|[ivxlcdm]+)\.?)?(?:references|bibliography)$/iu;
+
+/** Whether one line of a page's text is the references heading. */
+export const isReferencesHeading = (line: string): boolean =>
+  HEADING.test(line.normalize("NFKC").replace(/\s+/gu, ""));
+
+/** A line that is an appendix heading: `Appendix A.`, `APPENDIX`, `Appendices`, spaces removed. */
+const APPENDIX_HEADING = /^appendi(?:x|ces)(?:[a-z]|\d+)?[.:]?$/iu;
+
+/** Whether one line of a page's text is an appendix heading. */
+export const isAppendixHeading = (line: string): boolean =>
+  APPENDIX_HEADING.test(line.normalize("NFKC").replace(/\s+/gu, ""));
+
+/** Whether a line opens the first entry of a numbered bibliography: `[1]`. */
+const isFirstEntry = (line: string): boolean => /^\s*\[\s*1\s*\]/u.test(line);
+
+/** A page's lines, and where its headings are: the confirmed one, and every one. */
+interface PageReading {
+  readonly lines: readonly string[];
+  /** Line index of a heading whose next non-empty line is `[1]`, or -1. */
+  readonly confirmed: number;
+  /** Line indices of every heading line. */
+  readonly headings: readonly number[];
+}
+
+function readPage(text: string): PageReading {
+  const lines = text.split("\n");
+  const headings = lines.flatMap((l, i) => (isReferencesHeading(l) ? [i] : []));
+  const confirmed =
+    headings.find((i) =>
+      isFirstEntry(lines.slice(i + 1).find((l) => l.trim() !== "") ?? ""),
+    ) ?? -1;
+  return { lines, confirmed, headings };
+}
+
+/** A line with digits blanked and spaces collapsed: what a running header keeps from page to page. */
+const shape = (line: string): string =>
+  line.replace(/\d+/gu, "#").replace(/\s+/gu, " ").trim();
+
+/** The shapes of the lines that repeat on at least three pages and a third of them. */
+function runningLines(pages: readonly PageReading[]): ReadonlySet<string> {
+  const onPages = pages.flatMap((p) => [...new Set(p.lines.map(shape))]);
+  const sorted = onPages.toSorted();
+  const floor = Math.max(3, pages.length / 3);
+  // In sorted order, a shape on `floor` pages is the same string `floor - 1` places further on.
+  return new Set(
+    sorted.filter((s, i) => sorted[i + Math.ceil(floor) - 1] === s),
+  );
+}
+
+/** The heading line the references start at on a page: the confirmed one, else the last one. */
+const startLine = (p: PageReading): number =>
+  p.confirmed >= 0 ? p.confirmed : (p.headings.at(-1) ?? -1);
+
+/** A heading that ends the body: its 0-based page and its line there. */
+interface At {
+  readonly kind: "at";
+  readonly by: BodyEndsAt;
+  readonly page: number;
+  readonly line: number;
+  /** The lines of that page above the heading. */
+  readonly above: readonly string[];
+}
+type Start = At | Extract<BodyEnd, { readonly kind: "disagree" | "missing" }>;
+
+/** The references heading at line `line` of 0-based page `page`. */
+const at = (page: number, p: PageReading, line: number): At => ({
+  kind: "at",
+  by: "references",
+  page,
+  line,
+  above: p.lines.slice(0, line),
+});
+
+/** Where the references start: at hyperref's first entry's page, else at the heading in the text. */
+function referencesAt(
+  pages: readonly PageReading[],
+  anchor: number | null,
+): Start {
+  const confirmed = pages.findIndex((p) => p.confirmed >= 0);
+  if (anchor !== null) {
+    const p = pages[anchor - 1];
+    const line = p === undefined ? -1 : startLine(p);
+    if (p === undefined || line < 0)
+      return { kind: "disagree", what: "references", heading: null, anchor };
+    if (confirmed >= 0 && confirmed !== anchor - 1)
+      return {
+        kind: "disagree",
+        what: "references",
+        heading: confirmed + 1,
+        anchor,
+      };
+    return at(anchor - 1, p, line);
+  }
+  const i =
+    confirmed >= 0 ? confirmed : pages.findIndex((p) => p.headings.length > 0);
+  const p = pages[i];
+  return p === undefined ? { kind: "missing" } : at(i, p, startLine(p));
+}
+
+/** Where the appendix starts: on hyperref's page for it, at the line reading «Appendix». */
+function appendixAt(
+  pages: readonly PageReading[],
+  anchor: number | null,
+): Start {
+  if (anchor === null) return { kind: "missing" };
+  const lines = pages[anchor - 1]?.lines ?? [];
+  const line = lines.findIndex(isAppendixHeading);
+  return line < 0
+    ? { kind: "disagree", what: "appendix", heading: null, anchor }
+    : {
+        kind: "at",
+        by: "appendix",
+        page: anchor - 1,
+        line,
+        above: lines.slice(0, line),
+      };
+}
+
+/** The body's end at a heading: the heading's page counts when body text stands above it. */
+function endAt(pages: readonly PageReading[], at: At): BodyEnd {
+  const running = runningLines(pages);
+  const body = at.above.some((l) => /\p{L}/u.test(l) && !running.has(shape(l)));
+  return {
+    kind: "found",
+    by: at.by,
+    page: at.page + 1,
+    bodyPages: body ? at.page + 1 : at.page,
+  };
+}
+
+/**
+ * Where the body ends — at the references or the appendix, whichever comes first — from each
+ * page's text and where hyperref anchored the two. Pure.
+ */
+export function bodyEnd(
+  texts: readonly string[],
+  anchors: Anchors = { bib: null, appendix: null },
+): BodyEnd {
+  const pages = texts.map(readPage);
+  const starts = [
+    referencesAt(pages, anchors.bib),
+    appendixAt(pages, anchors.appendix),
+  ];
+  const disagree = starts.find(
+    (s): s is Extract<BodyEnd, { readonly kind: "disagree" }> =>
+      s.kind === "disagree",
+  );
+  if (disagree !== undefined) return disagree;
+  const first = starts
+    .filter((s): s is At => s.kind === "at")
+    .toSorted((a, b) => a.page - b.page || a.line - b.line)[0];
+  return first === undefined ? { kind: "missing" } : endAt(pages, first);
+}

package/src/domain/tex-document.ts

@@ -141,3 +141,13 @@ export type ProsePiece =
 export interface Passage {
   readonly pieces: readonly [ProsePiece, ...ProsePiece[]];
 }
+
+/**
+ * A command that changes the page layout a venue's template sets: the text block, the margins,
+ * the line spacing, or space pulled back with a negative skip. `command` is how a message names it
+ * (`\setlength{\textheight}`, `\vspace{-2mm}`).
+ */
+export interface LayoutOverride {
+  readonly command: string;
+  readonly place: Place;
+}