paperlint 10.4.0 → 11.0.0

package/src/outputs-before-decision-rule.test.ts

@@ -10,7 +10,6 @@ import { expect, it } from "vitest";
 import { gitHistory } from "./adapters/git/index.ts";
 import {
   nodeFiles,
-  nodeListDir,
   nodeListEntries,
   spawnProcess,
 } from "./adapters/node/index.ts";
@@ -42,7 +41,6 @@ const T = (h: number): string =>
 const lint = (repo: string, file = "p/PIPELINE-STATUS.md"): string[] => {
   const rule = outputsBeforeDecisionRules({
     files: nodeFiles,
-    listDir: nodeListDir,
     entries: nodeListEntries,
     codec: studyRegistryCodec,
     git: gitHistory(spawnProcess(), { PATH: String(process.env.PATH) }),
@@ -204,3 +202,50 @@ it("never reads through a study folder that is a symbolic link", () => {
   // Guards: the outputs behind the link are not this paper's study; nothing is read through it.
   expect(lint(repo)).toEqual([]);
 });
+
+it("a plan that is a symbolic link declares no mode: the order of its study is not judged", () => {
+  const repo = join(root, "plan-link");
+  initRepo(repo);
+  mkdirSync(join(repo, "p/elsewhere"), { recursive: true });
+  writeFileSync(join(repo, "p/elsewhere/plan.json"), planText(planOf(DECIDED)));
+  mkdirSync(join(repo, S), { recursive: true });
+  symlinkSync("../../elsewhere/plan.json", join(repo, S, "plan.json"));
+  commit(
+    repo,
+    {
+      ...Object.fromEntries(
+        Object.entries(PAPER).filter(([k]) => k !== `${S}/plan.json`),
+      ),
+      [`${S}/RESULTS.md`]: "41 of 60\n",
+    },
+    T(9),
+  );
+  commit(repo, { [`${S}/decision.md`]: "exclude run 7\n" }, T(10));
+  // Guards: read through the link, the plan is a decide-first one and its output precedes its
+  // decision (`output-before-decision`); a link is read through by nothing, so the study declares no mode.
+  expect(lint(repo)).toEqual([]);
+});
+
+it("loud on a decision under a linked directory: git records the link, not the files behind it", () => {
+  const repo = join(root, "decision-dir-link");
+  initRepo(repo);
+  mkdirSync(join(repo, "p/elsewhere"), { recursive: true });
+  writeFileSync(join(repo, "p/elsewhere/decision.md"), "exclude run 7\n");
+  const file = "repro/P1-S01-outcome/sub/decision.md";
+  commit(
+    repo,
+    {
+      ...PAPER,
+      [`${S}/plan.json`]: planText(
+        planOf({ ...DECIDED, decision: { file, note: "n" } }),
+      ),
+    },
+    T(9),
+  );
+  symlinkSync("../../elsewhere", join(repo, S, "sub"));
+  commit(repo, {}, T(10));
+  commit(repo, { [`${S}/RESULTS.md`]: "41 of 60\n" }, T(11));
+  // Guards: the decision file exists, and is committed as a path through a link; the order proof
+  // would be read from the link's history. The study is reported instead.
+  expect(lint(repo)).toEqual(["decision-linked"]);
+});

package/src/outputs-before-decision-rule.ts

@@ -14,13 +14,9 @@
  * Reported on `PIPELINE-STATUS.md`, first line, like the other `repro/` rules.
  */
 import { basename, dirname, join } from "node:path";
+import { filter, map, pipe } from "remeda";
 import { callerPath } from "./caller-path.ts";
-import {
-  filesUnder,
-  modeStudies,
-  onDisk,
-  type StudyDeps,
-} from "./study-modes.ts";
+import { decisionEntry, modeStudies, type ModeStudy } from "./study-modes.ts";
 import {
   judgeOrder,
   orderMessage,
@@ -28,11 +24,15 @@ import {
   type OrderFinding,
 } from "./domain/decide-first.ts";
 import { REPRO_DIR } from "./domain/repro-layout.ts";
+import type { DecideFirst } from "./domain/study-mode.ts";
 import type {
   FolderRuleContext,
   FolderRuleModule,
 } from "./folder-venue-rule.ts";
 import type { GitOrder } from "./ports/git-history.ts";
+import type { StudyDeps } from "./ports/study-deps.ts";
+import { studyFolder } from "./study-folder.ts";
+import { registryOf } from "./study-registry-rule.ts";
 import { rulePageUrl } from "./venue-rules.ts";
 
 const STATUS_FILE = "PIPELINE-STATUS.md";
@@ -46,32 +46,41 @@ export interface OrderDeps extends StudyDeps {
 export const decideFirstStudies = (
   paper: string,
   deps: OrderDeps,
-): readonly DecideFirstStudy[] =>
-  modeStudies(paper, deps).flatMap(({ row, plan, mode, empty }) => {
-    // Only a ready plan decides: a draft may name no outputs, or an empty decision file.
-    if (mode.kind !== "decide_before_run" || empty.length > 0) return [];
-    const folder = join(paper, REPRO_DIR, row.folder);
-    const decision = join(paper, mode.decision.file);
-    const on = onDisk(decision, deps);
-    return [
-      {
+): readonly DecideFirstStudy[] => {
+  const reader = studyFolder(paper, deps);
+  return pipe(
+    modeStudies(registryOf(paper, deps), reader, deps.codec),
+    filter(isDecidedAndReady),
+    map(({ row, plan, mode }): DecideFirstStudy => {
+      const folder = join(paper, REPRO_DIR, row.folder);
+      const decision = join(paper, mode.decision.file);
+      const on = decisionEntry(reader, mode.decision.file);
+      return {
         id: row.id,
         folder: row.folder,
         plan,
         mode,
-        tree: filesUnder(folder, deps),
+        tree: reader.list(row.folder),
         facts:
-          on === "directory" || on === "symbolic link"
-            ? { kind: "not-a-file", what: on }
-            : deps.git.order(callerPath(folder), callerPath(decision)),
-      },
-    ];
-  });
+          on.kind === "ok"
+            ? deps.git.order(callerPath(folder), callerPath(decision))
+            : on,
+      };
+    }),
+  );
+};
+
+/** Only a ready plan decides: a draft may name no outputs, or an empty decision file. */
+const isDecidedAndReady = (
+  s: ModeStudy,
+): s is ModeStudy & { readonly mode: DecideFirst } =>
+  s.mode.kind === "decide_before_run" && s.empty.length === 0;
 
 const PROBLEMS: readonly OrderFinding["problem"][] = [
   "decision-is-output",
   "decision-deleted",
   "decision-not-file",
+  "decision-linked",
   "no-history",
   "shallow",
   "undecided-output",

package/src/paper-settings.test.ts

@@ -33,6 +33,7 @@ describe("parsePaperSettings", () => {
         identity: null,
         talk: null,
         submission: null,
+        authors: null,
         cycles: null,
       },
     });
@@ -46,6 +47,7 @@ describe("parsePaperSettings", () => {
         identity: null,
         talk: null,
         submission: null,
+        authors: null,
         cycles: null,
       },
     });
@@ -62,6 +64,7 @@ describe("parsePaperSettings", () => {
         identity: null,
         talk: null,
         submission: null,
+        authors: null,
         cycles: null,
       },
     });
@@ -69,6 +72,15 @@ describe("parsePaperSettings", () => {
 });
 
 describe("parsePaperSettings — optional keys", () => {
+  it("reads authors, in order, an absent affiliation as null", () => {
+    const r = parsePaperSettings({
+      authors: [{ name: "Ada", email: "ada@example.org" }],
+    });
+    expect(r.ok && r.value.authors).toEqual([
+      { name: "Ada", email: "ada@example.org", affiliation: null },
+    ]);
+  });
+
   it("accepts $comment, JSON Schema's comment keyword, and ignores it", () => {
     expect(
       parsePaperSettings({ extends: "paperlint:aisec", $comment: "why" }).ok,
@@ -107,6 +119,11 @@ describe("parsePaperSettings — optional keys", () => {
       /"papersDir" is a project setting — set it in the root paperlint\.json/,
     ],
     ["not an object at all", ["aisec"], /must be a JSON object/],
+    [
+      "authors that are not a list of authors",
+      { authors: [{ name: "A" }] },
+      /"authors"\[0\]: "email" must be an email address/,
+    ],
   ])("refuses %s", (_, json, why) => {
     const r = parsePaperSettings(json);
     expect(r.ok).toBe(false);
@@ -167,6 +184,7 @@ const UNSET = {
   identity: null,
   talk: null,
   submission: null,
+  authors: null,
   cycles: null,
 };
 
@@ -224,6 +242,7 @@ describe("readPaperSettings — the root paperlint.json's defaults, the paper's
       identity: null,
       talk: null,
       submission: null,
+      authors: null,
       cycles: null,
     });
   });
@@ -274,6 +293,7 @@ describe("paperRules — `rules` in paperlint.json", () => {
     identity: null,
     talk: null,
     submission: null,
+    authors: null,
     cycles: null,
   });
 

package/src/paper-settings.ts

@@ -4,7 +4,7 @@
  * One file name at two levels, one schema (lib/paper-config.mjs → SETTINGS_KEYS):
  *
  *   paperlint.json                 the project (optional): papersDir, rules, defaults
- *   <paper>/paperlint.json         this paper: { extends, kind, pdf, rules, identity, talk, submission } —
+ *   <paper>/paperlint.json         this paper: { extends, kind, pdf, rules, identity, talk, submission, authors } —
  *                                  or `cycles`, from whose current attempt extends, kind and submission
  *                                  are DERIVED (src/domain/cycle.ts); the two forms do not mix
  *   a venue preset                 `paperlint:<name>` (shipped) or `./x.jsonc` (src/presets.ts)
@@ -35,7 +35,9 @@ import {
 import { messageOf } from "./domain/text.ts";
 import { parsePaperTalk, type PaperTalk } from "./domain/talk.ts";
 import {
+  parsePaperAuthors,
   parsePaperSubmission,
+  type Author,
   type PaperSubmission,
 } from "./domain/submission.ts";
 import {
@@ -69,6 +71,8 @@ export interface PaperSettings {
   readonly talk: PaperTalk | null;
   /** Which submission on the venue's portal is this paper's; null when it says none. Never the root's. */
   readonly submission: PaperSubmission | null;
+  /** The authors as the venue's portal should record them, in order; null when the paper declares none. Never the root's. */
+  readonly authors: readonly Author[] | null;
   /**
    * The paper's attempts at venues and the current one, when the file declares `cycles`; null for a
    * file in the flat form. With cycles, `extends`, `kind` and `submission` above are the current
@@ -133,10 +137,13 @@ export function identityField(
       );
 }
 
-/** `rules` (checked for shape only), `talk` and `submission`, each null when absent. */
+/** `rules` (checked for shape only), `talk`, `submission` and `authors`, each null when absent. */
 function rulesAndTalk(
   json: Readonly<Record<string, unknown>>,
-): Result<Pick<PaperSettings, "rules" | "talk" | "submission">, string> {
+): Result<
+  Pick<PaperSettings, "rules" | "talk" | "submission" | "authors">,
+  string
+> {
   const rules = json["rules"];
   if (rules !== undefined && !isObject(rules) && !Array.isArray(rules))
     return err(
@@ -145,13 +152,16 @@ function rulesAndTalk(
   const talk = parsePaperTalk(json["talk"]);
   if (!talk.ok) return talk;
   const submission = parsePaperSubmission(json["submission"]);
-  return submission.ok
+  if (!submission.ok) return submission;
+  const authors = parsePaperAuthors(json["authors"]);
+  return authors.ok
     ? ok({
         rules: rules ?? null,
         talk: talk.value,
         submission: submission.value,
+        authors: authors.value,
       })
-    : submission;
+    : authors;
 }
 
 /** The keys the current cycle supplies: writing one beside `cycles` is a second source for it. */
@@ -323,6 +333,7 @@ function merge(
     rules: null,
     talk: null,
     submission: null,
+    authors: null,
     cycles: null,
   };
   const merged: PaperSettings = {
@@ -333,6 +344,7 @@ function merge(
     identity: joined(r.identity, p.identity),
     talk: p.talk,
     submission: p.submission,
+    authors: p.authors,
     cycles: p.cycles,
   };
   return paper === null && Object.values(merged).every((v) => v === null)

package/src/ports/latex.ts

@@ -3,6 +3,7 @@
  * parser. The one implementation is `src/adapters/latex/` (unified-latex); `src/cli.ts` wires it.
  */
 import type { Include } from "../domain/paper-source.ts";
+import type { Result } from "../domain/result.ts";
 import type {
   ClassLine,
   DocumentClass,
@@ -25,6 +26,24 @@ export interface Filecontents {
   readonly body: Span;
 }
 
+/** Why a source's abstract cannot be read as plain text. */
+export type AbstractProblem =
+  | { readonly kind: "none" }
+  | {
+      readonly kind: "unreadable";
+      /** What it is, in words: `\toolname, which no \newcommand … defines`. */
+      readonly what: string;
+      /** Its offset in the source. */
+      readonly at: number;
+    }
+  | {
+      /** A macro the abstract uses that the source defines more than once: which one TeX uses is not guessed. */
+      readonly kind: "redefined";
+      readonly name: string;
+      /** Each definition's offset in the source, in order. */
+      readonly at: readonly number[];
+    };
+
 export interface LatexReader {
   /** The source's `\documentclass`, as one of its states. */
   readonly documentClass: (src: string) => ClassLine;
@@ -74,4 +93,10 @@ export interface LatexReader {
     src: string,
     jobname: string,
   ) => readonly Filecontents[];
+  /**
+   * The body of `src`'s `abstract` environment as one paragraph of plain text — the author's
+   * argument-less macros expanded, TeX's dashes and quotes, citations and comments dropped — or
+   * what stops it, with its offset in `src`.
+   */
+  readonly abstractText: (src: string) => Result<string, AbstractProblem>;
 }

package/src/ports/list-entries.ts

@@ -1,17 +1,20 @@
 /**
  * A directory's entries with what each one is, read without following a symbolic link — so a walk
  * that descends only into `dir` entries can neither loop on a link to an ancestor nor wander into a
- * tree outside through one. The walker of a study's folder (`src/study-modes.ts`) reads with it.
+ * tree outside through one. The reader of a study's folder
+ * (`src/study-folder.ts`), outputs listing included (`StudyFolder.list`), reads with it.
  */
 import type { AbsolutePath } from "../domain/paths.ts";
 
 /**
- * One entry of a directory: a directory, a symbolic link (not followed), or a file — anything else on
- * disk (a socket, a FIFO) reads as a file: a name, never descended into.
+ * One entry of a directory: a regular file, a directory, a symbolic link (not followed), or `other` —
+ * anything that is none of those (a FIFO, a socket, a device). An `other` entry is a name and nothing
+ * more: it is never read (opening a FIFO blocks) and never descended into, and an outputs listing
+ * still names it.
  */
 export interface DirEntry {
   readonly name: string;
-  readonly kind: "file" | "dir" | "symlink";
+  readonly kind: "file" | "dir" | "symlink" | "other";
 }
 
 /** The entries of `dir`; none when it does not exist or is not a directory. */

package/src/ports/study-deps.ts

@@ -0,0 +1,14 @@
+/**
+ * What the readers of a paper's studies are handed: the disk, the entries of a directory with what
+ * each is (no symbolic link followed), and the parsers of the registry and its plans. The study folder's
+ * reader (`src/study-folder.ts`), the gate and the order rule are built from it.
+ */
+import type { Files } from "./files.ts";
+import type { ListEntries } from "./list-entries.ts";
+import type { StudyRegistryCodec } from "./study-registry-codec.ts";
+
+export interface StudyDeps {
+  readonly files: Files;
+  readonly entries: ListEntries;
+  readonly codec: StudyRegistryCodec;
+}

package/src/ports/study-folder.ts

@@ -0,0 +1,38 @@
+/**
+ * The reads a paper's study folders allow, shaped by what the study readers need: a row's folder is
+ * entered or refused, a path inside it is located or read, the files under it are listed, and the
+ * decision file's path is walked — none of it by following a symbolic link. The reader of every plan,
+ * result file, output listing and decision (`src/study-folder.ts`) is this port's one implementation.
+ */
+import type { Located } from "../domain/study-registry.ts";
+
+/** What reading a path inside a study's folder gave. */
+export type FolderRead =
+  | { readonly kind: "text"; readonly text: string }
+  | { readonly kind: "absent" }
+  | { readonly kind: "linked"; readonly link: string };
+
+/** What a path in the paper is: `Located`, a directory, or something that is no regular file (a FIFO, a socket). */
+export type PathEntry =
+  Located | { readonly kind: "dir" } | { readonly kind: "other" };
+
+/** Why a row's folder may not be entered: it is no one folder inside `repro/`, or it is a link. */
+export type FolderRefusal = "not-a-folder" | "symbolic-link";
+
+/** The reads a paper's study folders allow. */
+export interface StudyFolder {
+  /** Why `folder` may not be entered; null when it may. */
+  readonly refusal: (folder: string) => FolderRefusal | null;
+  /** What `path` in `folder` is; nothing is read. */
+  readonly locate: (folder: string, path: string) => Located;
+  /** The text of the file at `path` in `folder`. */
+  readonly read: (folder: string, path: string) => FolderRead;
+  /**
+   * Every file under `folder`, relative to it and `/`-separated: a symbolic link is listed as a file
+   * (git stores it as one) and never descended into; a FIFO or a socket is listed by name too (it is
+   * never read). None for a folder that may not be entered.
+   */
+  readonly list: (folder: string) => readonly string[];
+  /** What `path`, relative to the paper, is: a decision file is held to be a regular file. */
+  readonly entryAt: (path: string) => PathEntry;
+}

package/src/ports/submission-portal.ts

@@ -1,10 +1,13 @@
 /**
  * A conference portal holding a paper's submission — the port `paperlint submission` talks through.
- * Shaped by what the command needs (read one submission, send one change), not by any portal's API;
+ * Shaped by what the command needs (read one submission, send one change, create one), not by any
+ * portal's API;
  * one adapter per portal kind (`src/adapters/hotcrp/`).
  */
 import type { Result } from "../domain/result.ts";
 import type {
+  CreateOutcome,
+  NewSubmission,
   PortalFailure,
   SubmissionChange,
   SubmissionView,
@@ -23,4 +26,43 @@ export interface SubmissionPortal {
     change: SubmissionChange,
     o: { readonly save: boolean },
   ): Promise<Result<UpdateOutcome, PortalFailure>>;
+  /**
+   * Create a submission. Without `save` the portal only checks it (a dry run), keeps nothing and
+   * chooses no id; with it, the outcome carries the id the portal chose.
+   */
+  create(
+    paper: NewSubmission,
+    o: { readonly save: boolean },
+  ): Promise<Result<CreateOutcome, PortalFailure>>;
+}
+
+/** How an author makes a token for a portal site, in the words the command prints. */
+export interface CredentialHelp {
+  /** The site's page where tokens are made. */
+  readonly page: string;
+  /** Where that page is in the site's menus. */
+  readonly where: string;
+  /** The permissions to give the token, per subcommand. */
+  readonly scopes: string;
+}
+
+/**
+ * A portal site before any token — what the command needs to find one, to say how to make one, and
+ * to say what is left to do on the site — and the portal itself once there is a token. One adapter
+ * per portal kind supplies it; the app prints what it returns.
+ */
+export interface PortalSite {
+  /** The environment variable this site's token is read from. */
+  readonly tokenVariable: string;
+  /** The site-less variable no longer read: named when still set, never used. */
+  readonly siteLessVariable: string;
+  /** The shape of a site's variable, for a message about another site's. */
+  readonly variablePattern: string;
+  readonly credentials: CredentialHelp;
+  /** What `submission new` does not send: done on the site by the author. */
+  readonly siteOnly: readonly string[];
+  /** A submission's page on the site; null: the one just created, before it has a number. */
+  readonly submissionPage: (id: number | null) => string;
+  /** The portal, read and changed with `token`. */
+  readonly connect: (token: string) => SubmissionPortal;
 }

package/src/ports/venue-deadlines.ts

@@ -1,6 +1,6 @@
 /**
  * A venue's deadlines as its portal publishes them — the port the scheduled refresh of the shipped
- * presets reads through (`scripts/refresh-deadlines.ts`). Shaped by what the refresh needs (the
+ * presets reads through (`scripts/refresh-deadlines/`). Shaped by what the refresh needs (the
  * portal's deadlines, once), not by any portal's page; one adapter per portal kind
  * (`src/adapters/hotcrp/`).
  */

package/src/presets.test.ts

@@ -103,23 +103,26 @@ describe("shipped presets: paperlint:msr", () => {
       kind: "hotcrp",
       url: "https://msr2027.hotcrp.com",
     });
-    // The portal's deadlines, read 2026-10-05 off cassette/deadlines-msr2027.html's page.
+    // The portal's deadlines, read 2026-10-19 18:05 UTC off https://msr2027.hotcrp.com/deadlines:
+    // «Wednesday Oct 21, 2026, 7:59:59 AM EDT» (`"sub":1792583999`) and «Saturday Oct 24, 2026,
+    // 7:59:59 AM EDT» (#235).
     expect(r.value.deadlines).toEqual([
       {
         what: "submission",
-        at: "2026-10-20T04:00:00Z",
+        at: "2026-10-21T11:59:59Z",
         source: "portal",
         url: "https://msr2027.hotcrp.com/deadlines",
-        read: "2026-10-05",
+        read: "2026-10-19",
       },
       {
         what: "resubmission",
-        at: "2026-10-23T04:00:00Z",
+        at: "2026-10-24T11:59:59Z",
         source: "portal",
         url: "https://msr2027.hotcrp.com/deadlines",
-        read: "2026-10-05",
+        read: "2026-10-19",
       },
     ]);
+    expect(Date.parse("2026-10-21T11:59:59Z") / 1000).toBe(1792583999);
     // No rule turned on: the IEEE capitalization rule has not been read and quoted.
     expect(r.value.rules).toEqual({});
     expect(r.value.registerAnchors).toEqual([]);

package/src/presets.ts

@@ -406,8 +406,7 @@ export type ShippedVenue = Pick<
 >;
 
 /**
- * A resolved preset as a name knows it: its label, its aliases, its chain. Pure. (Not Remeda's
- * `pick`: the app layer may not import it — `boundaries/dependencies`, `APP_EXTERNALS`.)
+ * A resolved preset as a name knows it: its label, its aliases, its chain. Pure.
  */
 export const venueOf = ({
   label,

package/src/studies-index-modes.test.ts

@@ -98,7 +98,7 @@ it("refuses a registry whose row names a folder outside repro/, for index and fo
     { ...ROW, folder: "../x" },
   );
   const line =
-    "P1-S01 in papers/example/repro/studies.json names the folder `../x`, which is not one folder inside repro/: nothing is read or written through it. Give the row its own folder's name, then run this again.";
+    "P1-S01 in papers/example/repro/studies.json names the folder `../x`, which is not one folder inside papers/example/repro/: nothing is read or written through it. Give the row its own folder's name, then run this again.";
   const index = studies("index", escaping, { title: undefined });
   const added = studies("new", escaping, { title: "Second" });
   // Guards: nothing is written — no README, no new folder — when a row could lead outside the paper.
@@ -122,7 +122,7 @@ it("refuses a registry whose study folder is a symbolic link, for index", () =>
   expect([r.code, r.err, README in r.after]).toEqual([
     1,
     [
-      "P1-S01 in papers/example/repro/studies.json names the folder `P1-S01-outcome`, which is not one folder inside repro/: nothing is read or written through it. Give the row its own folder's name, then run this again.",
+      "P1-S01 in papers/example/repro/studies.json names the folder `P1-S01-outcome`, which is a symbolic link: nothing is read or written through it. Give the row a real folder inside papers/example/repro/, then run this again.",
     ],
     false,
   ]);

package/src/studies.ts

@@ -16,6 +16,7 @@
  * registry is refused with the file to write rather than given a guessed one.
  */
 import { join, relative, resolve } from "node:path";
+import { find, map, pipe } from "remeda";
 import { callerPath } from "./caller-path.ts";
 import type { AbsolutePath } from "./domain/paths.ts";
 import { README, REPRO_DIR } from "./domain/repro-layout.ts";
@@ -37,10 +38,12 @@ import {
   type StudyRegistry,
 } from "./domain/study-registry.ts";
 import type { Files } from "./ports/files.ts";
+import type { FolderRefusal } from "./ports/study-folder.ts";
 import type { StudyRegistryCodec } from "./ports/study-registry-codec.ts";
 import type { ListEntries } from "./ports/list-entries.ts";
 import type { ListDir } from "./ports/talk-media.ts";
-import { readableFolders, registryOf } from "./study-registry-rule.ts";
+import { registryOf } from "./study-registry-rule.ts";
+import { folderRefusalText, studyFolder } from "./study-folder.ts";
 import { runGate } from "./study-gate.ts";
 import { indexInputOf } from "./study-index-input.ts";
 import type { GitHistory, GitOrder } from "./ports/git-history.ts";
@@ -106,20 +109,26 @@ function registryIn(p: Paper, deps: StudiesDeps): StudyRegistry | Refusal {
   }
 }
 
-/** The refusal when a row names a folder that is not one inside `repro/`; null when none does. */
+/** The refusal when a row names a folder that may not be entered; null when none does. */
 function escaping(
   p: Paper,
   r: StudyRegistry,
   deps: StudiesDeps,
 ): Refusal | null {
-  const readable = readableFolders(p.dir, deps);
-  const s = r.studies.find((row) => !readable(row.folder));
-  return s === undefined
-    ? null
-    : refuse(
-        1,
-        `${s.id} in ${p.shown}/${REPRO_DIR}/${STUDIES_FILE} names the folder \`${s.folder}\`, which is not one folder inside ${REPRO_DIR}/: nothing is read or written through it. Give the row its own folder's name, then run this again.`,
-      );
+  const folder = studyFolder(p.dir, deps);
+  const found = pipe(
+    r.studies,
+    map((row) => ({ row, why: folder.refusal(row.folder) })),
+    find(
+      (x): x is typeof x & { readonly why: FolderRefusal } => x.why !== null,
+    ),
+  );
+  if (found === undefined) return null;
+  const { reason, fix } = folderRefusalText(found.why, p.shown);
+  return refuse(
+    1,
+    `${found.row.id} in ${p.shown}/${REPRO_DIR}/${STUDIES_FILE} names the folder \`${found.row.folder}\`, which ${reason}: nothing is read or written through it. ${fix}, then run this again.`,
+  );
 }
 
 const isRefusal = (v: unknown): v is Refusal =>