paperlint 4.2.0 → 6.0.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/paper-source.ts

@@ -11,8 +11,8 @@
  *
  * ── WHAT IS NOT DONE ─────────────────────────────────────────────────────────────
  * No macro is expanded, so a path built from a macro (`\input{\dir/intro}`) is read as written. A
- * file that cannot be found is reported and left out; a file that includes itself, directly or
- * through others, is spliced once.
+ * file that cannot be found is left out and named in `missing`; a file that includes itself,
+ * directly or through others, is spliced once.
  */
 import { extname, normalize } from "node:path";
 import type { Span } from "./tex-document.ts";

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;
+}

package/src/facts-file.test.ts

@@ -82,14 +82,24 @@ const doc = (last: PageText, geometry: Geometry = NONE) =>
     sha: "a".repeat(64),
     venue: "agenticdev",
     kind: "short",
-    read: { pages: 4, fonts: FONTS, last, layout: [] },
+    read: {
+      pages: 4,
+      fonts: FONTS,
+      last,
+      layout: [],
+      pageTexts: [],
+      links: [],
+      bibAnchorPage: null,
+      appendixAnchorPage: null,
+      metadata: {},
+    },
     geometry,
   });
 
 // ── the document ────────────────────────────────────────────────────────────────────────
-test("schema 2; a measured last page gives both heights, in both fields", () => {
+test("schema 3; a measured last page gives both heights, in both fields", () => {
   const d = doc(lastPage(60, 30));
-  assert.equal(d.schema, 2);
+  assert.equal(d.schema, 3);
   assert.deepEqual(d.last_page, { kind: "measured", columns_pt: [600, 300] });
   assert.deepEqual(d.last_page_cols_pt, [600, 300]);
   assert.equal(d.npages, 4);
@@ -150,7 +160,17 @@ const PDF_BYTES = "%PDF-pretend";
 const good: PdfReader = () =>
   Promise.resolve({
     ok: true,
-    facts: { pages: 2, fonts: FONTS, last: lastPage(60, 60), layout: [] },
+    facts: {
+      pages: 2,
+      fonts: FONTS,
+      last: lastPage(60, 60),
+      layout: [],
+      pageTexts: [],
+      links: [],
+      bibAnchorPage: null,
+      appendixAnchorPage: null,
+      metadata: {},
+    },
   });
 /** The shipped presets at their real paths: `extends` resolves through the same Files port. */
 const SHIPPED_PRESETS = Object.fromEntries(
@@ -290,6 +310,11 @@ test("a PDF with no text has an empty font list, not a failed document", () => {
       fonts: { kind: "no-text" },
       last: lastPage(0, 0),
       layout: [],
+      pageTexts: [],
+      links: [],
+      bibAnchorPage: null,
+      appendixAnchorPage: null,
+      metadata: {},
     },
     geometry: NONE,
   });
@@ -387,3 +412,74 @@ test("parseFactsText: a missing schema is reported as null, another schema by it
   const other = parse({ ...written(), schema: 1 });
   assert.deepEqual(!other.ok && other.error, { kind: "schema", got: "1" });
 });
+
+test("schema 3: what the PDF says is written, and reads back typed", () => {
+  const said = {
+    ...written(),
+    pages_text: ["Ada Example\nIntroduction", "References"],
+    metadata: { Author: "Ada Example" },
+    links: [{ page: 1, uri: "https://github.com/adaexample" }],
+    bib_anchor_page: 2,
+    appendix_anchor_page: 3,
+  };
+  const r = parse(said);
+  assert.ok(r.ok);
+  assert.deepEqual(r.value.text, {
+    pages: ["Ada Example\nIntroduction", "References"],
+    metadata: { Author: "Ada Example" },
+    links: [{ page: 1, uri: "https://github.com/adaexample" }],
+    bibAnchorPage: 2,
+    appendixAnchorPage: 3,
+  });
+  const d = factsDocument({
+    pdf: "paper.pdf",
+    sha: "a".repeat(64),
+    venue: null,
+    kind: null,
+    read: {
+      pages: 1,
+      fonts: FONTS,
+      last: lastPage(1, 0),
+      layout: [],
+      pageTexts: ["x"],
+      links: [{ page: 1, uri: "u" }],
+      bibAnchorPage: 1,
+      appendixAnchorPage: null,
+      metadata: { Title: "t" },
+    },
+    geometry: MEASURED,
+  });
+  assert.deepEqual(
+    [
+      d.pages_text,
+      d.links,
+      d.bib_anchor_page,
+      d.appendix_anchor_page,
+      d.metadata,
+    ],
+    [["x"], [{ page: 1, uri: "u" }], 1, null, { Title: "t" }],
+  );
+});
+
+test("schema 3: a missing or malformed text field is refused, naming it", () => {
+  const noText = Object.fromEntries(
+    Object.entries(written()).filter(([k]) => k !== "pages_text"),
+  );
+  assert.equal(why(noText), "`pages_text` is not a list of strings");
+  assert.equal(
+    why({ ...written(), metadata: { Author: 3 } }),
+    "`metadata` is not an object of strings",
+  );
+  assert.equal(
+    why({ ...written(), links: [{ page: 0, uri: "u" }] }),
+    "`links` is not a list of { page, uri }",
+  );
+  assert.equal(
+    why({ ...written(), bib_anchor_page: 0 }),
+    "`bib_anchor_page` is neither a page number nor null",
+  );
+  assert.equal(
+    why({ ...written(), appendix_anchor_page: "3" }),
+    "`appendix_anchor_page` is neither a page number nor null",
+  );
+});