paperlint 6.0.0 → 6.1.0

package/src/register-bands.test.ts

@@ -0,0 +1,327 @@
+/**
+ * The register band rules on REAL papers — the accepted ones in `fixtures/accepted-papers/`, and
+ * variants derived from their sources, one change each:
+ *
+ * - every anchor the AIDC preset records is re-measured from its fixture and must equal the preset's
+ *   numbers, so a counter cannot change without the anchors (and so the band) changing with it;
+ * - every accepted ACSAC paper stands inside AIDC's band on every measure — a rule that fires on a
+ *   paper the venue accepted is wrong about the venue;
+ * - a variant that adds contrast frames, sets numbers in bold, or strips the relation markers from
+ *   one of those papers leaves the band on exactly that measure.
+ *
+ * `judgeBand` itself, on constructed measures: both ends, the floor of words, and what it reports.
+ */
+import { readdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { latexReader } from "./adapters/latex/index.ts";
+import { nodeFiles } from "./adapters/node/index.ts";
+import {
+  bandOf,
+  rateOf,
+  REGISTER_MEASURES,
+  type Band,
+  type RegisterAnchor,
+  type RegisterMeasureName,
+} from "./domain/register.ts";
+import { presetsDir } from "./package-dirs.ts";
+import { resolvePreset } from "./presets.ts";
+import { MIN_WORDS } from "./register.ts";
+import {
+  anchorOf,
+  judgeBand,
+  measureBody,
+  registerBandRules,
+  standingOf,
+} from "./register-bands.ts";
+import { readPaper } from "./tex-paper.ts";
+import { useTempDir, writeTree } from "../test/support.ts";
+
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const CORPUS = join(ROOT, "fixtures", "accepted-papers");
+
+/** The AIDC preset, resolved as a paper extending it would resolve it. */
+const aidc = (() => {
+  const r = resolvePreset(
+    "paperlint:aidc",
+    join(ROOT, "papers", "p", "paperlint.json"),
+    { files: nodeFiles, venuesDir: presetsDir() },
+  );
+  if (!r.ok) throw new Error(JSON.stringify(r.error));
+  return r.value;
+})();
+
+/** A fixture paper's text, its includes spliced, as the rules read it. */
+const sourceOf = (paper: string): string => {
+  const file = join(CORPUS, paper, "paper.tex");
+  return readPaper(file, readFileSync(file, "utf8"), {
+    files: nodeFiles,
+    latex: latexReader,
+  }).text;
+};
+
+const measured = new Map<string, RegisterAnchor>();
+/** A fixture paper measured the way an anchor is (cached: each parse costs a second). */
+const anchorFor = (paper: string, src = sourceOf(paper)): RegisterAnchor => {
+  const key = `${paper}\n${src}`;
+  const hit = measured.get(key);
+  if (hit) return hit;
+  const a = anchorOf(paper, src, latexReader);
+  measured.set(key, a);
+  return a;
+};
+
+/** Where each measure of a paper stands against AIDC's band. */
+const standings = (
+  a: RegisterAnchor,
+): Readonly<Record<RegisterMeasureName, string>> => {
+  const at = (m: RegisterMeasureName): string => {
+    const band = bandOf(aidc.registerAnchors, m);
+    return band === null
+      ? "no band"
+      : standingOf(rateOf(a.counts[m], a.words), band);
+  };
+  return {
+    contrast_frames: at("contrast_frames"),
+    claim_emphasis: at("claim_emphasis"),
+    relation_markers: at("relation_markers"),
+  };
+};
+
+const WITHIN = {
+  contrast_frames: "within",
+  claim_emphasis: "within",
+  relation_markers: "within",
+};
+
+const ACSAC = readdirSync(CORPUS).filter((d) => /acsac\d\d$/u.test(d));
+
+/** Parsing a real paper takes a second or more, several under coverage with every suite running. */
+const PAPER_TIMEOUT_MS = 60_000;
+
+describe("AIDC's anchors are the accepted ACSAC papers, as the counters measure them today", () => {
+  it("🔴 the preset records every ACSAC paper of the corpus, and nothing else", () => {
+    expect(aidc.registerAnchors.map((a) => a.paper).sort()).toEqual(
+      [...ACSAC].sort(),
+    );
+  });
+
+  it.each(aidc.registerAnchors.map((a) => [a.paper, a] as const))(
+    "🔴 %s: words and every count equal the fixture's, re-measured",
+    { timeout: PAPER_TIMEOUT_MS },
+    (paper, recorded) => {
+      expect(anchorFor(paper)).toEqual(recorded);
+    },
+  );
+});
+
+describe("every accepted ACSAC paper stands inside AIDC's band on every measure", () => {
+  it.each(ACSAC)("%s", { timeout: PAPER_TIMEOUT_MS }, (paper) => {
+    expect(standings(anchorFor(paper))).toEqual(WITHIN);
+  });
+});
+
+/** `src` with the first `n` matches of `re` after `\begin{document}` rewritten by `to`. */
+function inBody(
+  src: string,
+  re: RegExp,
+  to: (match: string) => string,
+  n: number,
+): string {
+  const start = src.indexOf("\\begin{document}");
+  const matches = new Set(
+    [...src.slice(start).matchAll(re)].slice(0, n).map((m) => m.index + start),
+  );
+  return src.replace(re, (m: string, ...rest: readonly unknown[]) => {
+    const at = rest.find((x) => typeof x === "number");
+    return typeof at === "number" && matches.has(at) ? to(m) : m;
+  });
+}
+
+/** The markers `tex/relation-markers` counts, as a writer who leaves the relation to the reader drops them. */
+const ADVERBIAL =
+  /\b(?:however|therefore|thus|hence|consequently|as a result|in contrast|specifically|for example|for instance|in particular),\s*/giu;
+
+describe("variants of real accepted papers, one change each, leave the band on that measure only", () => {
+  it(
+    "🔴 secure-acsac24 with a contrast frame after 20 mentions of the model: contrast frames above",
+    { timeout: PAPER_TIMEOUT_MS },
+    () => {
+      const src = inBody(
+        sourceOf("secure-acsac24"),
+        /\bthe model\b/gu,
+        () => "the model, not the prompt",
+        20,
+      );
+      expect(standings(anchorFor("secure-acsac24", src))).toEqual({
+        ...WITHIN,
+        contrast_frames: "above",
+      });
+    },
+  );
+
+  it(
+    "🔴 llm-splained-acsac25 with its first 20 percentages set in bold: claims in bold above",
+    { timeout: PAPER_TIMEOUT_MS },
+    () => {
+      const src = inBody(
+        sourceOf("llm-splained-acsac25"),
+        /\b\d+(?:\.\d+)?\\%/gu,
+        (m) => `\\textbf{${m}}`,
+        20,
+      );
+      expect(standings(anchorFor("llm-splained-acsac25", src))).toEqual({
+        ...WITHIN,
+        claim_emphasis: "above",
+      });
+    },
+  );
+
+  it(
+    "🔴 rr-dataset-quality-acsac24 with its relations left to the reader: relation markers below",
+    { timeout: PAPER_TIMEOUT_MS },
+    () => {
+      // One change: the sentence adverbials that name a relation are dropped, and «because» becomes
+      // «as» — the same claims, the relation between them no longer named.
+      const dropped = inBody(
+        sourceOf("rr-dataset-quality-acsac24"),
+        ADVERBIAL,
+        () => "",
+        Number.POSITIVE_INFINITY,
+      );
+      const src = inBody(
+        dropped,
+        /\bbecause\b/gu,
+        () => "as",
+        Number.POSITIVE_INFINITY,
+      );
+      expect(standings(anchorFor("rr-dataset-quality-acsac24", src))).toEqual({
+        ...WITHIN,
+        relation_markers: "below",
+      });
+    },
+  );
+});
+
+describe("judgeBand — a body's rate against a band", () => {
+  const band: Band = {
+    min: 20,
+    max: 10_000 * (5 / MIN_WORDS),
+    anchorMin: 30,
+    anchorMax: 20,
+    anchors: 5,
+  };
+  const occurrence = (i: number) => ({
+    match: `m${String(i)}`,
+    sentence: `s${String(i)}`,
+    at: { start: i, end: i + 1 },
+  });
+  const body = (n: number, words = MIN_WORDS) => ({
+    words,
+    occurrences: Array.from({ length: n }, (_, i) => occurrence(i)),
+    at: { start: 0, end: 1 },
+  });
+  const ids = (n: number, each = true, words = MIN_WORDS) =>
+    judgeBand(body(n, words), band, "aidc", each).map((f) => f.messageId);
+
+  it("inside the band, including its edges, nothing", () => {
+    expect(ids(5)).toEqual([]);
+    expect(ids(4)).toEqual([]);
+  });
+
+  it("🔴 above it: one finding for the body, then one at every occurrence", () => {
+    expect(ids(6)).toEqual([
+      "above",
+      ...Array.from({ length: 6 }, () => "each"),
+    ]);
+    expect(ids(6, false)).toEqual(["above"]);
+  });
+
+  it("🔴 below it: one finding for the body, never one per occurrence", () => {
+    expect(ids(3)).toEqual(["below"]);
+  });
+
+  it("under the floor of words, or without a band, nothing", () => {
+    expect(ids(1, true, MIN_WORDS - 1)).toEqual([]);
+    expect(judgeBand(body(99), null, "aidc", true)).toEqual([]);
+  });
+
+  it("the finding names the count, the rate, the band, the anchors' range and the first examples", () => {
+    const [f] = judgeBand(body(6), band, "aidc", true);
+    expect(f?.data).toMatchObject({
+      count: 6,
+      rate: "30.0",
+      min: "20.0",
+      max: "25.0",
+      anchors: 5,
+      venue: "aidc",
+      examples: "«s0», «s1», «s2»",
+    });
+  });
+});
+
+describe("the measures a preset may set a band for", () => {
+  it("each of them is recorded for every anchor", () => {
+    aidc.registerAnchors.forEach((a) => {
+      expect(Object.keys(a.counts).sort()).toEqual(
+        [...REGISTER_MEASURES].sort(),
+      );
+    });
+  });
+});
+
+describe("the rules, as ESLint calls them", () => {
+  /** A paper directory extending `extends`, and what one rule reports on its paper.tex. */
+  const reported = (
+    rule: "contrast-frames" | "claim-emphasis" | "relation-markers",
+    src: string,
+    file = "paper.tex",
+  ): string[] => {
+    const dir = writeTree(useTempDir("paperlint-register-bands-"), {
+      "paperlint.json": JSON.stringify({ extends: "paperlint:aidc" }),
+    });
+    const seen: string[] = [];
+    const deps = {
+      files: nodeFiles,
+      venuesDir: presetsDir(),
+      latex: latexReader,
+    };
+    registerBandRules(deps)
+      [rule].create({
+        filename: join(dir, file),
+        // No `raw`: the rule falls back to the text ESLint gives every language.
+        sourceCode: {
+          text: src,
+          getLocFromIndex: () => ({ line: 1, column: 0 }),
+        },
+        report: (d) => {
+          seen.push("messageId" in d ? d.messageId : d.message);
+        },
+      })
+      .root?.();
+    return seen;
+  };
+  const LONG = `\\documentclass{article}\n\\begin{document}\n${Array.from(
+    { length: 200 },
+    () =>
+      "The rule reads the body of the paper and counts every sentence it holds.",
+  ).join(" ")}\n\\end{document}\n`;
+
+  it("🔴 reads the paper's text when the language gives no raw source", () => {
+    expect(reported("relation-markers", LONG)).toEqual(["below"]);
+  });
+
+  it("judges a paper once, on its paper.tex, and nothing else", () => {
+    expect(reported("relation-markers", LONG, "intro.tex")).toEqual([]);
+  });
+
+  it("an empty body is measured as no words, reported nowhere", () => {
+    const m = measureBody(
+      "contrast-frames",
+      "\\documentclass{article}\n\\begin{document}\n\\end{document}\n",
+      latexReader,
+    );
+    expect(m).toEqual({ words: 0, occurrences: [], at: null });
+  });
+});

package/src/register-bands.ts

@@ -0,0 +1,291 @@
+/**
+ * THE REGISTER RULES THAT MEASURE A BODY AGAINST ITS VENUE'S ACCEPTED PAPERS — each a rate per
+ * 10,000 words, judged against the band the venue preset's anchors set (`src/domain/register.ts`):
+ *
+ *   tex/contrast-frames   warn  «X, not Y», «rather than», «instead of» … outside the band; above it,
+ *                               each frame is reported where it stands
+ *   tex/claim-emphasis    warn  claims set in bold inside a sentence outside the band; above it, each
+ *                               is reported where it stands
+ *   tex/relation-markers  warn  words naming how a sentence relates to the one before (because,
+ *                               therefore, however, for example …) outside the band
+ *
+ * ── WHY ──────────────────────────────────────────────────────────────────────────
+ * Reviewers called a paper "too informal" and "a blogpost". Its text differed from the accepted
+ * papers of the venue's parent conference in exactly these three counts, each several times over
+ * the anchors' range, while sentence length, contractions, questions and the second person did not
+ * separate them. The measurements are on the rules' pages.
+ *
+ * ── TWO-SIDED, AND THE VENUE'S OWN ───────────────────────────────────────────────
+ * Every rule judges both ends of its band: a rewrite that strips every relation marker is as far
+ * from the venue as one that stacks contrast frames. The band is the venue preset's, derived from
+ * its anchors, so a venue with other accepted papers gets another band, and a preset without
+ * anchors is not judged — there is nothing to compare, as `tex/template` is silent for a preset that
+ * names no template. A body under `MIN_WORDS` is not judged either: one sentence would decide it.
+ */
+import { basename, dirname } from "node:path";
+import {
+  bandOf,
+  bodySentences,
+  claimEmphasis,
+  contrastFrames,
+  rateOf,
+  relationMarkers,
+  wordsOf,
+  type Band,
+  type Occurrence,
+  type RegisterAnchor,
+  type RegisterMeasureName,
+} from "./domain/register.ts";
+import type { Emphasis, Passage, Span } from "./domain/tex-document.ts";
+import type { LatexReader } from "./ports/latex.ts";
+import { paperPreset } from "./presets.ts";
+import { MIN_WORDS, startOf } from "./register.ts";
+import { readPaper, reportInPaper } from "./tex-paper.ts";
+import {
+  ruleDocsUrl,
+  type Located,
+  type TexRuleContext,
+  type TexRuleModule,
+} from "./tex-venue-rules.ts";
+import type { VenueRuleDeps } from "./venue-rules.ts";
+
+/** What the three rules read: the preset store, and the LaTeX reader. */
+export interface RegisterBandDeps extends VenueRuleDeps {
+  readonly latex: LatexReader;
+}
+
+export type RegisterBandRuleName =
+  "contrast-frames" | "claim-emphasis" | "relation-markers";
+
+/** What one body measures for one rule: its words, the occurrences, where the body starts. */
+export interface BodyMeasure {
+  readonly words: number;
+  readonly occurrences: readonly Occurrence[];
+  readonly at: Span | null;
+}
+
+/** How a rate stands against a band. */
+export type Standing = "below" | "within" | "above";
+
+export const standingOf = (rate: number, band: Band): Standing =>
+  rate < band.min ? "below" : rate > band.max ? "above" : "within";
+
+const fixed = (n: number): string => n.toFixed(1);
+
+/** How many examples a finding about the whole body quotes. */
+const EXAMPLES = 3;
+
+/** What every message about a body names: its count and rate, the band, the anchors' range, examples. */
+function dataOf(
+  m: BodyMeasure,
+  band: Band,
+  venue: string,
+): Readonly<Record<string, string | number>> {
+  return {
+    count: m.occurrences.length,
+    words: m.words,
+    rate: fixed(rateOf(m.occurrences.length, m.words)),
+    venue,
+    min: fixed(band.min),
+    max: fixed(band.max),
+    anchors: band.anchors,
+    anchorMin: fixed(band.anchorMin),
+    anchorMax: fixed(band.anchorMax),
+    examples: m.occurrences
+      .slice(0, EXAMPLES)
+      .map((o) => `«${o.sentence}»`)
+      .join(", "),
+  };
+}
+
+/**
+ * A body against a band: nothing within it; outside it, one finding at the body's start naming the
+ * count, the rate, the band and the anchors' range — and, above it when `each` is set, one finding
+ * at every occurrence, so an editor shows the author where to rewrite.
+ */
+export function judgeBand(
+  m: BodyMeasure,
+  band: Band | null,
+  venue: string,
+  each: boolean,
+): readonly Located[] {
+  if (band === null || m.words < MIN_WORDS) return [];
+  const standing = standingOf(rateOf(m.occurrences.length, m.words), band);
+  if (standing === "within") return [];
+  const data = dataOf(m, band, venue);
+  const whole: Located = { messageId: standing, data, at: m.at };
+  if (standing === "below" || !each) return [whole];
+  const at = (o: Occurrence, i: number): Located => ({
+    messageId: "each",
+    data: { ...data, match: o.match, index: i + 1 },
+    at: o.at,
+  });
+  return [whole, ...m.occurrences.map(at)];
+}
+
+/** The band words every message shares: the rate, and where the venue's anchors put it. */
+const AGAINST =
+  "{{rate}} per 10,000 words; {{venue}}'s {{anchors}} anchor papers measure {{anchorMin}}–{{anchorMax}}, and this rule warns outside {{min}}–{{max}}";
+
+/** The body as the measures read it: its prose, and the phrases emphasised in it (read on demand). */
+interface Body {
+  readonly passages: readonly Passage[];
+  readonly emphasis: () => readonly Emphasis[];
+}
+
+/** What each rule counts, how it reads the paper, and what it says. */
+interface Measure {
+  readonly name: RegisterMeasureName;
+  readonly description: string;
+  /** Above the band, report every occurrence where it stands. */
+  readonly each: boolean;
+  readonly count: (body: Body) => readonly Occurrence[];
+  readonly messages: Readonly<Record<string, string>>;
+}
+
+const MEASURES: Readonly<Record<RegisterBandRuleName, Measure>> = {
+  "contrast-frames": {
+    name: "contrast_frames",
+    description:
+      "contrast frames («X, not Y», «rather than», «instead of») stay within the rate the venue's accepted papers show",
+    each: true,
+    count: (b) => contrastFrames(bodySentences(b.passages)),
+    messages: {
+      above: `{{count}} contrast frames («X, not Y», «not X but Y», «rather than», «instead of», «as opposed to») — ${AGAINST}. First: {{examples}}. Say what the thing is and why, with the evidence; keep a frame only where a reader would otherwise assume the rejected alternative`,
+      below: `{{count}} contrast frames — ${AGAINST}. A rewrite may have dropped relations the argument needs: check that each claim still says what it is set against`,
+      each: "contrast frame «{{match}}» ({{index}} of {{count}}; the body is at {{rate}} per 10,000 words, above {{venue}}'s {{max}})",
+    },
+  },
+  "claim-emphasis": {
+    name: "claim_emphasis",
+    description:
+      "claims set in bold inside a sentence stay within the rate the venue's accepted papers show",
+    each: true,
+    count: (b) => claimEmphasis(b.emphasis()),
+    messages: {
+      above: `{{count}} claims set in bold inside a sentence (a bold phrase of six words or more, or holding a number) — ${AGAINST}. First: {{examples}}. Accepted papers set a term or a label in bold; take the bold off a finding and let the sentence, a table or a figure carry it`,
+      below: `{{count}} claims set in bold inside a sentence — ${AGAINST}`,
+      each: "a claim set in bold, «{{match}}» ({{index}} of {{count}}; the body is at {{rate}} per 10,000 words, above {{venue}}'s {{max}})",
+    },
+  },
+  "relation-markers": {
+    name: "relation_markers",
+    description:
+      "words that name how a sentence relates to the one before (because, therefore, however, for example) stay within the rate the venue's accepted papers show",
+    each: false,
+    count: (b) => relationMarkers(bodySentences(b.passages)),
+    messages: {
+      below: `{{count}} words name how a sentence relates to the one before (because, therefore, however, in contrast, for example, that is …) — ${AGAINST}. Where two sentences stand side by side, say whether the second is the cause, the consequence, an example or a limit of the first`,
+      above: `{{count}} relation markers — ${AGAINST}. First: {{examples}}`,
+    },
+  },
+};
+
+/** What a body measures for a rule: its words, its occurrences, and where it starts. */
+export function measureBody(
+  rule: RegisterBandRuleName,
+  src: string,
+  latex: LatexReader,
+): BodyMeasure {
+  const passages = latex.bodyProse(src);
+  const [first] = passages;
+  const body: Body = { passages, emphasis: () => latex.bodyEmphasis(src) };
+  return {
+    words: wordsOf(bodySentences(passages)),
+    occurrences: MEASURES[rule].count(body),
+    at: first === undefined ? null : startOf(first),
+  };
+}
+
+/** Which rule counts each measure an anchor records. */
+const RULE_OF: Readonly<Record<RegisterMeasureName, RegisterBandRuleName>> = {
+  contrast_frames: "contrast-frames",
+  claim_emphasis: "claim-emphasis",
+  relation_markers: "relation-markers",
+};
+
+/**
+ * A paper as a preset records it among its anchors: its body's words and its count of every
+ * measure, by the rules' own counters — the one way an anchor is measured.
+ */
+export function anchorOf(
+  paper: string,
+  src: string,
+  latex: LatexReader,
+): RegisterAnchor {
+  const passages = latex.bodyProse(src);
+  const body: Body = { passages, emphasis: () => latex.bodyEmphasis(src) };
+  const count = (m: RegisterMeasureName): number =>
+    MEASURES[RULE_OF[m]].count(body).length;
+  return {
+    paper,
+    words: wordsOf(bodySentences(passages)),
+    counts: {
+      contrast_frames: count("contrast_frames"),
+      claim_emphasis: count("claim_emphasis"),
+      relation_markers: count("relation_markers"),
+    },
+  };
+}
+
+/** The findings for the paper whose `paper.tex` is `filename`; none when its preset has no anchors. */
+function judgePaper(
+  name: RegisterBandRuleName,
+  context: TexRuleContext,
+  deps: RegisterBandDeps,
+): void {
+  const p = paperPreset(dirname(context.filename), deps);
+  if (p.kind !== "resolved") return;
+  const measure = MEASURES[name];
+  const band = bandOf(p.preset.registerAnchors, measure.name);
+  if (band === null) return;
+  const sc = context.sourceCode;
+  const paper = readPaper(context.filename, sc.raw ?? sc.text, deps);
+  const m = measureBody(name, paper.text, deps.latex);
+  const findings = judgeBand(m, band, p.preset.label, measure.each);
+  reportInPaper(context, measure.messages, paper, findings);
+}
+
+function rule(
+  name: RegisterBandRuleName,
+  deps: RegisterBandDeps,
+): TexRuleModule {
+  const measure = MEASURES[name];
+  return {
+    meta: {
+      type: "suggestion",
+      docs: { description: measure.description, url: ruleDocsUrl(name) },
+      schema: [],
+      messages: measure.messages,
+    },
+    create(context) {
+      // Judged once per paper, on its paper.tex: the paper directory is the file's directory.
+      if (basename(context.filename) !== "paper.tex") return {};
+      return {
+        root: () => {
+          judgePaper(name, context, deps);
+        },
+      };
+    },
+  };
+}
+
+/** The three rules, as rules of the `tex` plugin. */
+export function registerBandRules(
+  deps: RegisterBandDeps,
+): Readonly<Record<RegisterBandRuleName, TexRuleModule>> {
+  return {
+    "contrast-frames": rule("contrast-frames", deps),
+    "claim-emphasis": rule("claim-emphasis", deps),
+    "relation-markers": rule("relation-markers", deps),
+  };
+}
+
+/** The level each rule is on at in paperlint's own config, for every `paper.tex`. */
+export const REGISTER_BAND_RULE_LEVELS: Readonly<
+  Record<`tex/${RegisterBandRuleName}`, "warn">
+> = {
+  "tex/contrast-frames": "warn",
+  "tex/claim-emphasis": "warn",
+  "tex/relation-markers": "warn",
+};

package/src/register.ts

@@ -15,8 +15,8 @@
  * (src/domain/sentences.ts). A citation, a cross-reference or math reads as one word, as it does on
  * the page. A body under 2 000 words is not judged: there one sentence decides the rate.
  */
-import { runText, type Passage, type Span } from "./domain/tex-document.ts";
-import { runOf, sentences } from "./domain/sentences.ts";
+import type { Passage, Span } from "./domain/tex-document.ts";
+import { bodySentences, wordsOf } from "./domain/register.ts";
 import { readPaper, reportInPaper, type PaperDeps } from "./tex-paper.ts";
 import {
   ruleDocsUrl,
@@ -24,7 +24,7 @@ import {
   type TexRuleModule,
 } from "./tex-venue-rules.ts";
 
-/** Under this many words in the body, the rate is not judged. */
+/** Under this many words in the body, a rate is not judged: one sentence would decide it. */
 export const MIN_WORDS = 2000;
 
 /** The limit when the config sets none, from the measurement on the rule's page. */
@@ -40,30 +40,6 @@ const CONJUNCTIONS: ReadonlySet<string> = new Set([
   "Yet",
 ]);
 
-/** The characters a mark or math stands as in a sentence's text (src/domain/sentences.ts). */
-const MARK = /[-]/gu;
-
-const WORDS = new Intl.Segmenter("en", { granularity: "word" });
-
-/** A sentence as the rate sees it: its text, its words, and its first word. */
-interface Sentence {
-  readonly text: string;
-  readonly words: number;
-  readonly first: string;
-}
-
-/** A sentence's words: the word-like ones, and one for each mark or math. Null when it has none of its own. */
-function sentenceOf(text: string): Sentence | null {
-  const words = [...WORDS.segment(text)].filter((w) => w.isWordLike);
-  const [first] = words;
-  if (first === undefined) return null;
-  return {
-    text: text.replace(MARK, "").replace(/\s+/gu, " ").trim(),
-    words: words.length + (text.match(MARK)?.length ?? 0),
-    first: first.segment,
-  };
-}
-
 /** What the body measures. */
 export interface RegisterMeasure {
   readonly words: number;
@@ -74,8 +50,8 @@ export interface RegisterMeasure {
   readonly at: Span | null;
 }
 
-/** Where a passage's first piece stands. */
-function startOf(p: Passage): Span {
+/** Where a passage's first piece stands: where a finding about the whole body points. */
+export function startOf(p: Passage): Span {
   const first = p.pieces[0];
   return first.kind === "text"
     ? {
@@ -87,17 +63,11 @@ function startOf(p: Passage): Span {
 
 /** The body's words, and its sentences that open with a conjunction. */
 export function measureRegister(passages: readonly Passage[]): RegisterMeasure {
-  const all = passages.flatMap((p) => {
-    const text = runText(runOf(p));
-    return sentences(text).flatMap(([from, to]) => {
-      const s = sentenceOf(text.slice(from, to));
-      return s === null ? [] : [s];
-    });
-  });
+  const all = bodySentences(passages);
   const conj = all.filter((s) => CONJUNCTIONS.has(s.first));
   const [first] = passages;
   return {
-    words: all.reduce((n, s) => n + s.words, 0),
+    words: wordsOf(all),
     conjunctionStarts: conj.length,
     examples: conj.slice(0, 3).map((s) => s.text),
     at: first === undefined ? null : startOf(first),