paperlint 7.0.0 → 7.2.0

package/src/venue-rules.ts

@@ -37,6 +37,8 @@
  *   no geometry (no banal)  pdf/measured (warn); geometry and body-size silent, page-limit judges
  *                           only a body counted before the references; fonts still judge
  *   kind does not resolve   pdf/profile (error); page-limit silent; everything else still judges
+ *   cycle phase `porting`   every rule silent — the source is in the previous venue's template by
+ *                           declaration (src/domain/cycle.ts); cycle/port-done watches the declaration
  */
 import { dirname, isAbsolute, join, basename, relative } from "node:path";
 import {
@@ -58,8 +60,14 @@ import { fieldOf } from "./domain/record.ts";
 import type { Files } from "./ports/files.ts";
 import { CONFIG_FILE } from "#lib/paper-config";
 import { findLeaks, type Leak, type Searchable } from "./domain/anonymity.ts";
-import { bodyEnd, type BodyEnd } from "./domain/body-pages.ts";
+import {
+  bodyEnd,
+  pageSplit,
+  type BodyEnd,
+  type PageSplit,
+} from "./domain/body-pages.ts";
 import type { TextFacts } from "./facts-file.ts";
+import { effectiveBlind, isPorting } from "./domain/cycle.ts";
 
 // ── the verdict's vocabulary ─────────────────────────────────────────────────────────
 
@@ -91,8 +99,19 @@ export interface Resolved {
 export type Assessment =
   | { readonly kind: "no-venue" }
   /** A `paperlint.json` that extends no preset yet — `pdf/measured` names the file to set. */
-  | { readonly kind: "no-preset"; readonly file: string }
+  | {
+      readonly kind: "no-preset";
+      readonly file: string;
+      /** The paper keeps `cycles`: its venue is the current cycle's, and `extends` beside them is refused. */
+      readonly cycles: boolean;
+    }
   | { readonly kind: "unresolved"; readonly finding: Finding }
+  /**
+   * The current cycle declares its port to the venue's template as open work (`"phase": "porting"`):
+   * a PDF built with the previous venue's template says nothing about this venue's limits, so every
+   * venue rule is silent, and `cycle/port-done` speaks when the port is done and the phase still says so.
+   */
+  | { readonly kind: "porting" }
   | { readonly kind: "unbuilt"; readonly venue: Resolved }
   | { readonly kind: "stale"; readonly finding: Finding }
   | {
@@ -142,9 +161,13 @@ function kindOf(
 /** How the venue reviews, and who the paper says wrote it: what `anonymity/*` judges by. */
 const reviewOf = (
   preset: Pick<Preset, "blind">,
-  settings: Pick<PaperSettings, "identity">,
+  settings: Pick<PaperSettings, "identity" | "cycles">,
 ): Pick<Resolved, "blind" | "identity"> => ({
-  blind: preset.blind,
+  // An accepted attempt's camera-ready carries the authors: no longer blind.
+  blind: effectiveBlind(
+    preset.blind,
+    settings.cycles?.current ?? { kind: "none" },
+  ),
   identity: settings.identity,
 });
 
@@ -169,13 +192,25 @@ function freshFacts(
 
 const isFinding = (v: object): v is Finding => "messageId" in v;
 
+/** The paper's declared venue and kind, resolved: what the judges compare the facts against. */
+const resolvedOf = (preset: Preset, settings: PaperSettings): Resolved => ({
+  venue: preset.label,
+  format: preset.format,
+  ...kindOf(preset.label, preset.format, settings.kind),
+  ...reviewOf(preset, settings),
+});
+
 /** One paper, assessed. Reads through `deps.files` only; never throws on a paper's files. */
 export function assessPaper(paperDir: string, deps: VenueRuleDeps): Assessment {
   const p = paperPreset(paperDir, deps);
   if (p.kind === "none")
     return p.settings === null
       ? { kind: "no-venue" }
-      : { kind: "no-preset", file: join(paperDir, CONFIG_FILE) };
+      : {
+          kind: "no-preset",
+          file: join(paperDir, CONFIG_FILE),
+          cycles: p.settings.cycles !== null,
+        };
   if (p.kind === "settings-problem")
     return {
       kind: "unresolved",
@@ -186,13 +221,9 @@ export function assessPaper(paperDir: string, deps: VenueRuleDeps): Assessment {
       kind: "unresolved",
       finding: finding("preset", { why: presetProblemText(p.problem) }),
     };
-  const label = p.preset.label;
-  const venue: Resolved = {
-    venue: label,
-    format: p.preset.format,
-    ...kindOf(label, p.preset.format, p.settings.kind),
-    ...reviewOf(p.preset, p.settings),
-  };
+  if (p.settings.cycles !== null && isPorting(p.settings.cycles.current))
+    return { kind: "porting" };
+  const venue = resolvedOf(p.preset, p.settings);
   const factsText = text(deps.files, factsPath(paperDir));
   if (factsText === null) return { kind: "unbuilt", venue };
   const facts = freshFacts(deps.files, paperDir, factsText);
@@ -261,9 +292,19 @@ export function judgeGeometry(
   return out;
 }
 
+/**
+ * How many of banal's two counts — body, then references — a venue's counting replaces with its own
+ * from the text: none for banal's count, the body for `body_ends_at`, both with `appendix_in_body`.
+ */
+function countedFromText(format: VenueFormat): number {
+  if (format.bodyEndsAt !== "references") return 0;
+  return format.appendixInBody === true ? 2 : 1;
+}
+
 /**
  * Body and reference pages, as banal classifies them, against the kind's limits. A venue that counts
- * the body before the references is judged on its body by `judgeBodyEnd` instead.
+ * the body before the references is judged on its body by `judgeBodyEnd` instead, and one that
+ * counts the appendix as body on both.
  */
 export function judgePages(g: FlatGeometry, resolved: Resolved): Finding[] {
   const kind = resolved.kind;
@@ -272,7 +313,7 @@ export function judgePages(g: FlatGeometry, resolved: Resolved): Finding[] {
     [kind.limits.bodyPagesMax, g.body_pages, "body pages"],
     [kind.limits.refPagesMax, g.ref_pages, "reference pages"],
   ];
-  const from = resolved.format.bodyEndsAt === "references" ? 1 : 0;
+  const from = countedFromText(resolved.format);
   return pages.slice(from).flatMap(([max, got, what]) =>
     max !== null && got > max
       ? [
@@ -300,13 +341,11 @@ export function judgeBodyEnd(
   resolved: Resolved,
 ): readonly Finding[] {
   const kind = resolved.kind;
-  const max = kind?.limits.bodyPagesMax ?? null;
-  if (
-    resolved.format.bodyEndsAt !== "references" ||
-    kind === null ||
-    max === null
-  )
-    return [];
+  if (resolved.format.bodyEndsAt !== "references" || kind === null) return [];
+  if (resolved.format.appendixInBody === true)
+    return judgeSplit(text, resolved, kind);
+  const max = kind.limits.bodyPagesMax;
+  if (max === null) return [];
   const end = endOfBody(text);
   const venue = resolved.venue;
   switch (end.kind) {
@@ -324,6 +363,54 @@ export function judgeBodyEnd(
   }
 }
 
+/** The findings of a split that was found: the body, and the pages holding only references. */
+function splitFindings(
+  split: Extract<PageSplit, { readonly kind: "found" }>,
+  limits: KindLimits,
+  at: { readonly venue: string; readonly kind: string },
+): readonly Finding[] {
+  const refs = `the references on page ${String(split.page)}`;
+  const body =
+    split.appendixFrom === null
+      ? `body pages (up to ${refs}, appendices included)`
+      : `body pages (up to ${refs}, and the appendix from page ${String(split.appendixFrom)})`;
+  const counts: readonly [number | null, number, string][] = [
+    [limits.bodyPagesMax, split.bodyPages, body],
+    [limits.refPagesMax, split.refPages, "pages holding only references"],
+  ];
+  return counts.flatMap(([max, got, what]) =>
+    max !== null && got > max
+      ? [finding("pages", { what, got, max, ...at })]
+      : [],
+  );
+}
+
+/**
+ * The body, appendices included, and the pages holding only references (`appendix_in_body`),
+ * against the kind's two limits. Like `judgeBodyEnd`, an end it cannot find is said, not passed.
+ */
+function judgeSplit(
+  text: Pick<TextFacts, "pages" | "bibAnchorPage" | "appendixAnchorPage">,
+  resolved: Resolved,
+  kind: NonNullable<Resolved["kind"]>,
+): readonly Finding[] {
+  const limits = kind.limits;
+  if (limits.bodyPagesMax === null && limits.refPagesMax === null) return [];
+  const split = pageSplit(text.pages, {
+    bib: text.bibAnchorPage,
+    appendix: text.appendixAnchorPage,
+  });
+  const venue = resolved.venue;
+  switch (split.kind) {
+    case "missing":
+      return [finding("noReferences", { venue })];
+    case "disagree":
+      return [finding("unclear", { venue, why: disagreement(split) })];
+    case "found":
+      return splitFindings(split, limits, { venue, kind: kind.name });
+  }
+}
+
 /** Where the body ends in what the PDF says, and where hyperref anchored the two ends. */
 const endOfBody = (
   t: Pick<TextFacts, "pages" | "bibAnchorPage" | "appendixAnchorPage">,
@@ -497,7 +584,11 @@ const JUDGES: Readonly<Record<VenueRuleName, Judge>> = {
   fresh: (a) => (a.kind === "stale" ? [a.finding] : []),
   measured: (a, { shown }) =>
     a.kind === "no-preset"
-      ? [finding("noPreset", { file: shown(a.file) })]
+      ? [
+          finding(a.cycles ? "noPresetCycle" : "noPreset", {
+            file: shown(a.file),
+          }),
+        ]
       : a.kind === "unbuilt"
         ? [
             finding("unbuilt", {
@@ -594,6 +685,8 @@ const META: Readonly<Record<VenueRuleName, Meta>> = {
         "not built yet, so `{{venue}}`'s page limit, fonts and format are not checked — run `paperlint build`",
       noPreset:
         'this paper names no venue preset yet, so its page limit, fonts and format are not checked — set "extends" in {{file}} (e.g. "paperlint:agenticdev"; see docs/rules.md)',
+      noPresetCycle:
+        'this paper\'s current cycle names no venue preset, so its page limit, fonts and format are not checked — set the venue in the current cycle in {{file}} ("venue": { "kind": "preset", "extends": "paperlint:…" }), or open a new cycle when the last one has ended',
       noGeometry:
         "the build measured no page geometry (banal was not found or failed), so page size, columns, page limits and font sizes were NOT checked — run `paperlint toolchain`, then `paperlint build`",
     },