paperlint 5.0.0 → 6.1.0

package/src/adapters/latex/index.test.ts

@@ -8,6 +8,7 @@ import type * as Ast from "@unified-latex/unified-latex-types";
 import { describe, expect, it } from "vitest";
 import { runText, spanIn, type ProsePiece } from "../../domain/tex-document.ts";
 import {
+  bodyEmphasis,
   bodyProse,
   documentBodyOf,
   documentClassOf,
@@ -470,6 +471,15 @@ describe("bodyProse — run-in headings and list items", () => {
     ).toEqual(["It grows.", "It holds."]);
   });
 
+  it("🔴 braces around a run-in heading change nothing: `{\\textbf{Side-channel eavesdropping:}}` is a heading, left out", () => {
+    // barovox-acsac24, Chapters/09_Related_Works.tex, writes its run-in headings this way.
+    expect(
+      texts(
+        "\\begin{document}\n{\\textbf{Side-channel eavesdropping:}} It has been studied.\n\\end{document}",
+      ),
+    ).toEqual(["It has been studied."]);
+  });
+
   it("the same markup inside a sentence, or without the closing mark, is prose", () => {
     expect(
       texts(
@@ -541,3 +551,84 @@ describe("documentBodyOf — the body of a source that is a document of its own"
     );
   });
 });
+
+describe("bodyEmphasis — phrases set apart inside the body's prose, and where they stand", () => {
+  /** Each phrase as `style/place: text`. */
+  const shape = (src: string): readonly string[] =>
+    bodyEmphasis(parseLatex(src)).map(
+      (e) => `${e.style}/${e.place}: ${e.text}`,
+    );
+
+  it("🔴 a bold phrase inside a sentence is inline; one opening a paragraph or an item is a label (opening)", () => {
+    expect(
+      shape(
+        "\\begin{document}\nWe find that \\textbf{the guards react to the word}.\n\n\\textbf{Varying the volume}. We vary it.\n\\begin{itemize}\n\\item \\textbf{A corpus of questions}: we release it.\n\\end{itemize}\n\\end{document}",
+      ),
+    ).toEqual([
+      "bold/inline: the guards react to the word",
+      "bold/opening: Varying the volume",
+      "bold/opening: A corpus of questions",
+    ]);
+  });
+
+  it("🔴 never a heading, a run-in heading, a caption, a table, or anything after the bibliography", () => {
+    expect(
+      shape(
+        "\\begin{document}\n\\section{\\textbf{Big}}\n\\textbf{Threats.} None \\emph{here}.\n\\begin{table}\\caption{\\textbf{C}}\\begin{tabular}{l}\\textbf{cell}\\end{tabular}\\end{table}\n\\bibliography{refs}\nAfter \\textbf{this}.\n\\end{document}",
+      ),
+    ).toEqual(["italic/inline: here"]);
+  });
+
+  it("braces around a label change nothing: `{\\textbf{Filtering}}.` opening a paragraph is a label", () => {
+    // barovox-acsac24, Chapters/08_Discussion.tex.
+    expect(
+      shape(
+        "\\begin{document}\n{\\textbf{Increasing the distance}}. The proximity matters.\n\\end{document}",
+      ),
+    ).toEqual(["bold/opening: Increasing the distance"]);
+  });
+});
+
+describe("bodyEmphasis — each style, and edge cases", () => {
+  /** Each phrase as `style/place: text`. */
+  const shape = (src: string): readonly string[] =>
+    bodyEmphasis(parseLatex(src)).map(
+      (e) => `${e.style}/${e.place}: ${e.text}`,
+    );
+
+  it("each style: \\emph and \\textit italic, \\underline underline, a `{\\bfseries …}` group bold; a footnote's phrase counts", () => {
+    expect(
+      shape(
+        "\\begin{document}\nA \\emph{b} c \\textit{d} e \\underline{f} g {\\bfseries h i} j.\\footnote{In \\textbf{k}.}\n\\end{document}",
+      ),
+    ).toEqual([
+      "italic/inline: b",
+      "italic/inline: d",
+      "underline/inline: f",
+      "bold/inline: h i",
+      "bold/inline: k",
+    ]);
+  });
+
+  it("an empty bold macro sets nothing apart, opening a paragraph or not", () => {
+    expect(
+      shape(
+        "\\begin{document}\n\\textbf{} Opens. We \\textbf{ } go.\n\\end{document}",
+      ),
+    ).toEqual([]);
+  });
+
+  it("an environment opening a paragraph opens nothing for the phrases inside it", () => {
+    expect(
+      shape(
+        "\\begin{document}\n\\begin{quote}\nWe say \\textbf{this}.\n\\end{quote}\n\\end{document}",
+      ),
+    ).toEqual(["bold/inline: this"]);
+  });
+
+  it("the span is the macro with its argument, where the source has it", () => {
+    const src = "\\begin{document}\nWe \\textbf{see it}.\n\\end{document}";
+    const [e] = bodyEmphasis(parseLatex(src));
+    expect(e && src.slice(e.span.start, e.span.end)).toBe("\\textbf{see it}");
+  });
+});

package/src/adapters/latex/index.ts

@@ -29,8 +29,9 @@ import {
 import { documentBodyOf, includesOf } from "./includes.ts";
 import { outlineOf } from "./outline.ts";
 import { parseLatex } from "./parse.ts";
-import { bodyProse } from "./prose.ts";
+import { bodyEmphasis, bodyProse } from "./prose.ts";
 import { renderedRuns } from "./rendered.ts";
+import { layoutOverridesOf } from "./layout.ts";
 
 export {
   documentClassOf,
@@ -49,8 +50,9 @@ export {
 export { documentBodyOf, includesOf } from "./includes.ts";
 export { outlineOf } from "./outline.ts";
 export { parseLatex, type ParsedTex } from "./parse.ts";
-export { bodyProse } from "./prose.ts";
+export { bodyEmphasis, 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 = {
@@ -58,8 +60,10 @@ export const latexReader: LatexReader = {
   outline: (src) => outlineOf(parseLatex(src)),
   renderedRuns: (src) => renderedRuns(parseLatex(src)),
   bodyProse: (src) => bodyProse(parseLatex(src)),
+  bodyEmphasis: (src) => bodyEmphasis(parseLatex(src)),
   includes: (src) => includesOf(parseLatex(src)),
   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/adapters/latex/prose.ts

@@ -14,10 +14,18 @@
  * own passage; one that cites or links leaves a citation mark in the sentence it hangs from.
  */
 import type * as Ast from "@unified-latex/unified-latex-types";
-import { hasAtLeast, sortBy } from "remeda";
-import type { Owner, Passage, ProsePiece } from "../../domain/tex-document.ts";
+import { hasAtLeast, mapWithFeedback, only, sortBy, zip } from "remeda";
+import type {
+  Emphasis,
+  EmphasisStyle,
+  Owner,
+  Passage,
+  Place,
+  ProsePiece,
+} from "../../domain/tex-document.ts";
 import {
   argumentsOf,
+  collapse,
   inPlace,
   macroPlace,
   mandatory,
@@ -28,12 +36,16 @@ import {
 } from "./nodes.ts";
 import { CITATION_MACROS, DEFINITION_MACROS, type ParsedTex } from "./parse.ts";
 
-/** What the walk yields: a piece, the end of a passage, the start of the back matter, a footnote. */
+/**
+ * What the walk yields: a piece, the end of a passage, the start of the back matter, a footnote, and
+ * an emphasised phrase — which stands beside the pieces it typesets, and makes no passage of its own.
+ */
 type Event =
   | { readonly kind: "piece"; readonly piece: ProsePiece }
   | { readonly kind: "break" }
   | { readonly kind: "end" }
-  | { readonly kind: "aside"; readonly events: readonly Event[] };
+  | { readonly kind: "aside"; readonly events: readonly Event[] }
+  | { readonly kind: "emphasis"; readonly emphasis: Emphasis };
 
 const BREAK: Event = { kind: "break" };
 const END: Event = { kind: "end" };
@@ -251,6 +263,75 @@ const OWN_EVENTS: ReadonlyMap<
   ],
 ]);
 
+/** Formatting macros that set their argument apart from the running text, and how. */
+const EMPHASIS_MACROS: ReadonlyMap<string, EmphasisStyle> = new Map([
+  ["textbf", "bold"],
+  ["emph", "italic"],
+  ["textit", "italic"],
+  ["textsl", "italic"],
+  ["underline", "underline"],
+  ["uline", "underline"],
+]);
+
+/**
+ * Declarations that set the rest of their group apart — `{\bfseries …}`, `{\em …}` — and how. The
+ * group is the phrase.
+ */
+const EMPHASIS_DECLARATIONS: ReadonlyMap<string, EmphasisStyle> = new Map([
+  ["bfseries", "bold"],
+  ["bf", "bold"],
+  ["em", "italic"],
+  ["itshape", "italic"],
+  ["it", "italic"],
+  ["slshape", "italic"],
+]);
+
+/** An emphasised phrase over `place`, typesetting what `inner` typesets; nothing when it has no place or no text. */
+const emphasisOf = (
+  style: EmphasisStyle,
+  place: Place,
+  inner: readonly Event[],
+): readonly Event[] =>
+  inPlace(place, (span) => {
+    const text = collapse(typeset(inner));
+    return text === ""
+      ? []
+      : [
+          {
+            kind: "emphasis",
+            emphasis: { style, place: "inline", text, span },
+          },
+        ];
+  });
+
+/** A formatting macro's events: what it typesets, and — for an emphasising one — the phrase. */
+function formattingEvents(t: ParsedTex, m: Macro): readonly Event[] {
+  const inner = walkList(t, lastArgument(m));
+  const style = EMPHASIS_MACROS.get(m.content);
+  return style === undefined
+    ? inner
+    : [...emphasisOf(style, macroPlace(m), inner), ...inner];
+}
+
+/** The style a group's opening declaration sets, when it opens with one (`{\bfseries …}`). */
+function declaredStyle(list: readonly Node[]): EmphasisStyle | undefined {
+  const first = list.find(
+    (n) => n.type !== "whitespace" && n.type !== "comment",
+  );
+  return first?.type === "macro"
+    ? EMPHASIS_DECLARATIONS.get(first.content)
+    : undefined;
+}
+
+/** A group's events: what it typesets, and — when it opens with an emphasis declaration — the phrase. */
+function groupEvents(t: ParsedTex, g: NodeOf<"group">): readonly Event[] {
+  const inner = walkList(t, g.content);
+  const style = declaredStyle(g.content);
+  return style === undefined
+    ? inner
+    : [...emphasisOf(style, placeOf(g), inner), ...inner];
+}
+
 function macroEvents(t: ParsedTex, m: Macro): readonly Event[] {
   const name = m.content;
   if (DEFINITION_MACROS.has(name)) return [];
@@ -260,7 +341,7 @@ function macroEvents(t: ParsedTex, m: Macro): readonly Event[] {
   const own = OWN_EVENTS.get(name);
   if (own !== undefined) return own(t, m);
   if (BREAK_MACROS.has(name)) return [BREAK];
-  if (INLINE_MACROS.has(name)) return walkList(t, lastArgument(m));
+  if (INLINE_MACROS.has(name)) return formattingEvents(t, m);
   const ch = CHARACTER_MACROS.get(name);
   return ch === undefined ? [] : characterAt(m, ch);
 }
@@ -298,7 +379,7 @@ function nodeEvents(t: ParsedTex, n: Node): readonly Event[] {
     case "whitespace":
       return textAt(n, " ");
     case "group":
-      return walkList(t, n.content);
+      return groupEvents(t, n);
     case "environment":
     case "mathenv":
       return environmentEvents(t, n);
@@ -346,20 +427,12 @@ function step(
  * macro the parser gave no signature — `\institution{…}`, `\ccsdesc[500]{…}`, `\tool{}`,
  * `\if\conference1` — which are its arguments, not text. A formatting macro's group (`\enquote{…}` without csquotes' signature) stays prose.
  */
-const proseNodes = (list: readonly Node[]): readonly Node[] =>
-  list.reduce<{
-    readonly kept: readonly Node[];
-    readonly state: ArgumentState;
-  }>(
-    (acc, n) => {
-      const next = step(acc.state, n);
-      return {
-        kept: next.skip ? acc.kept : [...acc.kept, n],
-        state: next.state,
-      };
-    },
-    { kept: [], state: "prose" },
-  ).kept;
+const proseNodes = (list: readonly Node[]): readonly Node[] => {
+  // Each node's step, fed the state the one before left: a scan, linear in the list.
+  const start: ReturnType<typeof step> = { skip: false, state: "prose" };
+  const steps = mapWithFeedback(list, (prev, n) => step(prev.state, n), start);
+  return zip(list, steps).flatMap(([n, st]) => (st.skip ? [] : [n]));
+};
 
 /** Formatting macros a run-in heading is set in: `\textbf{Correctness gate.} Each task…`. */
 const RUN_IN_MACROS: ReadonlySet<string> = new Set([
@@ -378,11 +451,33 @@ const typeset = (events: readonly Event[]): string =>
     )
     .join("");
 
-/** A formatting macro whose phrase ends in `.` or `:` — a run-in heading, when it opens a paragraph. */
-const isRunInHeading = (t: ParsedTex, n: Node): boolean =>
-  n.type === "macro" &&
-  RUN_IN_MACROS.has(n.content) &&
-  /[.:]$/u.test(typeset(walkList(t, lastArgument(n))).trim());
+/** The one node a group holds besides spaces and comments — `{\textbf{…}}` → the `\textbf` — or null. */
+const soleChild = (n: Node): Node | null => {
+  if (n.type !== "group") return null;
+  const kept = n.content.filter(
+    (c) => c.type !== "whitespace" && c.type !== "comment",
+  );
+  return only(kept) ?? null;
+};
+
+/** A node with the groups around it taken off: `{{\textbf{…}}}` → the `\textbf`. */
+const unwrapped = (n: Node): Node => {
+  const inner = soleChild(n);
+  return inner === null ? n : unwrapped(inner);
+};
+
+/**
+ * A formatting macro whose phrase ends in `.` or `:` — a run-in heading, when it opens a paragraph.
+ * Braces around it change nothing on the page, so `{\textbf{Threats:}}` is one too.
+ */
+const isRunInHeading = (t: ParsedTex, node: Node): boolean => {
+  const n = unwrapped(node);
+  return (
+    n.type === "macro" &&
+    RUN_IN_MACROS.has(n.content) &&
+    /[.:]$/u.test(typeset(walkList(t, lastArgument(n))).trim())
+  );
+};
 
 /** Macros that typeset no text, and so leave a paragraph's opening where it was. */
 const SILENT_AT_OPENING: ReadonlySet<string> = new Set([
@@ -405,28 +500,47 @@ const keepsOpening = (n: Node): boolean =>
 const opensAfter = (n: Node): boolean =>
   n.type === "parbreak" || (n.type === "macro" && BREAK_MACROS.has(n.content));
 
+/**
+ * An emphasising node's events when it opens a paragraph: its own phrase — the first event — is a
+ * label, not inline; braces around it change nothing on the page (`{\textbf{…}}.`). Any other node
+ * (an environment, a footnote) is left as it is: what it holds opens nothing here.
+ */
+const asOpening = (node: Node, events: readonly Event[]): readonly Event[] => {
+  const [own, ...rest] = events;
+  const n = unwrapped(node);
+  const emphasises =
+    (n.type === "macro" && EMPHASIS_MACROS.has(n.content)) ||
+    (n.type === "group" && declaredStyle(n.content) !== undefined);
+  return emphasises && own?.kind === "emphasis"
+    ? [
+        { kind: "emphasis", emphasis: { ...own.emphasis, place: "opening" } },
+        ...rest,
+      ]
+    : events;
+};
+
 /**
  * A list's events. `opens` says the list starts a paragraph (the body, an environment's content);
- * a run-in heading that opens a paragraph ends the passage before it and is left out, like a heading.
+ * a run-in heading that opens a paragraph ends the passage before it and is left out, like a heading,
+ * and a phrase emphasised there is a label (`opening`).
  */
 function walkList(
   t: ParsedTex,
   list: readonly Node[],
   opens = false,
 ): readonly Event[] {
-  return proseNodes(list).reduce<{
-    readonly events: readonly Event[];
-    readonly opening: boolean;
-  }>(
-    (acc, n) => ({
-      events: [
-        ...acc.events,
-        ...(acc.opening && isRunInHeading(t, n) ? [BREAK] : nodeEvents(t, n)),
-      ],
-      opening: opensAfter(n) || (acc.opening && keepsOpening(n)),
-    }),
-    { events: [], opening: opens },
-  ).events;
+  const nodes = proseNodes(list);
+  // Whether a paragraph is open AFTER each node: a scan, so the walk stays linear in the list.
+  const after = mapWithFeedback(
+    nodes,
+    (opening, n) => opensAfter(n) || (opening && keepsOpening(n)),
+    opens,
+  );
+  return nodes.flatMap((n, i) => {
+    const opening = i === 0 ? opens : after[i - 1] === true;
+    if (!opening) return nodeEvents(t, n);
+    return isRunInHeading(t, n) ? [BREAK] : asOpening(n, nodeEvents(t, n));
+  });
 }
 
 /** The events before the back matter starts. */
@@ -437,27 +551,35 @@ const untilEnd = (events: readonly Event[]): readonly Event[] => {
 
 /** Events → passages: pieces between breaks, each footnote a passage of its own. */
 function passagesOf(events: readonly Event[]): readonly Passage[] {
-  const { done, current } = events.reduce<{
-    readonly done: readonly (readonly ProsePiece[])[];
-    readonly current: readonly ProsePiece[];
-  }>(
-    (acc, e) =>
-      e.kind === "piece"
-        ? { done: acc.done, current: [...acc.current, e.piece] }
-        : e.kind === "break"
-          ? { done: [...acc.done, acc.current], current: [] }
-          : acc,
-    { done: [], current: [] },
+  // Where each passage starts and ends: between breaks. Slicing between them keeps this linear in
+  // the events — a paragraph of thousands of words is one slice, not a copy per word.
+  const breaks = events.flatMap((e, i) => (e.kind === "break" ? [i] : []));
+  const bounds = zip(
+    [0, ...breaks.map((b) => b + 1)],
+    [...breaks, events.length],
   );
+  const own = bounds.flatMap(([from, to]) => {
+    const pieces = events
+      .slice(from, to)
+      .flatMap((e) => (e.kind === "piece" ? [e.piece] : []));
+    return hasAtLeast(pieces, 1) ? [{ pieces }] : [];
+  });
   const asides = events.flatMap((e) =>
     e.kind === "aside" ? passagesOf(untilEnd(e.events)) : [],
   );
-  const own = [...done, current].flatMap((pieces) =>
-    hasAtLeast(pieces, 1) ? [{ pieces }] : [],
-  );
   return [...own, ...asides];
 }
 
+/** Every emphasised phrase among events, a footnote's included, up to the back matter. */
+const emphasesOf = (events: readonly Event[]): readonly Emphasis[] =>
+  untilEnd(events).flatMap((e) =>
+    e.kind === "emphasis"
+      ? [e.emphasis]
+      : e.kind === "aside"
+        ? emphasesOf(e.events)
+        : [],
+  );
+
 const isDocument = (n: Node): n is Readonly<Ast.Environment> =>
   n.type === "environment" && n.env === "document";
 
@@ -476,9 +598,17 @@ const startOf = (p: Passage): number => {
  * source when there is none), up to the first back-matter node.
  */
 export function bodyProse(t: ParsedTex): readonly Passage[] {
-  const body = t.root.content.find(isDocument)?.content ?? t.root.content;
-  return sortBy(
-    passagesOf(untilEnd(walkList(t, body, true))).filter(hasProse),
-    startOf,
-  );
+  return sortBy(passagesOf(untilEnd(bodyEvents(t))).filter(hasProse), startOf);
+}
+
+/** The walk of the body: the content of the `document` environment, or the whole source when there is none. */
+const bodyEvents = (t: ParsedTex): readonly Event[] =>
+  walkList(t, t.root.content.find(isDocument)?.content ?? t.root.content, true);
+
+/**
+ * The phrases set in bold, italics or underline inside the body's prose, in document order: what
+ * `bodyProse` reads, so never a heading, a run-in heading, a caption, a float or a table.
+ */
+export function bodyEmphasis(t: ParsedTex): readonly Emphasis[] {
+  return sortBy(emphasesOf(bodyEvents(t)), (e) => e.span.start);
 }

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