paperlint 4.0.0 → 4.2.0

package/src/tex-venue-rules.ts

@@ -0,0 +1,461 @@
+/**
+ * THE VENUE-CONFORMANCE RULES OVER THE SOURCE — `paper.tex` judged against what its venue preset
+ * requires of the LaTeX itself, before any build:
+ *
+ *   tex/template          error  the `\documentclass` is the preset's class, with every option it names
+ *   tex/required-section  error  each section the preset requires is there, titled exactly, and
+ *                                where the preset says (`last`: after every section of the body)
+ *   tex/venue-leftover    warn   the text a reader sees names ANOTHER shipped venue — its `name`
+ *                                or one of its `aliases` — than the one the paper extends
+ *
+ * ── WHY THEY LIVE HERE AND NOT IN `eslint-rules/` ────────────────────────────────
+ * Like the `pdf/*` venue rules (`venue-rules.ts`), they need the paper's resolved preset —
+ * `paperPreset`, the one answer to "which venue is this paper judged against" — and read it through
+ * the `Files` port. What they read of the source comes through the `LatexReader` port
+ * (`src/ports/latex.ts`, implemented over unified-latex in `src/adapters/latex/`): the parse tree of
+ * `sourceCode.raw`, never a search of the text.
+ *
+ * ── WHO SPEAKS WHEN THERE IS NOTHING TO JUDGE ───────────────────────────────────
+ * No `paperlint.json`, no `extends`, or a preset that does not resolve: silent. `pdf/measured` and
+ * `pdf/profile` already say so, once. A preset that names no template: silent — there is nothing to
+ * compare, and a template-family preset is where it is named.
+ */
+import { basename, dirname, join } from "node:path";
+import { CONFIG_FILE } from "#lib/paper-config";
+import {
+  collapse,
+  documentClassLine,
+  missingOptions,
+  runText,
+  spanIn,
+  type ClassCandidate,
+  type ClassLine,
+  type DocumentClass,
+  type Heading,
+  type Outline,
+  type Place,
+  type Span,
+  type TextRun,
+} from "./domain/tex-document.ts";
+import type { LatexReader } from "./ports/latex.ts";
+import {
+  paperPreset,
+  resolvePreset,
+  SHIPPED_PREFIX,
+  shippedPresets,
+  type Preset,
+} from "./presets.ts";
+import type { PaperSource } from "./domain/paper-source.ts";
+import { readPaper, reportInPaper } from "./tex-paper.ts";
+import type { RequiredSection } from "./tex-requirements.ts";
+import type { Finding, VenueRuleDeps } from "./venue-rules.ts";
+
+/** A finding and where it points; null points at the top of the file. */
+export interface Located extends Finding {
+  readonly at: Span | null;
+}
+
+/** The slice of ESLint's rule context these rules use. `raw` exists on the `.tex` language's. */
+export interface TexRuleContext {
+  readonly filename: string;
+  /** The rule's options from the config, as ESLint validated them against its schema. */
+  readonly options?: readonly unknown[];
+  readonly sourceCode: {
+    readonly text: string;
+    readonly raw?: string;
+    getLocFromIndex(index: number): Readonly<{ line: number; column: number }>;
+  };
+  report(
+    d: {
+      readonly loc: {
+        readonly start: { line: number; column: number };
+        readonly end: { line: number; column: number };
+      };
+    } & (
+      | {
+          readonly messageId: string;
+          readonly data?: Readonly<Record<string, string | number>>;
+        }
+      | { readonly message: string }
+    ),
+  ): void;
+}
+
+export interface TexRuleModule {
+  readonly meta: {
+    readonly type: "problem" | "suggestion";
+    readonly docs: { readonly description: string; readonly url: string };
+    readonly schema: readonly object[];
+    readonly messages: Readonly<Record<string, string>>;
+  };
+  create(context: TexRuleContext): { root?: () => void };
+}
+
+// ── the judges: what the source says + a resolved preset → findings. Pure. ─────────
+
+/** A place as a finding points at it: its span, or null — the top of the file — when unplaced. */
+const spanOf = (p: Place): Span | null => (p.kind === "at" ? p.span : null);
+
+/**
+ * What every template finding names: the venue and the class line it requires. A type alias, not an
+ * interface: a finding's `data` is a string record, and only an alias is assignable to one.
+ */
+type TemplateData = {
+  readonly venue: string;
+  readonly template: string;
+};
+
+/** A class line that names a class, against the template's: the same class, with every option. */
+function judgeClass(
+  line: Extract<ClassLine, { readonly kind: "class" }>,
+  want: DocumentClass,
+  data: TemplateData,
+): readonly Located[] {
+  const at = spanOf(line.place);
+  if (line.cls !== want.cls)
+    return [{ messageId: "wrongClass", data: { ...data, got: line.cls }, at }];
+  return missingOptions(line, want).map((option) => ({
+    messageId: "missingOption",
+    data: { ...data, option },
+    at,
+  }));
+}
+
+/** A candidate as the message names it: its line, or an empty `\documentclass{}`. */
+const candidateLine = (c: ClassCandidate): string =>
+  c.kind === "class" ? documentClassLine(c) : "\\documentclass{}";
+
+/**
+ * Several class lines behind a TeX switch: satisfied when any candidate is the template's class
+ * with its options; otherwise one finding, at the first candidate, naming every one.
+ */
+function judgeCandidates(
+  candidates: readonly [ClassCandidate, ...ClassCandidate[]],
+  want: DocumentClass,
+  data: TemplateData,
+): readonly Located[] {
+  const matches = candidates.some(
+    (c) => c.kind === "class" && judgeClass(c, want, data).length === 0,
+  );
+  if (matches) return [];
+  const named = candidates.map((c) => `\`${candidateLine(c)}\``).join(", ");
+  const found = { ...data, count: candidates.length, candidates: named };
+  return [
+    { messageId: "noCandidate", data: found, at: spanOf(candidates[0].place) },
+  ];
+}
+
+/** The paper's class line against a template that was read: present, naming a class, that class. */
+function judgeClassLine(
+  line: ClassLine,
+  want: DocumentClass,
+  data: TemplateData,
+): readonly Located[] {
+  switch (line.kind) {
+    case "missing":
+      return [{ messageId: "noClass", data, at: null }];
+    case "empty":
+      return [{ messageId: "emptyClass", data, at: spanOf(line.place) }];
+    case "class":
+      return judgeClass(line, want, data);
+    case "ambiguous":
+      return judgeCandidates(line.candidates, want, data);
+  }
+}
+
+/**
+ * The paper's class line against the preset's template: a template the reader cannot read is said
+ * once; then the class must be there, name a class, be the template's class, and carry every
+ * option the template names.
+ */
+export function judgeTemplate(
+  line: ClassLine,
+  preset: Preset,
+  latex: Pick<LatexReader, "template">,
+): readonly Located[] {
+  const t = preset.template;
+  if (t === null) return [];
+  const want = latex.template(t.text);
+  if (want === null) {
+    const data = { file: t.file, text: JSON.stringify(t.text) };
+    return [{ messageId: "badTemplate", data, at: null }];
+  }
+  const data = { venue: preset.label, template: documentClassLine(want) };
+  return judgeClassLine(line, want, data);
+}
+
+/** Where a heading starts, or null when the parser gave it no place. */
+const startOf = (p: Place): number | null =>
+  p.kind === "at" ? p.span.start : null;
+
+/** A required section that is absent, reported where the document ends — where it would go. */
+const missingSection = (
+  outline: Outline,
+  data: { readonly venue: string; readonly title: string },
+): Located => ({
+  messageId: "missing",
+  data,
+  at: outline.end === null ? null : { start: outline.end, end: outline.end },
+});
+
+/** The first section of the body that starts after `start` and is not titled `title`. */
+function bodySectionAfter(
+  outline: Outline,
+  start: number,
+  title: string,
+): Heading | undefined {
+  const backMatter = outline.backMatter ?? Number.POSITIVE_INFINITY;
+  return outline.sections.find((h) => {
+    const s = startOf(h.place);
+    return s !== null && s > start && s < backMatter && h.title !== title;
+  });
+}
+
+/**
+ * One required section against the outline: missing (reported where the document ends, where it
+ * would go), or — for `last` — standing before a section of the body. The body is every section
+ * before the appendix and the bibliography, so the required one may follow the bibliography. A
+ * heading without a place cannot be ordered, so it is never reported as out of order.
+ */
+function judgeSection(
+  outline: Outline,
+  want: RequiredSection,
+  venue: string,
+): readonly Located[] {
+  const title = collapse(want.title);
+  const last = outline.sections.filter((h) => h.title === title).at(-1);
+  const data = { venue, title };
+  if (last === undefined) return [missingSection(outline, data)];
+  const lastStart = startOf(last.place);
+  if (want.position !== "last" || lastStart === null) return [];
+  const after = bodySectionAfter(outline, lastStart, title);
+  if (after === undefined) return [];
+  const notLast = { ...data, after: after.title };
+  return [{ messageId: "notLast", data: notLast, at: spanOf(last.place) }];
+}
+
+/** Every section the preset requires, against the paper's outline. */
+export function judgeRequiredSections(
+  outline: () => Outline,
+  preset: Preset,
+): readonly Located[] {
+  if (preset.requiredSections.length === 0) return [];
+  const o = outline();
+  return preset.requiredSections.flatMap((r) =>
+    judgeSection(o, r, preset.label),
+  );
+}
+
+/** Another shipped venue: the word for it, and what it is called in a paper's text. */
+export interface OtherVenue {
+  readonly label: string;
+  readonly aliases: readonly string[];
+}
+
+/** `s` as a pattern that matches it literally. */
+const literal = (s: string): string =>
+  s.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+/**
+ * Each place the rendered text names another venue — one of its aliases as a whole word, case
+ * and all — unless that alias is also this paper's venue's own (a shared parent conference).
+ */
+export function judgeLeftover(
+  runs: readonly TextRun[],
+  preset: Preset,
+  others: readonly OtherVenue[],
+): readonly Located[] {
+  const own = new Set(preset.aliases);
+  const names = others.flatMap((o) =>
+    o.aliases
+      .filter((a) => !own.has(a))
+      .map((alias) => ({
+        other: o.label,
+        re: new RegExp(
+          `(?<![\\p{L}\\p{N}])${literal(alias)}(?![\\p{L}\\p{N}])`,
+          "gu",
+        ),
+      })),
+  );
+  return runs.flatMap((run) =>
+    names.flatMap(({ other, re }) =>
+      [...runText(run).matchAll(re)].map((m) => ({
+        messageId: "leftover",
+        data: { name: m[0], other, venue: preset.label },
+        at: spanIn(run, m.index, m.index + m[0].length),
+      })),
+    ),
+  );
+}
+
+/** Where a rule's page lives: `docs/rules/tex/<name>.md` on the default branch. */
+export const ruleDocsUrl = (
+  name: TexVenueRuleName | "claim-provenance" | "register",
+): string =>
+  `https://github.com/zernie/paperlint/blob/main/docs/rules/tex/${name}.md`;
+
+/** What a judge reads: the paper's source through the reader, its preset, the other venues. */
+interface Reading {
+  readonly src: string;
+  readonly latex: LatexReader;
+  readonly preset: Preset;
+  readonly others: () => readonly OtherVenue[];
+}
+type Judge = (r: Reading) => readonly Located[];
+
+export type TexVenueRuleName =
+  "template" | "required-section" | "venue-leftover";
+
+const RULES: Readonly<
+  Record<
+    TexVenueRuleName,
+    { readonly judge: Judge; readonly meta: TexRuleModule["meta"] }
+  >
+> = {
+  template: {
+    judge: (r) =>
+      judgeTemplate(r.latex.documentClass(r.src), r.preset, r.latex),
+    meta: {
+      type: "problem",
+      docs: {
+        description:
+          "the \\documentclass is the venue preset's class, with every option the preset names",
+        url: ruleDocsUrl("template"),
+      },
+      schema: [],
+      messages: {
+        noClass:
+          "paper.tex has no \\documentclass; {{venue}} requires `{{template}}`",
+        emptyClass:
+          "the \\documentclass names no class; {{venue}} requires `{{template}}`",
+        badTemplate:
+          '{{file}}: the preset\'s "template" {{text}} is neither a \\documentclass line nor a class name, so the class cannot be checked',
+        wrongClass:
+          "the class is `{{got}}`, and {{venue}} requires `{{template}}` — the page size, fonts and layout the venue checks come from the class",
+        missingOption:
+          "the class option `{{option}}` is missing: {{venue}} requires `{{template}}`",
+        noCandidate:
+          "none of the {{count}} \\documentclass lines is `{{template}}`, which {{venue}} requires: {{candidates}}. The source picks one behind a TeX switch, which is not evaluated; make one of them the venue's",
+      },
+    },
+  },
+  "required-section": {
+    judge: (r) => judgeRequiredSections(() => r.latex.outline(r.src), r.preset),
+    meta: {
+      type: "problem",
+      docs: {
+        description:
+          "every section the venue preset requires is there, titled exactly, and where the preset says",
+        url: ruleDocsUrl("required-section"),
+      },
+      schema: [],
+      messages: {
+        missing:
+          "{{venue}} requires a section titled «{{title}}» and there is none — add `\\section*{{{title}}}` (the title exactly; a bold paragraph does not count)",
+        notLast:
+          "«{{title}}» must close the paper at {{venue}}, and the section «{{after}}» comes after it — move it after the last section of the body (after the bibliography is fine)",
+      },
+    },
+  },
+  "venue-leftover": {
+    judge: (r) =>
+      judgeLeftover(r.latex.renderedRuns(r.src), r.preset, r.others()),
+    meta: {
+      type: "suggestion",
+      docs: {
+        description:
+          "the text names another shipped venue than the one the paper extends — a leftover from an earlier submission",
+        url: ruleDocsUrl("venue-leftover"),
+      },
+      schema: [],
+      messages: {
+        leftover:
+          "«{{name}}» names {{other}}, and this paper extends {{venue}} — a leftover from an earlier submission? A reviewer reads it before the abstract. Comments and citation keys are not reported; a sentence that names the other venue on purpose can keep it with a disable directive",
+      },
+    },
+  },
+};
+
+/** The level each rule is on at in paperlint's own config, for every `paper.tex`. */
+export const TEX_VENUE_RULE_LEVELS: Readonly<
+  Record<`tex/${TexVenueRuleName}`, "error" | "warn">
+> = {
+  "tex/template": "error",
+  "tex/required-section": "error",
+  "tex/venue-leftover": "warn",
+};
+
+/**
+ * Every shipped venue but the ones on this paper's own chain, each resolved the way a paper
+ * extending it would be. A preset that does not resolve is skipped: `pdf/profile` owns that.
+ */
+export function otherVenues(
+  preset: Preset,
+  fromFile: string,
+  deps: VenueRuleDeps,
+): readonly OtherVenue[] {
+  return shippedPresets(deps.venuesDir).flatMap((name) => {
+    const r = resolvePreset(`${SHIPPED_PREFIX}${name}`, fromFile, deps);
+    // A preset all of whose files are on this paper's chain is this venue or one it extends.
+    return r.ok && !r.value.chain.every((f) => preset.chain.includes(f))
+      ? [{ label: r.value.label, aliases: r.value.aliases }]
+      : [];
+  });
+}
+
+/** What the venue-conformance rules are built with: the preset store, and the LaTeX reader. */
+export interface TexVenueRuleDeps extends VenueRuleDeps {
+  readonly latex: LatexReader;
+}
+
+/**
+ * What a judge reads for the paper whose `paper.tex` is `filename` — the paper with its includes
+ * spliced (`readPaper`) — or null when the paper has no resolved preset (`pdf/measured` and
+ * `pdf/profile` already say so).
+ */
+function readingOf(
+  filename: string,
+  src: string,
+  deps: TexVenueRuleDeps,
+): { readonly reading: Reading; readonly paper: PaperSource } | null {
+  const dir = dirname(filename);
+  const p = paperPreset(dir, deps);
+  if (p.kind !== "resolved") return null;
+  const preset = p.preset;
+  const others = () => otherVenues(preset, join(dir, CONFIG_FILE), deps);
+  const paper = readPaper(filename, src, deps);
+  return {
+    reading: { src: paper.text, latex: deps.latex, preset, others },
+    paper,
+  };
+}
+
+function rule(name: TexVenueRuleName, deps: TexVenueRuleDeps): TexRuleModule {
+  const { judge, meta } = RULES[name];
+  return {
+    meta,
+    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() {
+          const sc = context.sourceCode;
+          const r = readingOf(context.filename, sc.raw ?? sc.text, deps);
+          if (r !== null)
+            reportInPaper(context, meta.messages, r.paper, judge(r.reading));
+        },
+      };
+    },
+  };
+}
+
+/** The venue-conformance rules, as rules of the `tex` plugin (beside `tex/future-promise`). */
+export function texVenueRules(
+  deps: TexVenueRuleDeps,
+): Readonly<Record<TexVenueRuleName, TexRuleModule>> {
+  return {
+    template: rule("template", deps),
+    "required-section": rule("required-section", deps),
+    "venue-leftover": rule("venue-leftover", deps),
+  };
+}

package/src/toolchain.harness.mjs

@@ -6,7 +6,7 @@
  * inside is `fixtures/toolchain-mirror/install-tl`, which lays out a tree whose `kpsewhich` and
  * `tlmgr` answer from two text files. So what runs is paperlint's own download, fallback, unpack,
  * install and verify logic — the part that decides success — and what is faked is only TeX.
- * The real TeX Live half is `test/e2e/toolchain.ts`.
+ * The real TeX Live half is `test/e2e/tex/toolchain.e2e.ts`.
  *
  * Tables, in order:
  *   1. the pure pieces (year, profile, tlmgr's unknown names, cache location);

package/src/venue-rules.test.ts

@@ -12,12 +12,12 @@ import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
 import { sha256Hex } from "./domain/sha256.ts";
-import { packageVenuesDir } from "../skills/paper-pipeline/scripts/consumer.mjs";
+import { presetsDir } from "./package-dirs.ts";
 import { VENUE_RULE_LEVELS, venueRules } from "./venue-rules.ts";
 import { buildConfig, OPTIONAL_RULES, SHIPPED_RULES } from "./cli.ts";
 import { present } from "../test/support.ts";
 
-const VENUES = packageVenuesDir();
+const VENUES = presetsDir();
 const PAPER = "/work/papers/p";
 const PDF_BYTES = new TextEncoder().encode(
   "%PDF-1.5 a stand-in for the built PDF",
@@ -213,13 +213,13 @@ describe("pdf/profile — the declaration must resolve, or nothing is judged", (
       "an unknown venue (a typo would silently disable every check)",
       { extends: "paperlint:agentic-dev", kind: "short" },
       "preset",
-      /agenticdev, aisec, realm/,
+      /agenticdev, aidc, aisec, ieee-conference, realm/,
     ],
     [
       "the base TeX set is not a venue",
       { extends: "paperlint:tex-base" },
       "preset",
-      /agenticdev, aisec, realm/,
+      /agenticdev, aidc, aisec, ieee-conference, realm/,
     ],
     [
       "paperlint.json that is not JSON",
@@ -560,6 +560,98 @@ describe("paperlint's own config turns the venue rules on for every paper.tex",
   });
 });
 
+/**
+ * The facts of the 13-page `[conference,compsoc]` IEEEtran paper measured for ieee-conference.jsonc
+ * (2026-09-27): banal's page, columns and sizes, pdf.js's fonts.
+ */
+/** Embedded Type 1 fonts of these names. */
+const type1 = (names: readonly string[]): Font[] =>
+  names.map((name) => ({
+    name,
+    type: "Type 1",
+    embedded: true,
+    program: "Type1",
+  }));
+
+const ieeeFacts = (patch: Patch = () => {}): Facts =>
+  withFacts((f) => {
+    f.page_w_in = 8.5;
+    f.page_h_in = 11;
+    f.columns = 2;
+    f.body_pt = 10.3;
+    f.ref_pt = 8.3;
+    f.body_pages = 12;
+    f.ref_pages = 1;
+    f.fonts = type1([
+      "NimbusRomNo9L-Medi",
+      "NimbusRomNo9L-Regu",
+      "NimbusRomNo9L-ReguItal",
+      "NimbusRomNo9L-MediItal",
+    ]);
+    patch(f);
+  });
+
+describe("the IEEE conference family and AIDC", () => {
+  const FAMILY = { extends: "paperlint:ieee-conference" };
+  const AIDC = { extends: "paperlint:aidc", kind: "regular" };
+
+  it.each([
+    ["the family", FAMILY],
+    ["aidc/regular", AIDC],
+    ["aidc/short", { extends: "paperlint:aidc", kind: "short" }],
+  ])("the measured IEEEtran build passes %s", (_, venue) => {
+    expect(lint({ venue, facts: ieeeFacts() })).toEqual([]);
+  });
+
+  it.each([
+    ["the family", FAMILY],
+    ["aidc", AIDC],
+  ])("the planted A4 build fails %s on both page dimensions", (_, venue) => {
+    const facts = ieeeFacts(
+      (f) => ((f.page_w_in = 8.264), (f.page_h_in = 11.694)),
+    );
+    expect(ids(lint({ venue, facts }))).toEqual([
+      "pdf/geometry:dim",
+      "pdf/geometry:dim",
+    ]);
+  });
+
+  it.each([
+    ["the family", FAMILY],
+    ["aidc", AIDC],
+  ])("the planted Computer Modern build fails %s: no Times", (_, venue) => {
+    const facts = ieeeFacts(
+      (f) => (f.fonts = type1(["CMBX12", "CMR10", "CMTI10"])),
+    );
+    const fs = lint({ venue, facts });
+    expect(ids(fs)).toEqual(["pdf/fonts:noFamily"]);
+    expect(fs[0]?.message).toMatch(/NimbusRomNo9L/);
+  });
+
+  it("a body size off the family's 10 pt fails pdf/body-size", () => {
+    expect(
+      ids(lint({ venue: AIDC, facts: ieeeFacts((f) => (f.body_pt = 9.3)) })),
+    ).toEqual(["pdf/body-size:body"]);
+  });
+
+  it("🔴 AIDC's page limit is not gated: banal's body count of 13 — a correct paper with its LLM Usage Statement before the references — is not a finding", () => {
+    expect(
+      lint({
+        venue: AIDC,
+        facts: ieeeFacts((f) => ((f.body_pages = 13), (f.ref_pages = 0))),
+      }),
+    ).toEqual([]);
+  });
+
+  it("an AIDC kind that does not exist names the two that do", () => {
+    const fs = lint({ venue: { extends: "paperlint:aidc", kind: "wip" } });
+    expect(ids(fs)).toContain("pdf/profile:kindUnknown");
+    expect(fs.find((f) => f.rule === "pdf/profile")?.message).toMatch(
+      /regular, short/,
+    );
+  });
+});
+
 describe("a project's own preset, and the facts' other spellings", () => {
   // A standalone preset (no `extends`, so it carries a `tex` block) that sets a body size with no
   // tolerance, a reference range, two columns — and no page size and no font families.

package/src/venue-rules.ts

@@ -89,7 +89,7 @@ export type Assessment =
 
 export interface VenueRuleDeps {
   readonly files: Files;
-  /** The package's venues directory (`packageVenuesDir()`): the shipped presets and their schema. */
+  /** The package's presets directory (`presetsDir()`): the shipped presets and their schema. */
   readonly venuesDir: string;
 }
 

package/templates/paper/paper.tex

@@ -1,5 +1,6 @@
 % Created by `paperlint new`. A stub: replace all of it. The only thing `paperlint lint` needs is that
-% this file exists; the document class is yours. `paperlint build` compiles it to paper.pdf.
+% this file exists. With `--venue`, the class below is the venue's (`tex/template` checks it);
+% without, it is yours. `paperlint build` compiles it to paper.pdf.
 \documentclass{article}
 \title{Working title for {{name}}}
 \begin{document}

package/skills/harden-paper/fixtures/uncited-assertions-sample.md

@@ -1,43 +0,0 @@
-# Uncited-assertion fixture (markdown path)
-
-Documents the `.md` behaviour of the uncited-assertion checker. Keep in the repo (it IS the contract).
-<!-- Since 2026-08-27 the checker is the ESLint rule `paper/uncited-assertion`
-(`eslint-rules/paper-claims.mjs`); this file is its test — see `eslint-rules/paper-claims.harness.mjs`. -->
-
-Transformers outperform RNNs by 12%.
-<!-- MUST FLAG: uncited empirical claim about prior work -->
-
-Transformers outperform RNNs by 12% [@vaswani2017].
-<!-- MUST NOT FLAG: pandoc [@key] citation attached -->
-
-Prior work reports a large improvement over baselines.[^1]
-<!-- MUST NOT FLAG: markdown footnote marker counts as a citation -->
-
-The majority of detectors fail on adversarial inputs, per a recent survey ([link](https://example.org/survey)).
-<!-- MUST NOT FLAG: markdown link/URL counts as a citation -->
-
-Most prior detectors silently miss adversarial inputs.
-<!-- MUST FLAG: bare fuzzy quantifier, no citation -->
-
-We observe a 6% reduction in false positives.
-<!-- MUST NOT FLAG: paper's own result (we-guard) -->
-
-Transformers outperform RNNs by 12% [12].
-<!-- MUST NOT FLAG (S6): numeric citation [12] counts as a cite -->
-
-Prior detectors reduce error by 20% [3, 4].
-<!-- MUST NOT FLAG (S6): citation list [3, 4] counts -->
-
-US-based detectors reject 40% of benign inputs.
-<!-- MUST FLAG (S5): bare country "US" is not the paper's own result -->
-
-Our reading of the literature shows transformers outperform every prior baseline.
-<!-- MUST FLAG (S5): claim about OTHERS, "our reading" is not an own result -->
-
-Our method reduces false positives by 6% over the strongest baseline.
-<!-- MUST NOT FLAG (S5): genuine own result, "our method" is the subject -->
-
-2. Prior detectors silently miss most adversarial inputs.
-<!-- MUST FLAG (S10): ordered-list marker "2." must not be a false boundary / stray number; the claim itself still flags -->
-
-[^1]: Some prior study, 2021.