paperlint 2.0.0 → 2.1.0

package/src/tex-requirements.ts

@@ -20,12 +20,13 @@
  * allowed to know where this package is installed (rule 10).
  */
 // eslint-disable-next-line boundaries/dependencies -- legacy I/O, moves behind a port in #76
-import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { readFileSync, readdirSync } from "node:fs";
 import { createRequire } from "node:module";
 import { join } from "node:path";
 // eslint-disable-next-line boundaries/dependencies -- legacy layer, moves behind a port in #76
 import Ajv from "ajv";
 import { packageVenuesDir } from "../skills/paper-pipeline/scripts/consumer.mjs";
+import { PAPER_SETTINGS_FILE } from "../lib/paper-config.mjs";
 
 /** CTAN package name → the names that prove it is installed. */
 export type PackageProofs = Readonly<Record<string, readonly string[]>>;
@@ -78,18 +79,133 @@ function violations(file: string, v: Validate): string[] {
   );
 }
 
+/** One kind of paper a venue takes (`short`, `research`, …) and its page limits; null = not limited. */
+export interface KindLimits {
+  readonly bodyPagesMax: number | null;
+  readonly refPagesMax: number | null;
+}
+
+/**
+ * The format a venue's call for papers sets — what the `pdf/*` venue rules judge a built PDF
+ * against. Every field the profile leaves out is null, and a rule that finds null checks nothing:
+ * a profile that does not name a number never makes one up.
+ */
+export interface VenueFormat {
+  readonly pageWidthIn: number | null;
+  readonly pageHeightIn: number | null;
+  readonly columns: number | null;
+  readonly bodyPt: number | null;
+  readonly bodyPtTol: number | null;
+  readonly refPtMin: number | null;
+  readonly refPtMax: number | null;
+  /** The prefix a font name of the body text starts with (`LinLibertine`). */
+  readonly fontsText: string | null;
+  readonly fontsTitle: string | null;
+  readonly kinds: ReadonlyMap<string, KindLimits>;
+}
+
+/** Every format field a preset left out is null; a merge fills it from the parent. */
+export const NO_FORMAT: VenueFormat = {
+  pageWidthIn: null,
+  pageHeightIn: null,
+  columns: null,
+  bodyPt: null,
+  bodyPtTol: null,
+  refPtMin: null,
+  refPtMax: null,
+  fontsText: null,
+  fontsTitle: null,
+  kinds: new Map(),
+};
+
+/**
+ * One preset FILE, parsed — before its `extends` chain is resolved (`src/presets.ts` does that).
+ * A preset is a venue or a template family: `{ extends?, name?, template?, format?, tex?, rules? }`.
+ */
+export interface PresetFile {
+  /** The preset this one builds on: `paperlint:<name>` or a relative path. */
+  readonly extends: string | null;
+  /** A display name for messages; the file name otherwise. */
+  readonly name: string | null;
+  readonly template: string | null;
+  /** Null when the file declares no `tex` block (allowed only with `extends`). */
+  readonly tex: TexRequirements | null;
+  readonly format: VenueFormat;
+  /** rule id → ESLint entry, checked against the shipped rules where a config is built. */
+  readonly rules: Readonly<Record<string, unknown>>;
+}
+
+type KindsJson = Readonly<
+  Record<string, { body_pages_max?: number; ref_pages_max?: number }>
+>;
+
+/** A preset's `format` block after the schema accepted it. */
+interface FormatJson {
+  readonly page_w_in?: number;
+  readonly page_h_in?: number;
+  readonly columns?: number;
+  readonly body_pt?: number;
+  readonly body_pt_tol?: number;
+  readonly ref_pt_min?: number;
+  readonly ref_pt_max?: number;
+  readonly fonts_text?: string;
+  readonly fonts_title?: string;
+  readonly kinds?: KindsJson;
+}
+
+/** The preset's JSON after the schema accepted it — the shape `venue-profile.schema.json` allows. */
+interface PresetJson {
+  readonly extends?: string;
+  readonly name?: string;
+  readonly template?: string;
+  readonly tex?: Partial<TexRequirements>;
+  readonly format?: FormatJson;
+  readonly rules?: Readonly<Record<string, unknown>>;
+}
+
+/** An optional field as the typed preset holds it: absent is null. */
+const orNull = <T>(v: T | undefined): T | null => (v === undefined ? null : v);
+
+function kindsOf(k: KindsJson | undefined): ReadonlyMap<string, KindLimits> {
+  return new Map(
+    Object.entries(k ?? {}).map(([name, v]) => [
+      name,
+      {
+        bodyPagesMax: orNull(v.body_pages_max),
+        refPagesMax: orNull(v.ref_pages_max),
+      },
+    ]),
+  );
+}
+
+function formatOf(j: FormatJson = {}): VenueFormat {
+  return {
+    pageWidthIn: orNull(j.page_w_in),
+    pageHeightIn: orNull(j.page_h_in),
+    columns: orNull(j.columns),
+    bodyPt: orNull(j.body_pt),
+    bodyPtTol: orNull(j.body_pt_tol),
+    refPtMin: orNull(j.ref_pt_min),
+    refPtMax: orNull(j.ref_pt_max),
+    fontsText: orNull(j.fonts_text),
+    fontsTitle: orNull(j.fonts_title),
+    kinds: kindsOf(j.kinds),
+  };
+}
+
 /**
- * The text of one profile → its typed requirements, or an Error naming every problem.
+ * The text of one preset file → the typed file, or an Error naming every problem. The ONE parser
+ * of a preset: the toolchain reads its `tex`, the venue rules its `format`, the config its `rules`.
  *
  * @param text  the file's contents
  * @param file  the name to put in messages
  * @param dir   the directory holding the schema (the shipped venues directory by default)
  */
-export function parseProfile(
+export function parsePreset(
   text: string,
   file: string,
   dir: string = packageVenuesDir(),
-): TexRequirements {
+): PresetFile {
   const { config, error } = typescript().parseConfigFileTextToJson(file, text);
   if (error)
     throw new Error(
@@ -100,8 +216,38 @@ export function parseProfile(
     throw new Error(
       `${file} does not match ${SCHEMA_FILE}:\n  ${violations(file, validate).join("\n  ")}`,
     );
-  const tex = (config as { tex: Partial<TexRequirements> }).tex;
-  return { packages: tex.packages ?? {}, tools: tex.tools ?? {} };
+  const j = config as PresetJson;
+  return {
+    extends: orNull(j.extends),
+    name: orNull(j.name),
+    template: orNull(j.template),
+    tex: j.tex
+      ? { packages: j.tex.packages ?? {}, tools: j.tex.tools ?? {} }
+      : null,
+    format: formatOf(j.format),
+    rules: j.rules ?? {},
+  };
+}
+
+/** The text of one preset → the TeX requirements it declares itself (none without a `tex` block). */
+export function parseProfile(
+  text: string,
+  file: string,
+  dir: string = packageVenuesDir(),
+): TexRequirements {
+  return parsePreset(text, file, dir).tex ?? NO_REQUIREMENTS;
+}
+
+/**
+ * The file a venue's profile lives in, or null when the name cannot be a venue (the base set is a
+ * profile file but not a venue). Whether the file exists is the caller's question.
+ */
+export function profileFileOf(venue: string): string | null {
+  return venue === BASE_PROFILE.slice(0, -PROFILE_EXT.length) ||
+    venue.includes("/") ||
+    venue.includes("\\")
+    ? null
+    : `${venue}${PROFILE_EXT}`;
 }
 
 function readProfile(dir: string, file: string): TexRequirements {
@@ -141,41 +287,45 @@ export function packageNames(tex: TexRequirements): string[] {
 }
 
 /**
- * What ONE paper needs: the base set plus its venue's block. A paper with no venue, or a venue this
- * package has no profile for, gets the base set — and the source says which, so an ACM paper built
- * without `venue.json` is visibly running on the base set rather than silently.
+ * What ONE paper needs: the base set plus its venue preset's `tex` (the union over the preset's
+ * `extends` chain, resolved by `src/presets.ts`). A paper with no preset gets the base set, and the
+ * source says so, so an ACM paper built without a preset is visibly running on the base set.
  */
 export function requirementsFor(
-  venue: string | null,
+  preset: { readonly label: string; readonly tex: TexRequirements } | null,
   dir: string = packageVenuesDir(),
 ): PaperRequirements {
   const base = readProfile(dir, BASE_PROFILE);
-  if (venue === null)
-    return { source: "the base set (no venue.json)", tex: base };
-  const file = `${venue}${PROFILE_EXT}`;
-  if (
-    venue === BASE_PROFILE.slice(0, -PROFILE_EXT.length) ||
-    !existsSync(join(dir, file))
-  )
-    return {
-      source: `the base set (venue ${venue} has no profile in paperlint)`,
-      tex: base,
-    };
-  return {
-    source: `venue ${venue}`,
-    tex: mergeRequirements(base, readProfile(dir, file)),
-  };
+  return preset === null
+    ? {
+        source: `the base set (no venue preset in ${PAPER_SETTINGS_FILE})`,
+        tex: base,
+      }
+    : {
+        source: `venue ${preset.label}`,
+        tex: mergeRequirements(base, preset.tex),
+      };
 }
 
-/** Everything any profile declares — the set `paperlint toolchain` installs, so one tree builds any paper. */
-export function declaredUnion(dir: string = packageVenuesDir()): {
+/**
+ * Everything any shipped preset declares, plus `extra` — the resolved presets of the project's own
+ * papers, which may live outside the package. The set `paperlint toolchain` installs, so one tree
+ * builds any paper.
+ */
+export function declaredUnion(
+  dir: string = packageVenuesDir(),
+  extra: readonly TexRequirements[] = [],
+): {
   readonly tex: TexRequirements;
   readonly profiles: number;
 } {
   const venues = venueNames(dir);
-  const tex = venues.reduce(
+  const shipped = venues.reduce(
     (acc, v) => mergeRequirements(acc, readProfile(dir, `${v}${PROFILE_EXT}`)),
     readProfile(dir, BASE_PROFILE),
   );
-  return { tex, profiles: venues.length + 1 };
+  return {
+    tex: extra.reduce(mergeRequirements, shipped),
+    profiles: venues.length + 1,
+  };
 }

package/src/toolchain.harness.mjs

@@ -4,7 +4,7 @@
  * 🔴 NOT ONE BYTE OF TeX LIVE IS DOWNLOADED HERE. The mirror is a directory served by `file://`
  * URLs: the real `curl` fetches from it, the real `tar` lists and unpacks it, and the installer
  * 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 rpp's own download, fallback, unpack,
+ * `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.mjs`.
  *
@@ -78,22 +78,25 @@ check(
   ) === '["urw-base35"]',
 );
 check(
-  "cacheRoot: RPP_TEXLIVE_DIR wins",
-  T.cacheRoot({ RPP_TEXLIVE_DIR: "/ci/tl", XDG_CACHE_HOME: "/x" }, "/h") ===
-    "/ci/tl",
+  "cacheRoot: PAPERLINT_TEXLIVE_DIR wins",
+  T.cacheRoot(
+    { PAPERLINT_TEXLIVE_DIR: "/ci/tl", XDG_CACHE_HOME: "/x" },
+    "/h",
+  ) === "/ci/tl",
 );
 check(
   "cacheRoot: then XDG_CACHE_HOME",
-  T.cacheRoot({ XDG_CACHE_HOME: "/x" }, "/h") === "/x/rpp/texlive",
+  T.cacheRoot({ XDG_CACHE_HOME: "/x" }, "/h") === "/x/paperlint/texlive",
 );
 check(
   "cacheRoot: then ~/.cache",
-  T.cacheRoot({}, "/h") === "/h/.cache/rpp/texlive",
+  T.cacheRoot({}, "/h") === "/h/.cache/paperlint/texlive",
 );
 check(
-  "mirrorsFrom: RPP_CTAN_MIRROR is the ONLY mirror, trailing slash dropped",
-  JSON.stringify(T.mirrorsFrom({ RPP_CTAN_MIRROR: "https://m/tlnet/" })) ===
-    '["https://m/tlnet"]',
+  "mirrorsFrom: PAPERLINT_CTAN_MIRROR is the ONLY mirror, trailing slash dropped",
+  JSON.stringify(
+    T.mirrorsFrom({ PAPERLINT_CTAN_MIRROR: "https://m/tlnet/" }),
+  ) === '["https://m/tlnet"]',
 );
 check(
   "mirrorsFrom: several defaults, every one https",
@@ -146,7 +149,9 @@ check(
 check("usableTree: an empty cache", T.usableTree([], () => true) === null);
 
 // ── the fake mirror ────────────────────────────────────────────────────────────────────
-const work = realpathSync(mkdtempSync(join(tmpdir(), "rpp-toolchain-h-")));
+const work = realpathSync(
+  mkdtempSync(join(tmpdir(), "paperlint-toolchain-h-")),
+);
 const good = join(work, "good");
 const garbage = join(work, "garbage");
 const staging = join(work, "staging", "install-tl-20260924");
@@ -259,14 +264,14 @@ const TEX = {
   tools: { texcount: ["texcount"] },
 };
 const root = join(work, "cache");
-// 🔴 banal goes into the work directory, never the developer's cache: without RPP_BANAL_DIR the
-// command installs into ~/.cache/rpp/banal, and a harness must not leave files in a home.
+// 🔴 banal goes into the work directory, never the developer's cache: without PAPERLINT_BANAL_DIR the
+// command installs into ~/.cache/paperlint/banal, and a harness must not leave files in a home.
 const banalDir = join(work, "banal");
 const env = {
   ...process.env,
-  RPP_TEXLIVE_DIR: root,
-  RPP_CTAN_MIRROR: url(good),
-  RPP_BANAL_DIR: banalDir,
+  PAPERLINT_TEXLIVE_DIR: root,
+  PAPERLINT_CTAN_MIRROR: url(good),
+  PAPERLINT_BANAL_DIR: banalDir,
 };
 // A stand-in banal: a Perl script that prints what banal prints for a one-page, 10 pt probe.
 const fakeBanal = join(work, "fake-banal");
@@ -446,7 +451,7 @@ const cmd = ({ banal = BANAL, ...over } = {}) => {
   const r = cmd({
     env: {
       ...env,
-      RPP_TEXLIVE_DIR: fresh,
+      PAPERLINT_TEXLIVE_DIR: fresh,
       FAKE_INSTALL_TL_FAIL: "1",
     },
   });
@@ -462,15 +467,15 @@ const cmd = ({ banal = BANAL, ...over } = {}) => {
   const r = cmd({
     env: {
       ...env,
-      RPP_TEXLIVE_DIR: join(work, "cache-nomirror"),
-      RPP_CTAN_MIRROR: MISSING,
+      PAPERLINT_TEXLIVE_DIR: join(work, "cache-nomirror"),
+      PAPERLINT_CTAN_MIRROR: MISSING,
     },
   });
   check(
     "no mirror answers: exit 1, names the mirrors and the override",
     r.code === 1 &&
       r.err.includes("no CTAN mirror returned install-tl") &&
-      r.err.includes("RPP_CTAN_MIRROR"),
+      r.err.includes("PAPERLINT_CTAN_MIRROR"),
     r.err,
   );
 }
@@ -520,7 +525,11 @@ const withLibertine = {
 };
 const inYears = (mirror, over = {}) =>
   cmd({
-    env: { ...env, RPP_TEXLIVE_DIR: years, RPP_CTAN_MIRROR: mirror },
+    env: {
+      ...env,
+      PAPERLINT_TEXLIVE_DIR: years,
+      PAPERLINT_CTAN_MIRROR: mirror,
+    },
     ...over,
   });
 check(
@@ -583,12 +592,12 @@ check(
 {
   // tlmgr says 2027, but the installer the mirrors hand out is still 2026.
   const split = join(work, "cache-split");
-  cmd({ env: { ...env, RPP_TEXLIVE_DIR: split } });
+  cmd({ env: { ...env, PAPERLINT_TEXLIVE_DIR: split } });
   const r = cmd({
     env: {
       ...env,
-      RPP_TEXLIVE_DIR: split,
-      RPP_CTAN_MIRROR: mirrorFor("split2027", "2027", "2026"),
+      PAPERLINT_TEXLIVE_DIR: split,
+      PAPERLINT_CTAN_MIRROR: mirrorFor("split2027", "2027", "2026"),
     },
     tex: withLibertine,
   });
@@ -606,7 +615,7 @@ check(
 // ── 4. banal, the second half of the command ───────────────────────────────────────────
 {
   const dir = join(work, "banal-4");
-  const e = { ...env, RPP_BANAL_DIR: dir };
+  const e = { ...env, PAPERLINT_BANAL_DIR: dir };
   const before = cmd({ env: e, check: true });
   // Guards: --check covers banal — a complete TeX Live alone must not read as a ready toolchain.
   check(
@@ -633,7 +642,7 @@ check(
 }
 {
   const r = cmd({
-    env: { ...env, RPP_BANAL_DIR: join(work, "banal-bad") },
+    env: { ...env, PAPERLINT_BANAL_DIR: join(work, "banal-bad") },
     banal: { ...BANAL, sha256: "0".repeat(64) },
   });
   // Guards: the two halves are independent — a banal failure fails the command, and TeX Live still

package/src/toolchain.ts

@@ -1,6 +1,6 @@
 /**
  * `paperlint toolchain` — install upstream TeX Live, with exactly the packages the venue profiles
- * declare, into rpp's own cache, and banal (the page-geometry script HotCRP runs) at its pinned
+ * declare, into paperlint's own cache, and banal (the page-geometry script HotCRP runs) at its pinned
  * commit (`adapters/banal/`). `paperlint build` offers the TeX Live install on a terminal.
  *
  * 🔴 WHY paperlint INSTALLS TeX AT ALL (rule 11). "Install TeX Live yourself" was a manual step with a
@@ -19,8 +19,8 @@
  *      once reported success having installed nothing: installers' exit codes are not evidence.)
  * A second run with everything present does nothing and says so; `--check` only reports.
  *
- * Where: `$RPP_TEXLIVE_DIR` when set (CI points its cache there), else
- * `$XDG_CACHE_HOME/rpp/texlive`, else `~/.cache/rpp/texlive` — one tree per TeX Live year inside.
+ * Where: `$PAPERLINT_TEXLIVE_DIR` when set (CI points its cache there), else
+ * `$XDG_CACHE_HOME/paperlint/texlive`, else `~/.cache/paperlint/texlive` — one tree per TeX Live year inside.
  * Processes run through the injected `run` (the port `build.ts` uses), so the harness drives the
  * real download/unpack/verify logic against a fake mirror on disk, never the network.
  */
@@ -56,8 +56,8 @@ import {
   type TexRequirements,
 } from "./tex-requirements.ts";
 
-export const CACHE_ENV = "RPP_TEXLIVE_DIR";
-export const MIRROR_ENV = "RPP_CTAN_MIRROR";
+export const CACHE_ENV = "PAPERLINT_TEXLIVE_DIR";
+export const MIRROR_ENV = "PAPERLINT_CTAN_MIRROR";
 
 /**
  * The CTAN mirrors, redirector first. 🔴 SEVERAL, AND THAT IS A MEASUREMENT: run 33650803245 died
@@ -99,7 +99,11 @@ export function cacheRoot(
   home: string = homedir(),
 ): string {
   if (env[CACHE_ENV]) return env[CACHE_ENV];
-  return join(env["XDG_CACHE_HOME"] || join(home, ".cache"), "rpp", "texlive");
+  return join(
+    env["XDG_CACHE_HOME"] || join(home, ".cache"),
+    "paperlint",
+    "texlive",
+  );
 }
 
 /**
@@ -353,7 +357,9 @@ export function installBase(
   mirrors: readonly string[],
   newerThan: string | null = null,
 ): Step<{ tree: CachedTree; mirror: string }> {
-  const work = realpathSync(mkdtempSync(join(tmpdir(), "rpp-install-tl-")));
+  const work = realpathSync(
+    mkdtempSync(join(tmpdir(), "paperlint-install-tl-")),
+  );
   try {
     io.log(`  downloading install-tl…`);
     const mirror = downloadInstaller(
@@ -409,7 +415,7 @@ function runInstallTl(
 ): Step<{ tree: CachedTree; mirror: string }> {
   const dir = join(a.root, a.year);
   mkdirSync(dir, { recursive: true });
-  const profile = join(a.work, "rpp.profile");
+  const profile = join(a.work, "paperlint.profile");
   writeFileSync(profile, tlProfile(dir));
   io.log(
     `  install-tl: TeX Live ${a.year} scheme-basic from ${a.mirror} (~150 MB, about a minute)…`,

package/src/types.ts

@@ -5,8 +5,8 @@ import type { RuleBlock } from "./rules-config.ts";
  * in someone's head: a typo in a config key read as "field not set", not as an error.
  */
 
-/** The contents of the consumer's `rpp.json`. */
-export interface RppConfig {
+/** The consumer's settings — the `paperlint` key of its `package.json`. */
+export interface PaperlintConfig {
   /** 🔴 REQUIRED. The paper director(ies), relative to the config file ITSELF. The field name is
    * `PAPERS_DIR_FIELD` in lib/paper-config.mjs; code reads it through `papersDirOf()` in cli.ts. */
   papersDir?: string | string[];
@@ -26,7 +26,7 @@ export interface RppConfig {
   structure?: StructureConfig | false;
   /** REMOVED — `paperlint build` compiles the paper itself. Still typed so a leftover key can be named. */
   buildScripts?: unknown;
-  /** ESLint config blocks appended after rpp's own — PARSED by `parseSettings` in cli.ts. */
+  /** ESLint config blocks appended after paperlint's own — PARSED by `parseSettings` in cli.ts. */
   rules?: readonly RuleBlock[];
 }
 
@@ -102,5 +102,5 @@ export interface BuildResult {
 
 /** The result of reading the config: either data, or the exit code the caller exits with. */
 export type ConfigRead =
-  | { opts: RppConfig; configPath: string | null; code?: undefined }
+  | { opts: PaperlintConfig; configPath: string | null; code?: undefined }
   | { code: number; opts?: undefined; configPath?: undefined };