paperlint 6.2.3 → 7.0.0

package/src/adapters/hotcrp/response.ts

@@ -0,0 +1,181 @@
+/**
+ * HotCRP's answers, parsed at the boundary into paperlint's submission values. Pure.
+ *
+ * Only the fields the command uses are read; every other key HotCRP sends is dropped here. The field
+ * names are HotCRP's (`devel/openapi.json` and `devel/apidoc/submissions.md` in kohler/hotcrp):
+ * `GET /api/paper` answers `{ ok, paper, message_list? }`, `POST /api/paper` answers
+ * `{ ok, valid, change_list, message_list, dry_run?, pid }`. A document's `hash` is
+ * `sha2-<64 hex>` when HotCRP stored a sha256; timestamps are Unix seconds.
+ */
+import { z } from "zod";
+import { err, ok, type Result } from "../../domain/result.ts";
+import { parseSha256, type Sha256 } from "../../domain/sha256.ts";
+import type {
+  PortalDocument,
+  PortalFailure,
+  PortalMessage,
+  SubmissionView,
+  UpdateOutcome,
+} from "../../domain/submission.ts";
+
+const Message = z.object({
+  message: z.string().optional(),
+  field: z.string().optional(),
+  status: z.number().optional(),
+});
+const Messages = z.array(Message).optional();
+
+const Document = z.object({
+  hash: z.string().optional(),
+  size: z.number().optional(),
+  mimetype: z.string().optional(),
+  timestamp: z.number().optional(),
+});
+
+const Paper = z.object({
+  pid: z.number(),
+  status: z.string(),
+  title: z.string().optional(),
+  abstract: z.string().optional(),
+  paper_type: z.unknown().optional(),
+  topics: z.array(z.string()).optional(),
+  submission: Document.nullable().optional(),
+  submitted_at: z.number().optional(),
+  modified_at: z.number().optional(),
+});
+
+const ShowBody = z.object({
+  ok: z.literal(true),
+  paper: Paper,
+  message_list: Messages,
+});
+
+const UpdateBody = z.object({
+  valid: z.boolean(),
+  change_list: z.array(z.string()).optional(),
+  message_list: Messages,
+  dry_run: z.boolean().optional(),
+});
+
+const Envelope = z.object({ message_list: Messages });
+
+const SHA2 = /^sha2-([0-9a-f]{64})$/;
+
+/** HotCRP's `sha2-<hex>` → the sha256; null for any other hash it may name. */
+export function sha256OfHash(hash: string): Sha256 | null {
+  const hex = SHA2.exec(hash)?.[1];
+  return hex === undefined ? null : parseSha256(hex);
+}
+
+/** HotCRP prefixes a message with its format (`<0>` plain text, `<5>` HTML); the text is the rest. */
+const textOf = (message: string | undefined): string =>
+  (message ?? "").replace(/^<\d+>/, "").trim();
+
+/** The messages that say something: HotCRP also sends entries with no text, which print as blanks. */
+const messagesOf = (
+  list: Readonly<z.infer<typeof Messages>>,
+): readonly PortalMessage[] =>
+  (list ?? [])
+    .map((m) => ({
+      message: textOf(m.message),
+      field: m.field ?? null,
+      status: m.status ?? null,
+    }))
+    .filter((m) => m.message !== "");
+
+const documentOf = (
+  d: Readonly<z.infer<typeof Document>> | null | undefined,
+): PortalDocument | null =>
+  d?.hash === undefined
+    ? null
+    : {
+        sha256: sha256OfHash(d.hash),
+        hash: d.hash,
+        size: d.size ?? null,
+        mimetype: d.mimetype ?? null,
+        uploadedAt: d.timestamp ?? null,
+      };
+
+/** A paper type as text: HotCRP sends the option's name, or a value of another shape. */
+const typeText = (v: unknown): string | null =>
+  v === undefined || v === null
+    ? null
+    : typeof v === "string"
+      ? v
+      : JSON.stringify(v);
+
+function viewOf(b: Readonly<z.infer<typeof ShowBody>>): SubmissionView {
+  const p = b.paper;
+  return {
+    id: p.pid,
+    status: p.status,
+    title: p.title ?? null,
+    paperType: typeText(p.paper_type),
+    topics: p.topics ?? [],
+    abstract: p.abstract ?? null,
+    pdf: documentOf(p.submission),
+    submittedAt: p.submitted_at ?? null,
+    modifiedAt: p.modified_at ?? null,
+    messages: messagesOf(b.message_list),
+  };
+}
+
+const is2xx = (status: number): boolean => status >= 200 && status < 300;
+
+const StatusCode = z.object({ status_code: z.number() });
+
+/**
+ * The status HotCRP meant. Its error envelope repeats the status in the body (`status_code: 401`
+ * beside `ok: false`, recorded in `cassette/get-noauth.json`); when something between us and HotCRP
+ * turns the transport status into a 2xx, the body's code still decides.
+ */
+function statusOf(transport: number, body: unknown): number {
+  const c = StatusCode.safeParse(body);
+  return is2xx(transport) && c.success ? c.data.status_code : transport;
+}
+
+/** A body that is no answer of HotCRP's: the portal's messages when it sent any, else "malformed". */
+function refusal(
+  httpStatus: number,
+  body: unknown,
+  what: string,
+): PortalFailure {
+  const e = Envelope.safeParse(body);
+  const messages = e.success ? messagesOf(e.data.message_list) : [];
+  return messages.length > 0 || !is2xx(httpStatus)
+    ? { kind: "refused", httpStatus, messages }
+    : { kind: "malformed", httpStatus, detail: what };
+}
+
+/** `GET /api/paper` → the submission, or why there is none. */
+export function parseShow(
+  httpStatus: number,
+  body: unknown,
+): Result<SubmissionView, PortalFailure> {
+  const status = statusOf(httpStatus, body);
+  const b = ShowBody.safeParse(body);
+  return b.success && is2xx(status)
+    ? ok(viewOf(b.data))
+    : err(refusal(status, body, "the answer has no submission in `paper`"));
+}
+
+/**
+ * `POST /api/paper` → the outcome, valid or not. A body carrying `valid` is HotCRP's verdict on
+ * the change whatever the HTTP status; the caller decides the exit from both.
+ */
+export function parseUpdate(
+  httpStatus: number,
+  body: unknown,
+): Result<UpdateOutcome, PortalFailure> {
+  const status = statusOf(httpStatus, body);
+  const b = UpdateBody.safeParse(body);
+  if (!b.success)
+    return err(refusal(status, body, "the answer has no `valid`"));
+  return ok({
+    httpStatus: status,
+    valid: b.data.valid,
+    changes: b.data.change_list ?? [],
+    messages: messagesOf(b.data.message_list),
+    dryRun: b.data.dry_run ?? false,
+  });
+}

package/src/adapters/latex/conditionals.ts

@@ -0,0 +1,130 @@
+/**
+ * `\iffalse … \fi`: text TeX never reads. Authors park old titles, sections and paragraphs there,
+ * and every reader of the tree — the outline, the rendered text, the headings the case judge reads,
+ * the includes — would otherwise take them for the paper. So the branch is cut out of the tree once,
+ * when the source is parsed (`parseLatex`), rather than pruned per walk like `hidden.ts` prunes: a
+ * walk can skip a node, but the rendered text reads the strings of a node list directly, and they
+ * would come back.
+ *
+ * What is cut: from `\iffalse` to its matching `\fi`, both included, counting the conditionals
+ * nested in between. An `\else` at the same depth ends the dead part: what follows it is read, and
+ * the matching `\fi` is cut. A conditional is a macro whose name starts with `if`, except
+ * `\ifthenelse` (the `ifthen` package's command, which takes arguments and has no `\fi`). An
+ * `\iffalse` with no `\fi` cuts to the end of its list, as TeX would read to the end of the file.
+ *
+ * Only `\iffalse` is decided. `\iftrue`, `\if\venue1` and every switch made with `\newif` depend on
+ * a value this reader does not compute, so both of their branches stay.
+ */
+import type * as Ast from "@unified-latex/unified-latex-types";
+
+type Node = Readonly<Ast.Node>;
+
+/** Where the scan of one node list stands: reading, inside a dead branch, or in its `\else`. */
+type Mode =
+  | { readonly kind: "live" }
+  | { readonly kind: "dead"; readonly depth: number }
+  | { readonly kind: "else"; readonly depth: number };
+
+/** One node against the mode before it: the mode after it, and whether the node is kept. */
+interface Step {
+  readonly mode: Mode;
+  readonly keep: boolean;
+}
+
+const LIVE: Mode = { kind: "live" };
+
+const isMacro = (n: Node, name: string): boolean =>
+  n.type === "macro" && n.content === name;
+
+/** A macro that opens a conditional TeX closes with `\fi`. */
+const opensConditional = (n: Node): boolean =>
+  n.type === "macro" &&
+  n.content.startsWith("if") &&
+  n.content !== "ifthenelse";
+
+/** Inside the dead branch: everything is cut; nesting is counted, `\else` at depth 1 ends it. */
+function stepDead(depth: number, n: Node): Step {
+  if (opensConditional(n))
+    return { mode: { kind: "dead", depth: depth + 1 }, keep: false };
+  if (isMacro(n, "fi"))
+    return {
+      mode: depth === 1 ? LIVE : { kind: "dead", depth: depth - 1 },
+      keep: false,
+    };
+  if (isMacro(n, "else") && depth === 1)
+    return { mode: { kind: "else", depth }, keep: false };
+  return { mode: { kind: "dead", depth }, keep: false };
+}
+
+/** In the `\else` branch: everything is kept but the `\fi` that closes the `\iffalse`. */
+function stepElse(depth: number, n: Node): Step {
+  if (opensConditional(n))
+    return { mode: { kind: "else", depth: depth + 1 }, keep: true };
+  if (isMacro(n, "fi"))
+    return depth === 1
+      ? { mode: LIVE, keep: false }
+      : { mode: { kind: "else", depth: depth - 1 }, keep: true };
+  return { mode: { kind: "else", depth }, keep: true };
+}
+
+function step(mode: Mode, n: Node): Step {
+  switch (mode.kind) {
+    case "live":
+      return isMacro(n, "iffalse")
+        ? { mode: { kind: "dead", depth: 1 }, keep: false }
+        : { mode, keep: true };
+    case "dead":
+      return stepDead(mode.depth, n);
+    case "else":
+      return stepElse(mode.depth, n);
+  }
+}
+
+/** A node list without its `\iffalse` branches, each kept node cleaned the same way. */
+// eslint-disable-next-line functional/prefer-immutable-types -- the tree's own content type is a mutable array
+function liveList(nodes: readonly Node[]): Ast.Node[] {
+  const { kept } = nodes.reduce<{
+    readonly mode: Mode;
+    readonly kept: readonly Ast.Node[];
+  }>(
+    (acc, n) => {
+      const next = step(acc.mode, n);
+      return {
+        mode: next.mode,
+        kept: next.keep ? [...acc.kept, liveNode(n)] : acc.kept,
+      };
+    },
+    { mode: LIVE, kept: [] },
+  );
+  return [...kept];
+}
+
+// eslint-disable-next-line functional/prefer-immutable-types -- the tree's own argument type is mutable
+const liveArgs = (args: readonly Readonly<Ast.Argument>[]): Ast.Argument[] =>
+  args.map((a) => ({ ...a, content: liveList(a.content) }));
+
+/** A node with its content and its arguments' content cleaned; a node with neither, as it is. */
+// eslint-disable-next-line functional/prefer-immutable-types -- the tree's own node type is mutable
+function liveNode(n: Node): Ast.Node {
+  if (n.type === "macro")
+    return n.args === undefined ? n : { ...n, args: liveArgs(n.args) };
+  if (n.type === "environment" || n.type === "mathenv")
+    return {
+      ...n,
+      content: liveList(n.content),
+      ...(n.args === undefined ? {} : { args: liveArgs(n.args) }),
+    };
+  if (n.type === "group" || n.type === "inlinemath" || n.type === "displaymath")
+    return { ...n, content: liveList(n.content) };
+  return n;
+}
+
+/** The tree without what `\iffalse … \fi` hides; the same tree when the source has no `\iffalse`. */
+export const withoutFalseBranches = (
+  src: string,
+  root: Readonly<Ast.Root>,
+  // eslint-disable-next-line functional/prefer-immutable-types -- `ParsedTex.root` is the tree's own mutable type
+): Ast.Root =>
+  src.includes("\\iffalse")
+    ? { ...root, content: liveList(root.content) }
+    : root;

package/src/adapters/latex/headings.ts

@@ -0,0 +1,163 @@
+/**
+ * The paper's `\title` and the titles of its headings as the case judge reads them: each as one run
+ * of text, every character with the source offset it came from.
+ *
+ * What a title says is its strings and spaces, and the words a formatting command wraps
+ * (`\emph{very}` says "very"). A label, a footnote or an index entry says nothing in the title and
+ * is left out. Anything else — math, `\texttt`, `\cite`, `\textsc`, an accent, an environment — is
+ * something the reader sees and the judge does not read, so it stands as `OPAQUE`, one character,
+ * where it is: the judge then knows a word is first or last only when nothing stands before or
+ * after it, and never reads a word that touches one.
+ */
+import { hasAtLeast } from "remeda";
+import type {
+  HeadingLevel,
+  Segment,
+  TitleArgument,
+  TitledCommand,
+  TitledHeading,
+} from "../../domain/tex-document.ts";
+import { LINE_BREAK, OPAQUE } from "../../domain/tex-document.ts";
+import { isDefinition, isUnrendered } from "./hidden.ts";
+import {
+  inPlace,
+  isNode,
+  mandatory,
+  optional,
+  placeOf,
+  stringText,
+  visited,
+  type Macro,
+  type Node,
+} from "./nodes.ts";
+import type { ParsedTex } from "./parse.ts";
+
+const LEVELS: ReadonlyMap<string, HeadingLevel> = new Map<string, HeadingLevel>(
+  [
+    ["section", "section"],
+    ["subsection", "subsection"],
+    ["subsubsection", "subsubsection"],
+    ["paragraph", "paragraph"],
+    ["subparagraph", "subparagraph"],
+  ],
+);
+
+/** Formatting commands: they say what their argument says. */
+const TRANSPARENT: ReadonlySet<string> = new Set([
+  "emph",
+  "textit",
+  "textbf",
+  "textsl",
+  "textup",
+  "textmd",
+  "textnormal",
+  "textsf",
+  "textrm",
+]);
+
+/** Commands that break the line: the title goes on as a second part, a subtitle. */
+const LINE_BREAKS: ReadonlySet<string> = new Set([
+  "\\\\",
+  "newline",
+  "linebreak",
+]);
+
+/** Commands that put nothing in the title's words: a label, a footnote, an index entry. */
+const INVISIBLE: ReadonlySet<string> = new Set([
+  "label",
+  "footnote",
+  "thanks",
+  "index",
+]);
+
+/**
+ * The command a macro is, for the case judge: the paper's `\title`, a heading at its level, or none.
+ * `\title` is read wherever it stands — in the preamble, where acmart and IEEEtran put it, or in a
+ * file the paper includes.
+ */
+const commandOf = (m: Macro): readonly TitledCommand[] => {
+  if (m.content === "title") return [{ kind: "title" }];
+  const level = LEVELS.get(m.content);
+  return level === undefined ? [] : [{ kind: "heading", level }];
+};
+
+/** A macro that is neither left out of the title nor read as the words it wraps. */
+const isOpaqueMacro = (m: Macro): boolean =>
+  !INVISIBLE.has(m.content) &&
+  !TRANSPARENT.has(m.content) &&
+  !LINE_BREAKS.has(m.content);
+
+/** What one macro says in a title. */
+function macroSegments(m: Macro): readonly Segment[] {
+  if (INVISIBLE.has(m.content)) return [];
+  if (LINE_BREAKS.has(m.content)) return textAt(m, LINE_BREAK);
+  if (TRANSPARENT.has(m.content))
+    return segmentsOf(mandatory(m).at(-1)?.content);
+  return textAt(m, OPAQUE);
+}
+
+/** A piece of text at the start of a node. */
+const textAt = (n: Node, text: string): readonly Segment[] =>
+  inPlace(placeOf(n), (s) => [{ text, at: s.start }]);
+
+/** What one node says in a title: text as itself, a formatting command's words, anything else opaque. */
+function nodeSegments(n: Node): readonly Segment[] {
+  if (n.type === "string") return textAt(n, stringText(n.content));
+  if (n.type === "whitespace" || n.type === "parbreak") return textAt(n, " ");
+  // A comment ends its line: the words on either side of it are two words.
+  if (n.type === "comment") return textAt(n, " ");
+  if (n.type === "group") return segmentsOf(n.content);
+  if (n.type === "macro") return macroSegments(n);
+  return textAt(n, OPAQUE);
+}
+
+/**
+ * A group that is the very next node after a command the parser has no signature for (`\ours{…}`, a macro of the
+ * author's own): the parser leaves such a group beside the macro, but TeX hands it to the macro as an
+ * argument, so it is part of what the macro prints and not words of the title. A chain of groups
+ * (`\findingdes{label}{a sentence}`) is all argument.
+ */
+function isArgumentGroup(nodes: readonly Node[], n: Node, i: number): boolean {
+  const prev = nodes[i - 1];
+  if (prev === undefined || n.type !== "group") return false;
+  return prev.type === "macro"
+    ? isOpaqueMacro(prev)
+    : isArgumentGroup(nodes, prev, i - 1);
+}
+
+const segmentsOf = (nodes: readonly Node[] | undefined): readonly Segment[] => {
+  const list = nodes ?? [];
+  return list.flatMap((n, i) =>
+    isArgumentGroup(list, n, i) ? [] : nodeSegments(n),
+  );
+};
+
+/** One argument's contents → the heading it makes, or none when it says nothing. */
+function titled(
+  command: TitledCommand,
+  argument: TitleArgument,
+  nodes: readonly Node[] | undefined,
+): readonly TitledHeading[] {
+  const segments = segmentsOf(nodes);
+  return hasAtLeast(segments, 1)
+    ? [{ command, argument, title: { segments } }]
+    : [];
+}
+
+/** One titled command → the short title (`[…]`) and the title (the last `{…}`), each judged. */
+const headingsOfMacro = (m: Macro): readonly TitledHeading[] =>
+  commandOf(m).flatMap((command) => [
+    ...titled(command, "short", optional(m)?.content),
+    ...titled(command, "title", mandatory(m).at(-1)?.content),
+  ]);
+
+/**
+ * The paper's `\title` and every `\section`, `\subsection`, `\subsubsection`, `\paragraph` and
+ * `\subparagraph`, starred or not, each with its optional short title, in document order. What the
+ * PDF never shows is pruned (`isUnrendered`), and so is a macro definition's body: a heading in a
+ * comment environment or in a definition is not a heading where it is written.
+ */
+export const headingsOf = (t: ParsedTex): readonly TitledHeading[] =>
+  visited(t.root, (v, parent) => isUnrendered(v, parent) || isDefinition(v))
+    .filter(isNode)
+    .flatMap((n) => (n.type === "macro" ? headingsOfMacro(n) : []));

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

@@ -324,6 +324,71 @@ describe("outlineOf — a heading that is never rendered is not in the outline",
   });
 });
 
+describe("\\iffalse … \\fi — a branch TeX never reads is not in the tree any reader walks", () => {
+  const dead = [
+    "A",
+    "\\iffalse",
+    "\\section{Old Title}",
+    "dead words",
+    "\\ifx\\a\\b nested\\fi",
+    "still dead",
+    "\\fi",
+    "B",
+  ].join("\n");
+  const doc = (body: string) => `\\begin{document}\n${body}\n\\end{document}`;
+
+  it("🔴 outline, headings and rendered text skip it, nested conditionals included", () => {
+    const t = parseLatex(doc(dead));
+    expect(outlineOf(t).sections).toEqual([]);
+    expect(latexReader.headings(doc(dead))).toEqual([]);
+    // Guards: the dead strings are gone from the list itself, so A and B are one run.
+    expect(
+      renderedRuns(t).map((r) => runText(r).replace(/\s+/gu, " ").trim()),
+    ).toEqual(["A B"]);
+  });
+
+  it("the \\else branch of an \\iffalse is read, and the text after its \\fi", () => {
+    const src = doc(
+      "\\iffalse\n\\section{Old}\n\\else\n\\section{New}\n\\fi\n\\section{After}",
+    );
+    expect(outlineOf(parseLatex(src)).sections.map((h) => h.title)).toEqual([
+      "New",
+      "After",
+    ]);
+  });
+
+  it("inside a group too, and `\\ifthenelse` (which has no \\fi) does not swallow the rest", () => {
+    const src = doc(
+      "{\\iffalse\\section{Old}\\ifthenelse{x}{y}{z}\\fi}\\section{Real}",
+    );
+    expect(outlineOf(parseLatex(src)).sections.map((h) => h.title)).toEqual([
+      "Real",
+    ]);
+  });
+
+  it("inside an environment with arguments, in math, and an \\else holding its own conditional", () => {
+    const src = doc(
+      [
+        "\\begin{minipage}{4cm}\\iffalse\\section{Old}\\fi\\section{Kept}\\end{minipage}",
+        "$x \\iffalse y \\fi$ \\[ z \\] \\begin{align*} a \\end{align*}",
+        "\\iffalse\\section{Old}\\else\\ifx\\a\\b\\section{Inner}\\fi\\section{New}\\fi",
+      ].join("\n"),
+    );
+    expect(outlineOf(parseLatex(src)).sections.map((h) => h.title)).toEqual([
+      "Kept",
+      "Inner",
+      "New",
+    ]);
+  });
+
+  it("an \\iffalse that is never closed leaves out everything after it, as TeX does", () => {
+    const src = doc("\\section{Real}\n\\iffalse\n\\section{Old}");
+    expect(outlineOf(parseLatex(src)).sections.map((h) => h.title)).toEqual([
+      "Real",
+    ]);
+  });
+});
+
 describe("renderedRuns", () => {
   it("runs of strings and spaces, each character mapped to its source offset", () => {
     const src = "A~B \\emph{C D}\n\n E";

package/src/adapters/latex/index.ts

@@ -26,6 +26,7 @@ import {
   parseTemplate,
   replaceDocumentClass,
 } from "./document-class.ts";
+import { headingsOf } from "./headings.ts";
 import { documentBodyOf, includesOf } from "./includes.ts";
 import { outlineOf } from "./outline.ts";
 import { parseLatex } from "./parse.ts";
@@ -48,6 +49,7 @@ export {
   textOf,
 } from "./nodes.ts";
 export { documentBodyOf, includesOf } from "./includes.ts";
+export { headingsOf } from "./headings.ts";
 export { outlineOf } from "./outline.ts";
 export { parseLatex, type ParsedTex } from "./parse.ts";
 export { bodyEmphasis, bodyProse } from "./prose.ts";
@@ -58,6 +60,7 @@ export { layoutOverridesOf } from "./layout.ts";
 export const latexReader: LatexReader = {
   documentClass: (src) => documentClassOf(parseLatex(src)),
   outline: (src) => outlineOf(parseLatex(src)),
+  headings: (src) => headingsOf(parseLatex(src)),
   renderedRuns: (src) => renderedRuns(parseLatex(src)),
   bodyProse: (src) => bodyProse(parseLatex(src)),
   bodyEmphasis: (src) => bodyEmphasis(parseLatex(src)),

package/src/adapters/latex/parse.ts

@@ -12,6 +12,7 @@
 import type * as Ast from "@unified-latex/unified-latex-types";
 import { getParser } from "@unified-latex/unified-latex-util-parse";
 import { once } from "remeda";
+import { withoutFalseBranches } from "./conditionals.ts";
 
 const signed = (
   names: readonly string[],
@@ -133,9 +134,9 @@ const parser = once(() =>
   }),
 );
 
-/** A LaTeX source → its tree. */
+/** A LaTeX source → its tree, without the branches `\iffalse … \fi` hides (`conditionals.ts`). */
 export const parseLatex = (src: string): ParsedTex => ({
   src,
-  root: parser().parse(src),
+  root: withoutFalseBranches(src, parser().parse(src)),
   [PARSED]: true,
 });

package/src/build.ts

@@ -121,7 +121,7 @@ export interface PaperFacts {
     readonly name: string;
     readonly options: readonly string[];
   } | null;
-  /** The label of the venue preset `paperlint.json` extends, or null. */
+  /** The id of the venue preset `paperlint.json` extends (`agenticdev`), or null. */
   readonly venue: string | null;
   /** Paper-supplied build scripts found on disk — reported as ignored. */
   readonly ignoredScripts: readonly string[];
@@ -239,7 +239,7 @@ export function readFacts(paperDir: string): PaperFacts {
   return {
     main,
     documentclass: documentclassOf(ast),
-    venue: venue?.label ?? null,
+    venue: venue?.id ?? null,
     ignoredScripts: IGNORED_SCRIPTS.filter((s) =>
       existsSync(join(paperDir, s)),
     ),