paperlint 5.0.0 → 6.1.0

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/register.test.ts

@@ -0,0 +1,153 @@
+/**
+ * The register measures on real parses: what counts as a contrast frame, a relation marker and a
+ * claim in bold, and what does not; the band the anchors set; the excerpt a finding quotes.
+ * Every "does not count" case below is a sentence shape found in an accepted ACSAC paper.
+ */
+import { describe, expect, it } from "vitest";
+import { latexReader } from "../adapters/latex/index.ts";
+import {
+  bandOf,
+  bodySentences,
+  claimEmphasis,
+  contrastFrames,
+  excerpt,
+  rateOf,
+  relationMarkers,
+  type RegisterAnchor,
+} from "./register.ts";
+
+const doc = (body: string): string =>
+  `\\documentclass{article}\n\\begin{document}\n${body}\n\\end{document}\n`;
+const sentencesOf = (body: string) =>
+  bodySentences(latexReader.bodyProse(doc(body)));
+const frames = (body: string): number =>
+  contrastFrames(sentencesOf(body)).length;
+const markers = (body: string): number =>
+  relationMarkers(sentencesOf(body)).length;
+const claims = (body: string): readonly string[] =>
+  claimEmphasis(latexReader.bodyEmphasis(doc(body))).map((o) => o.match);
+
+describe("contrastFrames — a claim set against a rejected alternative", () => {
+  it.each([
+    [
+      "X, not Y",
+      "They react to the dangerous word, not the dangerous operation.",
+    ],
+    ["X --- not Y", "It guarantees encryption --- not authenticity."],
+    ["X; not Y", "We score the operation; not the attacker."],
+    ["X, and not Y", "It reads the field, and not the raw input."],
+    ["not X but Y", "Over-blocking is not a side metric but a precondition."],
+    ["rather than", "It fires on the mention rather than the act."],
+    ["instead of", "It reads the whole event instead of the command."],
+    ["as opposed to", "It matches words as opposed to operations."],
+  ])("🔴 %s is one frame", (_form, sentence) => {
+    expect(frames(sentence)).toBe(1);
+  });
+
+  it.each([
+    ["not only … but also", "It is not only fast but also exact."],
+    [
+      "a negated clause",
+      "The nature of the audit is not reported, but it did not assess quality.",
+    ],
+    ["«, not yet»", "The fix is merged, not yet released."],
+    [
+      "«, not already in the corpus»",
+      "We kept every guard published since, not already in the corpus.",
+    ],
+    ["«without»", "The attack works without any access to the device."],
+    ["«unlike»", "Unlike prior work, we measure the installed guards."],
+    ["a bare negation", "The guard does not block it."],
+  ])("%s is no frame", (_form, sentence) => {
+    expect(frames(sentence)).toBe(0);
+  });
+
+  it("two frames in one sentence are two; one phrase matching two forms is one", () => {
+    expect(
+      frames("It reads the word, not the act, rather than the operation."),
+    ).toBe(2);
+    expect(frames("It is not a word but rather than a verb.")).toBe(2);
+  });
+
+  it("a frame in a table, a caption or a heading is not prose, so not counted", () => {
+    expect(
+      frames(
+        "\\section{Words, not operations}\n\\begin{table}\\caption{Words, not operations.}\\begin{tabular}{l}a, not b\\end{tabular}\\end{table}\nPlain text here.",
+      ),
+    ).toBe(0);
+  });
+});
+
+describe("relationMarkers — words that name how a sentence relates to the one before", () => {
+  it("🔴 each marker counts where it stands, sentence-initial or not", () => {
+    expect(
+      markers(
+        "However, the rate is low. It fails because the rule matches words. For example, echo is blocked. It is therefore unsafe.",
+      ),
+    ).toBe(4);
+  });
+
+  it("a marker inside a longer word is not one: «thusly» is no «thus», «sincere» no «since»", () => {
+    expect(
+      markers("The sincere author wrote thusly. Eventually it held."),
+    ).toBe(0);
+  });
+});
+
+describe("claimEmphasis — a claim set in bold inside a sentence", () => {
+  it("🔴 a bold phrase of six words or more, or holding a number, inside a sentence", () => {
+    expect(
+      claims(
+        "We find that \\textbf{they react to the dangerous word}. The \\textbf{median coverage is 2.5/10} here.",
+      ),
+    ).toEqual([
+      "they react to the dangerous word",
+      "median coverage is 2.5/10",
+    ]);
+  });
+
+  it("a term in bold, a label opening a paragraph or item, italics, and a run-in heading are not claims", () => {
+    expect(
+      claims(
+        "BaroVox offers a \\textbf{Pressure-Acoustic Transformation (PAT)} here.\n\n\\textbf{Varying the orientation of the sound source from the device}. We vary it.\n\\begin{itemize}\n\\item \\textbf{A corpus of user security questions with sources}: we release it.\n\\end{itemize}\nWe \\emph{find that the guards react to the word}.\n\n\\textbf{Threats to validity of the 46 guards.} None.",
+      ),
+    ).toEqual([]);
+  });
+});
+
+describe("bandOf — the anchors' range, widened by two Poisson standard deviations", () => {
+  const anchor = (words: number, contrast_frames: number): RegisterAnchor => ({
+    paper: "p",
+    words,
+    counts: { contrast_frames, claim_emphasis: 0, relation_markers: 0 },
+  });
+
+  it("🔴 the edges stand two standard deviations of the edge anchor's count beyond it", () => {
+    // 4 in 10,000 words: rate 4, sd 2 → max 8. 1 in 10,000: rate 1, sd 1 → min 1 - 2 < 0 → 0.
+    expect(
+      bandOf([anchor(10_000, 4), anchor(10_000, 1)], "contrast_frames"),
+    ).toEqual({ min: 0, max: 8, anchorMin: 1, anchorMax: 4, anchors: 2 });
+  });
+
+  it("an anchor with no occurrence is widened as if it had one; a floor above zero stays", () => {
+    expect(bandOf([anchor(10_000, 0)], "contrast_frames")?.max).toBe(2);
+    expect(bandOf([anchor(10_000, 100)], "contrast_frames")?.min).toBe(80);
+  });
+
+  it("no anchors, no band; a body of no words has a rate of zero", () => {
+    expect(bandOf([], "contrast_frames")).toBeNull();
+    expect(rateOf(3, 0)).toBe(0);
+  });
+});
+
+describe("excerpt — the words around an occurrence, as a finding quotes them", () => {
+  it("the match with its neighbours, cut at a word, an ellipsis where the sentence goes on", () => {
+    const s =
+      "We score 46 gates and find that they react to the dangerous word, not the dangerous operation, in every one of the ten cases we built.";
+    const at = s.indexOf(", not");
+    expect(excerpt(s, at, at + 6)).toBe(
+      "…that they react to the dangerous word, not the dangerous operation, in every one…",
+    );
+    expect(excerpt("a, not b", 1, 7)).toBe("a, not b");
+  });
+});