paperlint 5.0.0 → 6.0.0

package/src/pdf-content.ts

@@ -0,0 +1,125 @@
+/**
+ * What a page SAYS, as pdf.js exports it — PURE. The anonymity and page-limit rules judge text, so
+ * the facts carry each page's text, the targets of its links, where the bibliography's first entry
+ * and the appendix are anchored, and the document's metadata. `pdf-facts.ts` reads the PDF and
+ * calls these; nothing here knows what a rule does with the result.
+ */
+import { fieldOf, isRecord } from "./domain/record.ts";
+
+/**
+ * A page's text: its items in content order, joined WITHOUT a separator — pdf.js emits a space as
+ * an item of its own where the glyphs leave a gap, so a word split into two items by kerning comes
+ * back whole — with a line break after every item pdf.js marks as ending a line.
+ */
+export const pageTextOf = (items: readonly unknown[]): string =>
+  items
+    .map((it) => {
+      const s = fieldOf(it, "str");
+      return `${typeof s === "string" ? s : ""}${fieldOf(it, "hasEOL") === true ? "\n" : ""}`;
+    })
+    .join("");
+
+/**
+ * The target of every link annotation on a page, once each: its `url`, else its `unsafeUrl`. A link
+ * whose text breaks across lines is one annotation per line (measured: hyperref's `\\href` gave two
+ * for one target), and one target is one fact.
+ */
+export const linkTargetsOf = (
+  annotations: readonly unknown[],
+): readonly string[] => {
+  const urls = annotations.flatMap((a) => {
+    if (fieldOf(a, "subtype") !== "Link") return [];
+    const url = fieldOf(a, "url") ?? fieldOf(a, "unsafeUrl");
+    return typeof url === "string" && url !== "" ? [url] : [];
+  });
+  return urls.filter((u, i) => urls.indexOf(u) === i);
+};
+
+/** The page reference an explicit destination starts with, or null for anything else. */
+export const refOf = (dest: unknown): object | null => {
+  const ref: unknown = Array.isArray(dest) ? dest[0] : undefined;
+  return typeof ref === "object" && ref !== null ? ref : null;
+};
+
+/**
+ * The page references of the named destinations whose name starts with `prefix`, from pdf.js's
+ * `getDestinations()` (name → explicit destination). hyperref names one `cite.<key>` per
+ * `\bibitem`, and, after `\appendix` in the standard classes, the appendix's sections
+ * `appendix.<letter>`.
+ */
+export const namedRefs = (
+  destinations: unknown,
+  prefix: string,
+): readonly object[] =>
+  isRecord(destinations)
+    ? Object.entries(destinations).flatMap(([name, dest]) => {
+        const ref = refOf(dest);
+        return name.startsWith(prefix) && ref !== null ? [ref] : [];
+      })
+    : [];
+
+/** A bookmark title that opens an appendix: «Appendix A: …», «APPENDIX», «Appendices». */
+const APPENDIX_TITLE = /^\s*appendi(?:x|ces)\b/iu;
+
+/**
+ * The destinations of the top-level bookmarks that open an appendix, from pdf.js's `getOutline()`:
+ * each a name to look up, or an explicit destination. IEEEtran's `\appendices` names its sections
+ * `section*.<n>`, so the bookmark's title is what says it is an appendix.
+ */
+export const appendixOutlineDests = (outline: unknown): readonly unknown[] =>
+  Array.isArray(outline)
+    ? outline.flatMap((item: unknown) => {
+        const title = fieldOf(item, "title");
+        return typeof title === "string" && APPENDIX_TITLE.test(title)
+          ? [fieldOf(item, "dest")]
+          : [];
+      })
+    : [];
+
+/** A value of a metadata field as text: a string, or the strings of a list; nothing else. */
+const textsOf = (v: unknown): readonly string[] =>
+  typeof v === "string"
+    ? [v]
+    : Array.isArray(v)
+      ? v.filter((x): x is string => typeof x === "string")
+      : [];
+
+const entries = (rec: unknown): readonly (readonly [string, string])[] =>
+  isRecord(rec)
+    ? Object.entries(rec).flatMap(([k, v]) => {
+        const text = textsOf(v).join("; ");
+        return text === "" ? [] : [[k, text] as const];
+      })
+    : [];
+
+/**
+ * The XMP packet pdf.js parsed, as `name → value`: its `Metadata` iterates `[name, value]` pairs.
+ * Null when the PDF carries no packet.
+ */
+export const xmpOf = (
+  packet: Iterable<unknown> | null,
+): Readonly<Record<string, unknown>> | null =>
+  packet === null
+    ? null
+    : Object.fromEntries(
+        [...packet].flatMap((e) =>
+          Array.isArray(e) && typeof e[0] === "string" ? [[e[0], e[1]]] : [],
+        ),
+      );
+
+/**
+ * The document's metadata as flat `field → text`: every string of the Info dictionary (`Author`,
+ * `Title`, …), of its custom entries (`PTEX.Fullbanner`), and of the XMP packet, whose names carry
+ * their namespace (`dc:creator`), as pdf.js's `getMetadata` returns them. `xmp` is the packet's
+ * `xmpOf`, or null when the PDF has none.
+ */
+export function metadataOf(
+  info: unknown,
+  xmp: unknown,
+): Readonly<Record<string, string>> {
+  return Object.fromEntries([
+    ...entries(info),
+    ...entries(fieldOf(info, "Custom")),
+    ...entries(xmp),
+  ]);
+}

package/src/pdf-facts.test.ts

@@ -6,6 +6,7 @@
  */
 import assert from "node:assert/strict";
 import { getResolvedPDFJS } from "unpdf";
+import { fieldOf } from "./domain/record.ts";
 import { test } from "vitest";
 import { factsOf, failureOf, rawFontOf } from "./pdf-facts.ts";
 import { present } from "../test/support.ts";
@@ -21,7 +22,11 @@ interface FakeItem {
   height: number;
 }
 /** A page whose text items and loaded fonts are given; its viewport flips y like pdf.js's. */
-function page(items: FakeItem[], fonts: Record<string, unknown>) {
+function page(
+  items: FakeItem[],
+  fonts: Record<string, unknown>,
+  said: { annotations?: unknown[] } = {},
+) {
   const objs = new Map(Object.entries(fonts));
   return {
     getOperatorList: () => Promise.resolve({ fnArray: [], argsArray: [] }),
@@ -32,6 +37,7 @@ function page(items: FakeItem[], fonts: Record<string, unknown>) {
       get: (id: string) => objs.get(id),
       [Symbol.iterator]: () => objs[Symbol.iterator](),
     },
+    getAnnotations: () => Promise.resolve(said.annotations ?? []),
     getViewport: () => ({
       width: 612,
       height: H,
@@ -40,8 +46,23 @@ function page(items: FakeItem[], fonts: Record<string, unknown>) {
     }),
   };
 }
-const doc = (pages: ReturnType<typeof page>[]) => ({
+const doc = (
+  pages: ReturnType<typeof page>[],
+  info: unknown = {},
+  destinations: unknown = {},
+  outline: unknown = null,
+) => ({
   numPages: pages.length,
+  getMetadata: () => Promise.resolve({ info, metadata: null }),
+  getDestinations: () => Promise.resolve(destinations),
+  getDestination: (id: string) =>
+    Promise.resolve(fieldOf(destinations, id) ?? null),
+  getOutline: () => Promise.resolve(outline),
+  // A reference is `{ page }` here; one without a page is one pdf.js cannot place.
+  getPageIndex: (ref: object) =>
+    "page" in ref && typeof ref.page === "number"
+      ? Promise.resolve(ref.page - 1)
+      : Promise.reject(new Error("Invalid page reference")),
   getPage: (i: number) =>
     Promise.resolve(present(pages[i - 1], `page ${String(i)}`)),
 });
@@ -152,3 +173,90 @@ test("🔴 a rejection with no value at all is a failure too, not a TypeError ou
     ],
   );
 });
+
+test("what the pages say: text, links with their page, metadata", async () => {
+  const fonts = { f1: { loadedName: "f1", name: "Named", ascent: 0.8 } };
+  const plain = page([item("f1", [10, 0, 0, 10, 50, 700])], fonts);
+  const linked = page([item("f1", [10, 0, 0, 10, 50, 700])], fonts, {
+    annotations: [{ subtype: "Link", url: "https://github.com/adaexample" }],
+  });
+  const r = await factsOf(doc([plain, linked], { Author: "Ada Example" }), lib);
+  assert.ok(r.ok);
+  assert.deepEqual(
+    [r.facts.pageTexts, r.facts.links, r.facts.metadata],
+    [
+      ["word", "word"],
+      [{ page: 2, uri: "https://github.com/adaexample" }],
+      { Author: "Ada Example" },
+    ],
+  );
+});
+
+test("the bibliography anchor: the lowest page of any cite.<key> destination", async () => {
+  const fonts = { f1: { loadedName: "f1", name: "Named", ascent: 0.8 } };
+  const pages = [1, 2, 3].map(() =>
+    page([item("f1", [10, 0, 0, 10, 50, 700])], fonts),
+  );
+  const facts = async (destinations: unknown) => {
+    const r = await factsOf(doc(pages, {}, destinations), lib);
+    assert.ok(r.ok);
+    return r.facts.bibAnchorPage;
+  };
+  assert.equal(
+    await facts({
+      "cite.b": [{ page: 3 }, { name: "XYZ" }],
+      "cite.a": [{ page: 2 }, { name: "XYZ" }],
+      "section.1": [{ page: 1 }, { name: "XYZ" }],
+      // A reference pdf.js cannot place is skipped, not fatal.
+      "cite.c": [{ num: 99 }, { name: "XYZ" }],
+    }),
+    2,
+  );
+  // No hyperref: no cite destinations, and the value says so.
+  assert.equal(await facts({ "section.1": [{ page: 1 }] }), null);
+  assert.equal(await facts(null), null);
+  // A destination that is not an explicit array is not an anchor.
+  assert.equal(await facts({ "cite.a": "named-elsewhere" }), null);
+});
+
+test("the appendix anchor: an appendix.<letter> destination, or a bookmark titled «Appendix…»", async () => {
+  const fonts = { f1: { loadedName: "f1", name: "Named", ascent: 0.8 } };
+  const pages = [1, 2, 3, 4].map(() =>
+    page([item("f1", [10, 0, 0, 10, 50, 700])], fonts),
+  );
+  const facts = async (destinations: unknown, outline: unknown) => {
+    const r = await factsOf(doc(pages, {}, destinations, outline), lib);
+    assert.ok(r.ok);
+    return r.facts.appendixAnchorPage;
+  };
+  const XYZ = { name: "XYZ" };
+  // The standard classes: hyperref names the appendix's sections `appendix.<letter>`.
+  assert.equal(
+    await facts(
+      { "appendix.B": [{ page: 4 }, XYZ], "appendix.A": [{ page: 3 }, XYZ] },
+      null,
+    ),
+    3,
+  );
+  // IEEEtran's \appendices: the sections are `section*.<n>`; the bookmark's title says appendix,
+  // its destination is a name to look up, or an explicit one.
+  const named = {
+    "section*.5": [{ page: 2 }, XYZ],
+    "section*.4": [{ page: 1 }, XYZ],
+  };
+  assert.equal(
+    await facts(named, [
+      { title: "Conclusion", dest: "section*.4", items: [] },
+      { title: "Appendix A: Details", dest: "section*.5", items: [] },
+      { title: "APPENDIX", dest: [{ page: 4 }, XYZ], items: [] },
+    ]),
+    2,
+  );
+  // No appendix anywhere, a bookmark whose name resolves to nothing, and no outline at all.
+  assert.equal(
+    await facts(named, [{ title: "Conclusion", dest: "section*.4" }]),
+    null,
+  );
+  assert.equal(await facts({}, [{ title: "Appendices", dest: "gone" }]), null);
+  assert.equal(await facts({}, { not: "a list" }), null);
+});

package/src/pdf-facts.ts

@@ -34,6 +34,15 @@ import {
 import type { PageLayout, TextBox } from "./domain/page-layout.ts";
 // eslint-disable-next-line boundaries/dependencies -- legacy layer, moves behind a port in #76
 import { fillsFor, isUpright } from "./adapters/pdfjs/fill.ts";
+import {
+  appendixOutlineDests,
+  linkTargetsOf,
+  metadataOf,
+  namedRefs,
+  pageTextOf,
+  refOf,
+  xmpOf,
+} from "./pdf-content.ts";
 import { messageOf } from "./domain/text.ts";
 import { fieldOf, isRecord, numbersOf } from "./domain/record.ts";
 
@@ -83,12 +92,27 @@ interface Page {
     [Symbol.iterator](): Iterator<readonly unknown[]>;
   };
   getViewport(params: { scale: number }): Viewport;
+  /** pdf.js's annotations; the link ones carry `url`. */
+  getAnnotations(): Promise<readonly unknown[]>;
 }
 
 /** A document as this module reads it; pdf.js's `PDFDocumentProxy` is one. */
 interface Doc {
   readonly numPages: number;
   getPage(pageNumber: number): Promise<Page>;
+  /** The Info dictionary, and the XMP packet when there is one. */
+  getMetadata(): Promise<{
+    readonly info: unknown;
+    readonly metadata: Iterable<unknown> | null;
+  }>;
+  /** Every named destination: name → explicit destination. */
+  getDestinations(): Promise<unknown>;
+  /** The 0-based index of the page a destination's reference names. */
+  getPageIndex(ref: object): Promise<number>;
+  /** One named destination, or null. */
+  getDestination(id: string): Promise<unknown>;
+  /** The bookmarks: `{ title, dest, items }`, or null. */
+  getOutline(): Promise<unknown>;
 }
 
 /** A viewport point, which pdf.js types as `any[]`: the two numbers it holds. */
@@ -106,6 +130,22 @@ export interface PdfFacts {
   readonly fonts: Fonts;
   readonly last: PageText;
   readonly layout: readonly PageLayout[];
+  /** Each page's text, in content order, a line break after each line (`pageTextOf`). */
+  readonly pageTexts: readonly string[];
+  /** The target of every link, with its 1-based page. */
+  readonly links: readonly PdfLink[];
+  /** The 1-based page of the first bibliography entry hyperref anchored, or null without one. */
+  readonly bibAnchorPage: number | null;
+  /** The 1-based page the appendix starts on, from hyperref's destinations and bookmarks, or null. */
+  readonly appendixAnchorPage: number | null;
+  /** The Info dictionary and XMP packet, flat (`metadataOf`). */
+  readonly metadata: Readonly<Record<string, string>>;
+}
+
+/** A link annotation's target, and the page it is on. */
+export interface PdfLink {
+  readonly page: number;
+  readonly uri: string;
 }
 
 export type PdfReadFailure =
@@ -198,10 +238,17 @@ async function readPage(
   page: Page,
   seen: ReadonlySet<string>,
   lib: PdfJs,
-): Promise<{ raw: RawPage; items: TextItem[]; layout: PageLayout }> {
+): Promise<{
+  raw: RawPage;
+  items: TextItem[];
+  layout: PageLayout;
+  text: string;
+  links: readonly string[];
+}> {
   // The operator list is what makes pdf.js load a page's fonts into `commonObjs`.
   const ops = await page.getOperatorList();
-  const items = (await page.getTextContent()).items.filter(isText);
+  const all = (await page.getTextContent()).items;
+  const items = all.filter(isText);
   const loaded = loadedFonts(page);
   const named = new Set(items.map((it) => it.fontName));
   const fonts = [...loaded.values()].filter(
@@ -211,6 +258,8 @@ async function readPage(
     raw: { hasText: items.length > 0, fonts },
     items,
     layout: layoutOf(page, items, ops, lib),
+    text: pageTextOf(all),
+    links: linkTargetsOf(await page.getAnnotations()),
   };
 }
 
@@ -310,12 +359,7 @@ function layoutOf(
  * transform, no pages) — `readPdf` below is the one production caller.
  */
 export async function factsOf(doc: Doc, lib: PdfJs): Promise<PdfRead> {
-  const read: {
-    page: Page;
-    raw: RawPage;
-    items: TextItem[];
-    layout: PageLayout;
-  }[] = [];
+  const read: (Awaited<ReturnType<typeof readPage>> & { page: Page })[] = [];
   const seen = new Set<string>();
   for (let i = 1; i <= doc.numPages; i++) {
     const page = await doc.getPage(i);
@@ -340,10 +384,64 @@ export async function factsOf(doc: Doc, lib: PdfJs): Promise<PdfRead> {
       fonts,
       last: pageText(last.page, last.items),
       layout: read.map((r) => r.layout),
+      ...saidOf(read, await doc.getMetadata()),
+      ...(await anchorsOf(doc)),
     },
   };
 }
 
+/**
+ * Where hyperref anchored the bibliography's first entry (the lowest page of a `cite.<key>`
+ * destination) and the appendix (the lowest page of an `appendix.<letter>` destination or of a
+ * bookmark titled «Appendix…»). A reference pdf.js cannot place is skipped.
+ */
+async function anchorsOf(
+  doc: Doc,
+): Promise<Pick<PdfFacts, "bibAnchorPage" | "appendixAnchorPage">> {
+  const destinations = await doc.getDestinations();
+  const bookmarked = await Promise.all(
+    appendixOutlineDests(await doc.getOutline()).map(async (d) =>
+      refOf(typeof d === "string" ? await doc.getDestination(d) : d),
+    ),
+  );
+  return {
+    bibAnchorPage: await lowestPage(doc, namedRefs(destinations, "cite.")),
+    appendixAnchorPage: await lowestPage(doc, [
+      ...namedRefs(destinations, "appendix."),
+      ...bookmarked.filter((r): r is object => r !== null),
+    ]),
+  };
+}
+
+/** The lowest 1-based page any of `refs` names, or null when none can be placed. */
+async function lowestPage(
+  doc: Doc,
+  refs: readonly object[],
+): Promise<number | null> {
+  const pages = await Promise.all(
+    refs.map((r) =>
+      doc.getPageIndex(r).then(
+        (i) => [i + 1],
+        () => [],
+      ),
+    ),
+  );
+  const found = pages.flat();
+  return found.length === 0 ? null : Math.min(...found);
+}
+
+/** What the pages say, from each page's read, and the document's metadata. */
+function saidOf(
+  read: readonly Pick<Awaited<ReturnType<typeof readPage>>, "text" | "links">[],
+  meta: Awaited<ReturnType<Doc["getMetadata"]>>,
+): Pick<PdfFacts, "pageTexts" | "links" | "metadata"> {
+  return {
+    pageTexts: read.map((r) => r.text),
+    links: read.flatMap((r, i) => r.links.map((uri) => ({ page: i + 1, uri }))),
+    metadata: metadataOf(meta.info, xmpOf(meta.metadata)),
+  };
+}
+
 /** pdf.js's own exception names for the two conditions a caller can act on. */
 export function failureOf(e: unknown): PdfRead {
   const name = fieldOf(e, "name");

package/src/ports/latex.ts

@@ -6,6 +6,7 @@ import type { Include } from "../domain/paper-source.ts";
 import type {
   ClassLine,
   DocumentClass,
+  LayoutOverride,
   Outline,
   Passage,
   Span,
@@ -39,4 +40,6 @@ export interface LatexReader {
    * option `want` names (the author's own options stay), or it has none.
    */
   readonly withDocumentClass: (src: string, want: DocumentClass) => string;
+  /** Every command that changes the page layout the class sets: margins, text block, line spacing. */
+  readonly layoutOverrides: (src: string) => readonly LayoutOverride[];
 }

package/src/presets.ts

@@ -83,6 +83,8 @@ export interface Preset {
   readonly template: PresetTemplate | null;
   /** Every `name` and `aliases` along the chain: what this venue is called in a paper's text. */
   readonly aliases: readonly string[];
+  /** Whether the venue reviews double-blind (`anonymity/identity`); false when no file of the chain says. */
+  readonly blind: boolean;
   readonly requiredSections: readonly RequiredSection[];
   readonly tex: TexRequirements;
   readonly format: VenueFormat;
@@ -196,6 +198,7 @@ export function mergeFormat(
     refPtMax: pick("refPtMax"),
     fontsText: pick("fontsText"),
     fontsTitle: pick("fontsTitle"),
+    bodyEndsAt: pick("bodyEndsAt"),
     kinds: new Map([...parent.kinds, ...child.kinds]),
   };
 }
@@ -205,18 +208,13 @@ function merged(
   spec: string,
   rootFirst: readonly { readonly preset: PresetFile; readonly file: string }[],
 ): Preset {
-  const base: {
-    name: string | null;
-    template: PresetTemplate | null;
-    aliases: readonly string[];
-    requiredSections: readonly RequiredSection[];
-    tex: TexRequirements;
-    format: VenueFormat;
-    rules: Readonly<Record<string, unknown>>;
+  const base: Omit<Preset, "label" | "chain"> & {
+    readonly name: string | null;
   } = {
     name: null,
     template: null,
     aliases: [],
+    blind: false,
     requiredSections: [],
     tex: NO_REQUIREMENTS,
     format: NO_FORMAT,
@@ -233,6 +231,7 @@ function merged(
           ...p.aliases,
         ]),
       ],
+      blind: p.blind ?? acc.blind,
       requiredSections: p.requiredSections ?? acc.requiredSections,
       tex: p.tex ? mergeRequirements(acc.tex, p.tex) : acc.tex,
       format: mergeFormat(acc.format, p.format),
@@ -245,6 +244,7 @@ function merged(
     chain: rootFirst.map((x) => x.file),
     template: m.template,
     aliases: m.aliases,
+    blind: m.blind,
     requiredSections: m.requiredSections,
     tex: m.tex,
     format: m.format,

package/src/rule-cases.test.ts

@@ -43,11 +43,22 @@ const paper = (
 
 const PDF = "%PDF-1.5 a stand-in for the built PDF";
 const AGENTICDEV = { extends: "paperlint:agenticdev", kind: "short" };
+/** A double-blind venue's paper that declares who wrote it (`anonymity/*`). */
+const BLIND = {
+  extends: "paperlint:aidc",
+  kind: "regular",
+  identity: ["Ada Example", "adaexample"],
+};
 const ACM_TEX = tex("Text.", "\\documentclass[sigconf]{acmart}");
 
 /** The facts of a short agenticdev paper that meets every number in its preset. */
 const goodFacts = (): Record<string, unknown> => ({
-  schema: 2,
+  schema: 3,
+  pages_text: [],
+  metadata: {},
+  links: [],
+  bib_anchor_page: null,
+  appendix_anchor_page: null,
   pdf: "paper.pdf",
   pdf_sha256: sha256Hex(new TextEncoder().encode(PDF)),
   venue: "agenticdev",
@@ -381,16 +392,31 @@ const CASES: Readonly<Record<string, RuleCases>> = {
     reports: onPdf(built({ page_w_in: 8.264 })),
     silent: built(),
   },
-  "pdf/limits": {
+  "format/page-limit": {
     reports: onPdf(
       built({ body_pages: 9, pages_by_type: { body: 9, bib: 2 } }),
     ),
     silent: built(),
   },
   "pdf/body-size": {
-    reports: { ...onPdf(built({ body_pt: 12 })), severity: 1 },
+    reports: onPdf(built({ body_pt: 12 })),
     silent: built(),
   },
+  "anonymity/identity": {
+    reports: onPdf(
+      built({ pages_text: ["Ada Example\n", "References\n"] }, BLIND),
+    ),
+    silent: built({ pages_text: ["Anonymous\n", "References\n"] }, BLIND),
+  },
+  "format/layout-override": {
+    reports: {
+      tree: aidc("\\linespread{0.9}Text."),
+      file: TEX_FILE,
+      severity: 2,
+      line: 4,
+    },
+    silent: aidc("\\vspace{-2mm}Text."),
+  },
   "pdf/last-page-balance": {
     reports: onPdf(
       built(

package/src/rule-docs.test.ts

@@ -29,12 +29,10 @@ const AWAITING_PAGE: ReadonlySet<string> = new Set([
   "paper/section-word",
   "paper/source",
   "paper/stages",
-  "pdf/body-size",
   "pdf/fonts",
   "pdf/fresh",
   "pdf/geometry",
   "pdf/last-page-balance",
-  "pdf/limits",
   "pdf/measured",
   "pdf/profile",
   "review/frontmatter",

package/src/tex-requirements.ts

@@ -131,6 +131,8 @@ export interface VenueFormat {
   /** The prefix a font name of the body text starts with (`LinLibertine`). */
   readonly fontsText: string | null;
   readonly fontsTitle: string | null;
+  /** How the body is counted: null is banal's count; `references`, the pages before the references. */
+  readonly bodyEndsAt: "references" | null;
   readonly kinds: ReadonlyMap<string, KindLimits>;
 }
 
@@ -145,6 +147,7 @@ export const NO_FORMAT: VenueFormat = {
   refPtMax: null,
   fontsText: null,
   fontsTitle: null,
+  bodyEndsAt: null,
   kinds: new Map(),
 };
 
@@ -168,6 +171,8 @@ export interface PresetFile {
   readonly template: string | null;
   /** Other names the venue goes by in a paper's text; empty when the file names none. */
   readonly aliases: readonly string[];
+  /** Whether the venue reviews double-blind; null when the file does not say. */
+  readonly blind: boolean | null;
   /** Sections the venue requires; null when the file names none (a child's list replaces its parent's). */
   readonly requiredSections: readonly RequiredSection[] | null;
   /** Null when the file declares no `tex` block (allowed only with `extends`). */
@@ -192,6 +197,7 @@ interface FormatJson {
   readonly ref_pt_max?: number;
   readonly fonts_text?: string;
   readonly fonts_title?: string;
+  readonly body_ends_at?: "references";
   readonly kinds?: KindsJson;
 }
 
@@ -201,6 +207,7 @@ interface PresetJson {
   readonly name?: string;
   readonly template?: string;
   readonly aliases?: readonly string[];
+  readonly blind?: boolean;
   readonly required_sections?: readonly {
     readonly title: string;
     readonly position?: "last";
@@ -238,6 +245,7 @@ function formatOf(j: FormatJson = {}): VenueFormat {
     refPtMax: orNull(j.ref_pt_max),
     fontsText: orNull(j.fonts_text),
     fontsTitle: orNull(j.fonts_title),
+    bodyEndsAt: orNull(j.body_ends_at),
     kinds: kindsOf(j.kinds),
   };
 }
@@ -281,6 +289,7 @@ export function parsePreset(
     name: orNull(j.name),
     template: orNull(j.template),
     aliases: j.aliases ?? [],
+    blind: orNull(j.blind),
     requiredSections: sectionsOf(j.required_sections),
     tex: j.tex ? { packages: j.tex.packages, tools: j.tex.tools ?? {} } : null,
     format: formatOf(j.format),