paperlint 6.2.2 → 6.3.0

package/src/folder-venue-rule.ts

@@ -0,0 +1,141 @@
+/**
+ * `paper/folder-venue-leftover` — a paper folder named after a venue the paper no longer targets.
+ *
+ * A folder named `aisec-2026` reads as "the AISec paper" for as long as it exists; once the paper is
+ * rejected and goes to another venue, the name is wrong and nothing says so. paperlint already knows
+ * the venue a paper targets — its `paperlint.json` `extends` — and the names of every venue it ships
+ * a preset for, so the stale case costs one comparison. The sibling of `tex/venue-leftover`, which
+ * does the same for the text of the paper.
+ *
+ * ── WHAT IT READS ────────────────────────────────────────────────────────────────
+ * The folder's name, as the path module gives it (the directory of the linted file), its words
+ * against each shipped venue's label and `aliases` (`src/domain/venue-name.ts`). The venues are
+ * `otherVenues` — the presets not on this paper's own chain, the same list `tex/venue-leftover`
+ * reads — and the paper's own label and aliases are never reported.
+ *
+ * ── WHICH FILE IT REPORTS ON ─────────────────────────────────────────────────────
+ * The folder itself is not a file ESLint lints. `PIPELINE-STATUS.md` is: every paper folder has one
+ * (`paperlint lint` requires it, `paperlint new` writes it), whatever the paper's source format, so
+ * the finding is made once per paper, on that file's first line, where a disable directive can
+ * also sit.
+ *
+ * ── WHO SPEAKS WHEN THERE IS NOTHING TO JUDGE ───────────────────────────────────
+ * No `paperlint.json`, no `extends`, or one that does not resolve: silent. With no venue chosen
+ * there is no "other" venue, and `pdf/measured` and `pdf/profile` already speak about the rest. An
+ * `extends` that names only a template family is silent too (`isFamily`).
+ */
+import { basename, dirname } from "node:path";
+import { venuesNamedBy, type NamedIn } from "./domain/venue-name.ts";
+import { paperPreset, type Preset } from "./presets.ts";
+import { otherVenues, type OtherVenue } from "./tex-venue-rules.ts";
+import type { Finding, VenueRuleDeps } from "./venue-rules.ts";
+
+/** The file the rule reports on: one per paper folder. */
+const STATUS_FILE = "PIPELINE-STATUS.md";
+
+/** The slice of ESLint's rule context this rule uses: the file, its first line, and `report`. */
+export interface FolderRuleContext {
+  readonly filename: string;
+  readonly sourceCode: {
+    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>>;
+  }): void;
+}
+
+export interface FolderRuleModule {
+  readonly meta: {
+    readonly type: "suggestion";
+    readonly docs: { readonly description: string; readonly url: string };
+    readonly schema: readonly object[];
+    readonly messages: Readonly<Record<string, string>>;
+  };
+  create(context: FolderRuleContext): { root?: () => void };
+}
+
+/** A venue as the message names it: its label, and the alias when the folder used another name. */
+const shown = (n: NamedIn): string =>
+  n.name.toLowerCase() === n.venue.toLowerCase()
+    ? n.venue
+    : `${n.venue} («${n.name}»)`;
+
+/**
+ * Each other venue the folder name names, as a finding. Pure: the folder's name, the paper's
+ * resolved preset, and the other shipped venues.
+ */
+export function judgeFolder(
+  folder: string,
+  preset: Pick<Preset, "label" | "aliases">,
+  others: readonly OtherVenue[],
+): readonly Finding[] {
+  return venuesNamedBy(folder, others, [preset.label, ...preset.aliases]).map(
+    (n) => ({
+      messageId: "leftover",
+      data: { folder, other: shown(n), venue: preset.label },
+    }),
+  );
+}
+
+/**
+ * A template family (`acm-sigconf`, `ieee-conference`): a preset with no kinds, which a paper for a
+ * venue paperlint has no preset for extends directly (`src/venue-rules.ts` reads it the same way).
+ * Such a paper declares a format, not a venue, so a venue in its folder name may be its own: the
+ * accepted ACSAC papers in `fixtures/accepted-papers/` extend `ieee-conference` from folders named
+ * `…-acsac24`, and ACSAC is the parent conference `aidc` names as an alias.
+ */
+const isFamily = (preset: Preset): boolean => preset.format.kinds.size === 0;
+
+/** The findings for the paper folder `dir`; none when it has no resolved venue, or only a family. */
+function findingsFor(dir: string, deps: VenueRuleDeps): readonly Finding[] {
+  const p = paperPreset(dir, deps);
+  if (p.kind !== "resolved" || isFamily(p.preset)) return [];
+  const others = otherVenues(p.preset, deps);
+  return judgeFolder(basename(dir), p.preset, others);
+}
+
+const META: FolderRuleModule["meta"] = {
+  type: "suggestion",
+  docs: {
+    description:
+      "the paper folder's name names a shipped venue other than the one the paper extends — a name left from an earlier submission",
+    url: "https://github.com/zernie/paperlint/blob/main/docs/rules/paper/folder-venue-leftover.md",
+  },
+  schema: [],
+  messages: {
+    leftover:
+      "the folder name «{{folder}}» names the venue {{other}}, and this paper extends {{venue}} — the name went stale when the venue changed, and venues change on every resubmission. Name the folder after the work (what the paper shows), not the venue",
+  },
+};
+
+/** The rule, reading the paper's settings and the shipped presets through `deps`. */
+export function folderVenueRules(
+  deps: VenueRuleDeps,
+): Readonly<Record<"folder-venue-leftover", FolderRuleModule>> {
+  return {
+    "folder-venue-leftover": {
+      meta: META,
+      create(context) {
+        if (basename(context.filename) !== STATUS_FILE) return {};
+        return {
+          root() {
+            const at = context.sourceCode.getLocFromIndex(0);
+            findingsFor(dirname(context.filename), deps).forEach((f) => {
+              context.report({ loc: { start: at, end: at }, ...f });
+            });
+          },
+        };
+      },
+    },
+  };
+}
+
+/** The level it is on at in paperlint's own config, for every paper's `PIPELINE-STATUS.md`. */
+export const FOLDER_VENUE_RULE_LEVELS: Readonly<
+  Record<"paper/folder-venue-leftover", "warn">
+> = { "paper/folder-venue-leftover": "warn" };

package/src/init.test.ts

@@ -37,6 +37,9 @@ import {
   workflowYaml,
 } from "./init.ts";
 import { runNode } from "../test/support.ts";
+import { nodeFiles } from "./adapters/node/index.ts";
+import { presetsDir } from "./package-dirs.ts";
+import { shippedVenueNames } from "./presets.ts";
 
 const dirs: string[] = [];
 afterEach(() => {
@@ -515,6 +518,25 @@ describe("paperlint init — a first paper", () => {
   });
 });
 
+describe("paperlint init — a first paper named after a venue", () => {
+  it("--paper aisec-2026 is refused before anything is asked, and createPaper is not called", async () => {
+    const made: string[] = [];
+    const asked: string[] = [];
+    const r = await initRun(tree({}), {
+      interactive: true,
+      paper: "aisec-2026",
+      venues: shippedVenueNames({ files: nodeFiles, venuesDir: presetsDir() }),
+      ask: (q) => Promise.resolve((asked.push(q), "")),
+      createPaper: (_root, name) => Promise.resolve((made.push(name), 0)),
+    });
+    expect(made).toEqual([]);
+    expect(asked.filter((q) => /format/.test(q))).toEqual([]);
+    expect(r.out[r.out.indexOf("first paper") + 1]).toBe(
+      '  ✗ no paper created — `aisec-2026` — the paper folder names a venue ("aisec"); venues change on resubmission, so name it after the work\n    if the venue really belongs in the name, rerun `paperlint new` with --allow-venue-name',
+    );
+  });
+});
+
 describe("paperlint init — paths are shown relative to where it was run", () => {
   it("a path that IS the working directory is shown whole, not as an empty string", async () => {
     const root = tree({ "papers/a/paper.md": "# a\n" });

package/src/init.ts

@@ -79,6 +79,7 @@ import {
 } from "#lib/paper-config";
 import { messageOf } from "./domain/text.ts";
 import { isRecord } from "./domain/record.ts";
+import type { NamedVenue } from "./domain/venue-name.ts";
 
 /** How the papers directory was arrived at. Printed, because a guess must not read as a fact. */
 export type PapersHow =
@@ -582,6 +583,11 @@ export interface InitOptions {
     name: string,
     format: PaperFormat,
   ) => Promise<number>;
+  /**
+   * The venues a paper name may not name (`shippedVenueNames`), so `--paper aisec-2026` is refused
+   * before anything is asked. `createPaper` refuses it again whatever this holds.
+   */
+  venues?: readonly NamedVenue[];
   run?: ProgramProbe;
   /**
    * What `paperlint lint` would resolve from the declaration, asked of the CLI's OWN reader. A second
@@ -713,6 +719,7 @@ export async function init(
     paper = null,
     format = null,
     createPaper,
+    venues = [],
     run = spawnSync,
     resolveCliPapers,
     link = (r: string) => linkSkills(r),
@@ -816,7 +823,7 @@ export async function init(
     wanted = answer ? answer : null;
   }
   if (wanted !== null && createPaper) {
-    const problem = nameProblem(wanted);
+    const problem = nameProblem(wanted, venues);
     let fmt: PaperFormat = format ?? DEFAULT_FORMAT;
     if (!problem && format === null && interactive) {
       const f = (
@@ -825,7 +832,7 @@ export async function init(
       if (isFormat(f)) fmt = f;
     }
     if (problem) {
-      log(`  ✗ ${problem} — no paper created`);
+      log(`  ✗ no paper created — ${problem}`);
       paperCode = 2;
     } else {
       const code = await createPaper(papersAbs, wanted, fmt);

package/src/new-paper.harness.mjs

@@ -75,22 +75,23 @@ try {
 
   // ── names ───────────────────────────────────────────────────────────────────────────
   for (const ok of ["demo", "aisec-2026", "v1.2_final"])
-    check(`\`${ok}\` is a valid name`, nameProblem(ok) === null);
+    check(`\`${ok}\` is a valid name`, nameProblem(ok, []) === null);
   for (const bad of ["Demo", "my paper", "a/b", "../x", "", "ÿ"])
-    check(`\`${bad}\` is refused`, typeof nameProblem(bad) === "string");
+    check(`\`${bad}\` is refused`, typeof nameProblem(bad, []) === "string");
   for (const dot of [".template", ".x", ".."])
     check(
       `\`${dot}\` is refused — discovery skips dot-directories, so it would never be linted`,
-      /starting with a dot/.test(nameProblem(dot) ?? ""),
+      /starting with a dot/.test(nameProblem(dot, []) ?? ""),
     );
   check(
     "a refused name creates nothing",
-    newPaper(work, "Bad", "tex").ok === false && !existsSync(join(work, "Bad")),
+    newPaper(work, "Bad", "tex", { venues: [] }).ok === false &&
+      !existsSync(join(work, "Bad")),
   );
 
   // ── a fresh LaTeX paper ─────────────────────────────────────────────────────────────
   const papers = join(work, "papers");
-  const r = newPaper(papers, "demo", "tex");
+  const r = newPaper(papers, "demo", "tex", { venues: [] });
   check(
     "a fresh folder gets the scorecard, a .tex source and paperlint.json, all from the package",
     r.ok &&
@@ -128,7 +129,7 @@ try {
 
   // ── never overwrite; on an existing folder only the missing files ─────────────────────
   writeFileSync(join(papers, "demo", STATUS_FILE), "mine\n");
-  const again = newPaper(papers, "demo", "md");
+  const again = newPaper(papers, "demo", "md", { venues: [] });
   check(
     "🔴 a second run overwrites nothing and adds no second source",
     again.ok &&
@@ -139,7 +140,7 @@ try {
   );
   mkdirSync(join(papers, "old"), { recursive: true });
   writeFileSync(join(papers, "old", "paper.md"), "# Old\n");
-  const migrated = newPaper(papers, "old", "tex");
+  const migrated = newPaper(papers, "old", "tex", { venues: [] });
   check(
     "an old folder with only paper.md gets ONLY the scorecard — that is the migration",
     migrated.ok &&
@@ -157,7 +158,7 @@ try {
   writeFileSync(join(papers, "afile"), "x");
   check(
     "a name taken by a FILE is refused, not written through",
-    newPaper(papers, "afile", "tex").ok === false,
+    newPaper(papers, "afile", "tex", { venues: [] }).ok === false,
   );
 
   // ── the project's template wins, file by file ─────────────────────────────────────────
@@ -166,7 +167,7 @@ try {
     join(papers, OVERRIDE_DIR, STATUS_FILE),
     "---\n---\n# House scorecard for {{name}}\n",
   );
-  const own = newPaper(papers, "house", "md");
+  const own = newPaper(papers, "house", "md", { venues: [] });
   // Guards: the override slot — `fromTemplate` in new-paper.ts reads `<papers>/.template/<file>`
   // before the package's copy. Replace that lookup with the package's alone and this goes red.
   check(
@@ -180,6 +181,7 @@ try {
 
   // ── a missing template is a broken install, not an empty file ─────────────────────────
   const broken = newPaper(join(work, "b"), "x", "tex", {
+    venues: [],
     packageTemplates: join(work, "no-such-dir"),
   });
   check(

package/src/new-paper.test.ts

@@ -6,6 +6,7 @@
 import {
   mkdirSync,
   mkdtempSync,
+  readdirSync,
   readFileSync,
   realpathSync,
   rmSync,
@@ -40,7 +41,7 @@ const settingsOf = (dir: string) =>
 describe("paperlint new — paperlint.json", () => {
   it("is always written, from the package template: no venue chosen yet, and valid", () => {
     const papers = join(tmp(), "papers");
-    const r = newPaper(papers, "demo", "tex");
+    const r = newPaper(papers, "demo", "tex", { venues: [] });
     expect(r.ok && r.files.find((f) => f.file === "paperlint.json")).toEqual({
       file: "paperlint.json",
       status: "created",
@@ -58,6 +59,7 @@ describe("paperlint new — paperlint.json", () => {
         rules: null,
         identity: null,
         talk: null,
+        submission: null,
       },
     });
   });
@@ -69,7 +71,7 @@ describe("paperlint new — paperlint.json", () => {
       join(papers, OVERRIDE_DIR, "paperlint.json"),
       '{ "extends": "paperlint:aisec", "kind": "research" }\n',
     );
-    const r = newPaper(papers, "house", "tex");
+    const r = newPaper(papers, "house", "tex", { venues: [] });
     expect(r.ok && r.files.find((f) => f.file === "paperlint.json")?.from).toBe(
       "project",
     );
@@ -86,7 +88,7 @@ describe("paperlint new — paperlint.json", () => {
       join(papers, "p", "paperlint.json"),
       '{"extends":"paperlint:aisec"}',
     );
-    const r = newPaper(papers, "p", "tex");
+    const r = newPaper(papers, "p", "tex", { venues: [] });
     expect(
       r.ok && r.files.find((f) => f.file === "paperlint.json")?.status,
     ).toBe("kept");
@@ -103,7 +105,7 @@ describe("paperlint lint — a paper with no venue preset chosen", () => {
       join(root, "package.json"),
       JSON.stringify({ name: "c", private: true }),
     );
-    newPaper(join(root, "papers"), "demo", "tex");
+    newPaper(join(root, "papers"), "demo", "tex", { venues: [] });
     if (extendsValue !== null)
       writeFileSync(
         join(root, "papers", "demo", "paperlint.json"),
@@ -140,7 +142,11 @@ describe("paperlint lint — a paper with no venue preset chosen", () => {
 });
 
 /** `paperlint new <args>` in a fresh project (not a terminal: vitest's stdin is not a TTY). */
-async function newIn(args: string[], files: Record<string, string> = {}) {
+async function newIn(
+  args: string[],
+  files: Record<string, string> = {},
+  name = "demo",
+) {
   const root = tmp();
   const all = {
     "package.json": JSON.stringify({ name: "c", private: true }),
@@ -152,12 +158,12 @@ async function newIn(args: string[], files: Record<string, string> = {}) {
   }
   const out: string[] = [];
   const err: string[] = [];
-  const code = await run(["new", "demo", ...args], {
+  const code = await run(["new", name, ...args], {
     cwd: root,
     log: (s: string) => out.push(s),
     err: (s: string) => err.push(s),
   });
-  const dir = join(root, "papers", "demo");
+  const dir = join(root, "papers", name);
   return {
     code,
     out: out.join("\n"),
@@ -286,6 +292,117 @@ describe("paperlint new --venue / --kind — refusals and defaults", () => {
   });
 });
 
+describe("paperlint new — a name that names a venue is refused", () => {
+  it.each<[string, string, string[], string]>([
+    [
+      "a venue's label, with the work's name left to suggest",
+      "aisec-agent-drift",
+      [],
+      '`aisec-agent-drift` — the paper folder names a venue ("aisec"); venues change on resubmission, so name it after the work (e.g. "agent-drift")',
+    ],
+    [
+      "nothing but a year left: no example",
+      "aisec-2026",
+      [],
+      '`aisec-2026` — the paper folder names a venue ("aisec"); venues change on resubmission, so name it after the work',
+    ],
+    [
+      "its own venue too: right today, stale on the next resubmission",
+      "aidc-2026",
+      ["--venue", "aidc"],
+      '`aidc-2026` — the paper folder names a venue ("aidc"); venues change on resubmission, so name it after the work',
+    ],
+    [
+      "by an alias, glued to a year",
+      "acsac2026-rules",
+      [],
+      '`acsac2026-rules` — the paper folder names a venue ("ACSAC"); venues change on resubmission, so name it after the work',
+    ],
+    [
+      "two venues",
+      "realm-aisec-rules",
+      [],
+      '`realm-aisec-rules` — the paper folder names a venue ("aisec", "realm"); venues change on resubmission, so name it after the work (e.g. "rules")',
+    ],
+  ])("%s: exit 2, nothing written", async (_, name, args, reason) => {
+    const r = await newIn(args, {}, name);
+    expect(r.code).toBe(2);
+    expect(r.out).toBe(
+      `  ✗ ${reason}\n    if the venue really belongs in the name, rerun \`paperlint new\` with --allow-venue-name`,
+    );
+    expect(existsSync(r.dir)).toBe(false);
+  });
+
+  it("an existing folder that names a venue gets no missing files either", async () => {
+    const r = await newIn(
+      [],
+      { "papers/aisec-2026/paper.tex": "x" },
+      "aisec-2026",
+    );
+    expect(r.code).toBe(2);
+    expect(readdirSync(r.dir)).toEqual(["paper.tex"]);
+  });
+
+  it.each(["agent-rule-drift", "overrealm-realms"])(
+    "%s names no venue: created, as before",
+    async (name) => {
+      const r = await newIn([], {}, name);
+      expect(r.out).not.toMatch(/names a venue/);
+      expect(existsSync(join(r.dir, "PIPELINE-STATUS.md"))).toBe(true);
+      expect(r.code).toBe(0);
+    },
+  );
+});
+
+describe("paperlint new --allow-venue-name", () => {
+  it("the folder is created as any other, and nothing is said about the venue", async () => {
+    const r = await newIn(["--allow-venue-name"], {}, "realm-of-agents");
+    expect(r.code).toBe(0);
+    expect(r.out).not.toMatch(/venue really belongs|names a venue/);
+    expect(readdirSync(r.dir).sort()).toEqual([
+      "PIPELINE-STATUS.md",
+      "paper.tex",
+      "paperlint.json",
+    ]);
+  });
+
+  it.each<{
+    readonly what: string;
+    readonly name: string;
+    readonly args: readonly string[];
+    readonly files: Record<string, string>;
+    readonly says: RegExp;
+  }>([
+    {
+      what: "an invalid name",
+      name: "Realm",
+      args: [],
+      files: {},
+      says: /may hold only a-z/,
+    },
+    {
+      what: "an unknown preset",
+      name: "realm-of-agents",
+      args: ["--venue", "nope"],
+      files: {},
+      says: /no such venue preset/,
+    },
+    {
+      what: "an existing paperlint.json with --venue",
+      name: "realm-of-agents",
+      args: ["--venue", "aisec"],
+      files: {
+        "papers/realm-of-agents/paperlint.json": '{ "extends": null }\n',
+      },
+      says: /already exists and is never overwritten/,
+    },
+  ])("skips no other refusal: $what", async ({ name, args, files, says }) => {
+    const r = await newIn(["--allow-venue-name", ...args], files, name);
+    expect(r.code).toBe(2);
+    expect(`${r.out}\n${r.err}`).toMatch(says);
+  });
+});
+
 describe("chooseVenue — on a terminal", () => {
   const at = (answers: string[]) => {
     const asked: string[] = [];
@@ -340,6 +457,7 @@ describe("a project's own template", () => {
     const src = join(papers, OVERRIDE_DIR, "paperlint.json");
     writeFileSync(src, '{\n  // our house venue\n  "extends": null\n}\n');
     const r = newPaper(papers, "p", "tex", {
+      venues: [],
       venue: { extends: "paperlint:aisec", kind: null },
     });
     expect(r).toEqual({
@@ -353,7 +471,10 @@ describe("a project's own template", () => {
     const papers = join(tmp(), "papers");
     mkdirSync(join(papers, OVERRIDE_DIR), { recursive: true });
     writeFileSync(join(papers, OVERRIDE_DIR, "paperlint.json"), "{}\n");
-    const lines = reportNewPaper(newPaper(papers, "p", "tex"), (p) => p);
+    const lines = reportNewPaper(
+      newPaper(papers, "p", "tex", { venues: [] }),
+      (p) => p,
+    );
     expect(lines).toContain(
       "      + paperlint.json  (from the project's .template/ template)",
     );

package/src/new-paper.ts

@@ -27,6 +27,11 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { CONFIG_FILE } from "#lib/paper-config";
 import { isRecord } from "./domain/record.ts";
+import {
+  venuesNamedBy,
+  withoutVenues,
+  type NamedVenue,
+} from "./domain/venue-name.ts";
 
 export type PaperFormat = "tex" | "md";
 export const FORMATS: readonly PaperFormat[] = ["tex", "md"];
@@ -50,6 +55,9 @@ export const SOURCE_FILE: Readonly<Record<PaperFormat, string>> = {
   md: "paper.md",
 };
 
+/** The flag that lets `paperlint new` create a folder whose name names a venue. */
+export const ALLOW_VENUE_NAME = "--allow-venue-name";
+
 export const isFormat = (v: unknown): v is PaperFormat =>
   FORMATS.some((f) => f === v);
 
@@ -57,13 +65,30 @@ export const isFormat = (v: unknown): v is PaperFormat =>
  * Why a name is refused, or null. `[a-z0-9._-]+` is the charset; a LEADING dot is refused on top
  * of it, because discovery skips dot-directories — a paper named `.x` would be created and then
  * never linted, which is worse than a refusal.
+ *
+ * A name that names a venue — one of `venues`' names as whole words (`aisec-2026`) — is refused
+ * too, the paper's own venue included: a paper that is rejected goes to another venue and keeps its
+ * folder, so the name goes stale, and nothing at creation time knows the paper will not move. A
+ * folder made by hand, and one made with `--allow-venue-name` (a whole word can be the work's own:
+ * a paper about realms), is what `paper/folder-venue-leftover` judges once the venue changes. The
+ * flag passes no `venues`, so it skips this refusal and no other.
  */
-export function nameProblem(name: string): string | null {
+export function nameProblem(
+  name: string,
+  venues: readonly NamedVenue[],
+): string | null {
   if (!/^[a-z0-9._-]+$/.test(name))
     return `\`${name}\` — a paper name may hold only a-z, 0-9, dot, underscore and hyphen (it becomes a path and a shell argument)`;
   if (name.startsWith("."))
     return `\`${name}\` — a name starting with a dot is skipped by paper discovery, so it would never be linted`;
-  return null;
+  const named = venuesNamedBy(name, venues);
+  if (named.length === 0) return null;
+  const which = named.map((n) => `"${n.name}"`).join(", ");
+  const instead = withoutVenues(name, venues);
+  return [
+    `\`${name}\` — the paper folder names a venue (${which}); venues change on resubmission, so name it after the work${instead === null ? "" : ` (e.g. "${instead}")`}`,
+    `    if the venue really belongs in the name, rerun \`paperlint new\` with ${ALLOW_VENUE_NAME}`,
+  ].join("\n");
 }
 
 export interface FileOutcome {
@@ -180,17 +205,23 @@ function fromTemplate(
     : edited;
 }
 
+/** What `newPaper` is told besides the name: the venues a name may not name, and what to write. */
+export interface NewPaperOptions {
+  readonly packageTemplates?: string;
+  readonly venue?: VenueSetting | null;
+  /** Every venue paperlint knows (`shippedVenueNames`): a name naming one is refused. */
+  readonly venues: readonly NamedVenue[];
+}
+
 // Documented in README.md#getting-started — update it when this changes.
 export function newPaper(
   papersRoot: string,
   name: string,
   format: PaperFormat,
-  {
-    packageTemplates = PACKAGE_TEMPLATES,
-    venue = null,
-  }: { packageTemplates?: string; venue?: VenueSetting | null } = {},
+  opts: NewPaperOptions,
 ): NewPaperResult {
-  const problem = nameProblem(name);
+  const { packageTemplates = PACKAGE_TEMPLATES, venue = null } = opts;
+  const problem = nameProblem(name, opts.venues);
   if (problem) return { ok: false, reason: problem };
   const dir = join(papersRoot, name);
   const fresh = !existsSync(dir);

package/src/paper-settings.test.ts

@@ -32,6 +32,7 @@ describe("parsePaperSettings", () => {
         rules: null,
         identity: null,
         talk: null,
+        submission: null,
       },
     });
     expect(parsePaperSettings({})).toEqual({
@@ -43,6 +44,7 @@ describe("parsePaperSettings", () => {
         rules: null,
         identity: null,
         talk: null,
+        submission: null,
       },
     });
   });
@@ -57,6 +59,7 @@ describe("parsePaperSettings", () => {
         rules: null,
         identity: null,
         talk: null,
+        submission: null,
       },
     });
   });
@@ -155,7 +158,13 @@ describe("readPaperSettings — a root paperlint.json that cannot be used", () =
 });
 
 /** The fields a case does not set. */
-const UNSET = { pdf: null, rules: null, identity: null, talk: null };
+const UNSET = {
+  pdf: null,
+  rules: null,
+  identity: null,
+  talk: null,
+  submission: null,
+};
 
 describe("readPaperSettings — the root paperlint.json's defaults, the paper's file over them", () => {
   const ROOT = "/work";
@@ -210,6 +219,7 @@ describe("readPaperSettings — the root paperlint.json's defaults, the paper's
       rules: { "pdf/fonts": "off" },
       identity: null,
       talk: null,
+      submission: null,
     });
   });
 
@@ -253,6 +263,7 @@ describe("paperRules — `rules` in paperlint.json", () => {
     rules,
     identity: null,
     talk: null,
+    submission: null,
   });
 
   it("no rules: none", () => {