paperlint 12.0.0 → 13.0.0

package/src/versions-command.ts

@@ -0,0 +1,360 @@
+/**
+ * `paperlint versions [show|lock|migrate] [paper]` — a paper's frozen versions, one folder per
+ * attempt (src/domain/versions.ts):
+ *
+ *   show      (the default) each attempt's frozen versions and what they are, newest first, then the
+ *             draft and how far it has moved from the version it is measured against
+ *   lock      record the files of versions/ in versions/lock.json: what `submission --save` did not
+ *             freeze — a file put there by hand, an arXiv copy, a recovered upload
+ *   migrate   from the `stages:` list and dated files to folders per attempt, once
+ *
+ * ── WHY ONE NOUN, THREE VERBS ───────────────────────────────────────────────────────────────
+ * docs/prior-art/multi-mode-tools.md: tools that stay small add verbs to a noun the project already
+ * has, not nouns. The table is also printed by `paperlint submission show`, beside the portal's copy;
+ * `versions` prints it without a token or a network call. `lock` is the `npm install` slot — make the
+ * generated file match the disk — and `migrate` runs once per paper.
+ */
+import { join, relative, resolve } from "node:path";
+import * as R from "remeda";
+import { callerPath } from "./caller-path.ts";
+import type { Cycles } from "./domain/cycle.ts";
+import { fieldOf, isRecord } from "./domain/record.ts";
+import { err, ok, type Result } from "./domain/result.ts";
+import { sha256Hex } from "./domain/sha256.ts";
+import {
+  frontmatterOf,
+  planMigration,
+  rehearse,
+  withoutStages,
+  type MigrationPlan,
+} from "./domain/versions-migration.ts";
+import {
+  frozenKey,
+  frozenName,
+  LOCK_FILE,
+  lockText,
+  relock,
+  type Lock,
+  type OnDisk,
+} from "./domain/versions.ts";
+import type { CopyFile, MoveFile } from "./ports/move-file.ts";
+import type { ParseYaml } from "./ports/yaml.ts";
+import type { ProseDeps } from "./tex-paper.ts";
+import {
+  cyclesIn,
+  entriesIn,
+  factsOfFrozen,
+  readLock,
+  versionLines,
+  versionsDir,
+  type VersionsDeps,
+} from "./versions.ts";
+
+const SUBS = ["show", "lock", "migrate"] as const;
+type Sub = (typeof SUBS)[number];
+const isSub = (s: unknown): s is Sub => SUBS.some((x) => x === s);
+
+const STATUS_FILE = "PIPELINE-STATUS.md";
+
+export interface VersionsCommandDeps extends ProseDeps, VersionsDeps {
+  readonly move: MoveFile;
+  readonly copy: CopyFile;
+  readonly yaml: ParseYaml;
+  /** The instant a lock entry records, ISO 8601. */
+  readonly now: () => string;
+  readonly cwd: string;
+  readonly log: (line: string) => void;
+  readonly err: (line: string) => void;
+}
+
+/** The words after `versions` → the subcommand, the paper folder, and what is left over. Pure. */
+export function versionsArgs(words: readonly string[]): {
+  readonly sub: Sub;
+  readonly paper: string;
+  readonly extra: readonly string[];
+} {
+  const [first, ...rest] = words;
+  const named = isSub(first);
+  const after = named ? rest : words;
+  return {
+    sub: named ? first : "show",
+    paper: after[0] ?? ".",
+    extra: after.slice(1),
+  };
+}
+
+/** The paper as a command line names it, from where the command runs. */
+const shown = (cwd: string, p: string): string => relative(cwd, p) || ".";
+
+const logAll = (lines: readonly string[], deps: VersionsCommandDeps): void => {
+  lines.forEach((l) => {
+    deps.log(l);
+  });
+};
+
+// ── lock ────────────────────────────────────────────────────────────────────────────────
+
+/** Every frozen file in the cycles' folders, with what it holds. */
+function onDisk(
+  paperDir: string,
+  cycles: Cycles,
+  deps: VersionsCommandDeps,
+): readonly OnDisk[] {
+  const root = versionsDir(paperDir);
+  const facts = factsOfFrozen(paperDir, deps.files);
+  return cycles.list.flatMap((c) =>
+    entriesIn(join(root, c.id), deps).flatMap((e) => {
+      const n = e.kind === "file" ? frozenName(e.name) : null;
+      return n === null
+        ? []
+        : [
+            {
+              key: frozenKey(c.id, n.stage, n.ext),
+              facts: facts(frozenKey(c.id, n.stage, n.ext)),
+            },
+          ];
+    }),
+  );
+}
+
+const writeLock = (
+  paperDir: string,
+  lock: Lock,
+  deps: VersionsCommandDeps,
+): void => {
+  deps.files.writeAtomic(
+    callerPath(join(versionsDir(paperDir), LOCK_FILE)),
+    new TextEncoder().encode(lockText(lock)),
+  );
+};
+
+function runLock(
+  paperDir: string,
+  cycles: Cycles,
+  deps: VersionsCommandDeps,
+): number {
+  const found = onDisk(paperDir, cycles, deps);
+  const old = readLock(paperDir, deps.files);
+  if (found.length === 0 && old === null)
+    return (deps.log("nothing frozen in versions/ — no lock to write"), 0);
+  const r = relock(found, old?.ok === true ? old.value : {}, deps.now());
+  writeLock(paperDir, r.lock, deps);
+  logAll(
+    [
+      ...(old?.ok === false
+        ? [
+            `versions/lock.json did not read (${old.error}): written anew from the files`,
+          ]
+        : []),
+      ...r.lines,
+    ],
+    deps,
+  );
+  if (old?.ok !== false && r.lines.length === 0)
+    deps.log("versions/lock.json records every frozen file as it stands");
+  return 0;
+}
+
+// ── migrate ─────────────────────────────────────────────────────────────────────────────
+
+/** What the scorecard holds for the migration: its `stages:` list, and its text without it (null: none to take out). */
+export interface Scorecard {
+  readonly stages: readonly unknown[];
+  readonly without: string | null;
+}
+
+/** The scorecard's text, "" when there is none. */
+const statusText = (paperDir: string, deps: VersionsCommandDeps): string =>
+  new TextDecoder().decode(
+    deps.files.readBytes(callerPath(join(paperDir, STATUS_FILE))) ??
+      new Uint8Array(),
+  );
+
+/** Whether the scorecard without its list says everything else it said: parsed, both, and compared. */
+function keepsTheRest(
+  before: Readonly<Record<string, unknown>>,
+  without: string,
+  yaml: ParseYaml,
+): boolean {
+  const after = yaml(frontmatterOf(without) ?? "");
+  return (
+    after.ok && R.isDeepEqual(R.omit(before, ["stages"]), after.value ?? {})
+  );
+}
+
+/** The scorecard read and its list taken out — checked by parsing both, so a cut that misreads is refused. */
+function scorecard(
+  paperDir: string,
+  deps: VersionsCommandDeps,
+): Result<Scorecard, string> {
+  const text = statusText(paperDir, deps);
+  const before = deps.yaml(frontmatterOf(text) ?? "");
+  if (!before.ok)
+    return err(
+      `${STATUS_FILE}: the frontmatter does not parse (${before.error}) — fix it, then migrate`,
+    );
+  // A frontmatter that is no mapping (none, or a bare value) has no `stages:` key to take out.
+  const fields = isRecord(before.value) ? before.value : {};
+  const list = fieldOf(fields, "stages");
+  const stages: readonly unknown[] = Array.isArray(list) ? list : [];
+  const without = withoutStages(text);
+  return without === null || keepsTheRest(fields, without, deps.yaml)
+    ? ok({ stages, without })
+    : err(
+        `${STATUS_FILE}: taking the stages: list out would change the rest of its frontmatter — take it out by hand, then migrate`,
+      );
+}
+
+/** A file of the paper, by its path relative to the paper: its size and digest, or null. */
+const paperFacts =
+  (paperDir: string, deps: VersionsCommandDeps) => (rel: string) => {
+    const b = deps.files.readBytes(callerPath(resolve(paperDir, rel)));
+    return b === null ? null : { bytes: b.length, sha256: sha256Hex(b) };
+  };
+
+/** Each copy, then each move: a shared source is copied before the move takes it away. */
+function carry(
+  paperDir: string,
+  plan: MigrationPlan,
+  deps: VersionsCommandDeps,
+): void {
+  const at = (rel: string) => callerPath(resolve(paperDir, rel));
+  plan.copies.forEach((m) => {
+    deps.copy(at(m.from), at(m.to));
+    deps.log(`copied        ${m.from} → ${m.to}`);
+  });
+  plan.moves.forEach((m) => {
+    deps.move(at(m.from), at(m.to));
+    deps.log(`moved         ${m.from} → ${m.to}`);
+  });
+}
+
+/** The plan carried out: the files, the lock, the scorecard without its list. */
+function migrate(
+  paperDir: string,
+  plan: MigrationPlan,
+  card: Scorecard,
+  deps: VersionsCommandDeps,
+): number {
+  carry(paperDir, plan, deps);
+  const entries = Object.keys(plan.lock).length;
+  if (entries > 0) {
+    writeLock(paperDir, plan.lock, deps);
+    deps.log(`recorded      versions/lock.json, ${String(entries)} entries`);
+  }
+  if (card.without !== null) {
+    deps.files.writeAtomic(
+      callerPath(join(paperDir, STATUS_FILE)),
+      new TextEncoder().encode(card.without),
+    );
+    deps.log(
+      `removed       the stages: list from ${STATUS_FILE} — the folders and the lock are the record now`,
+    );
+  }
+  return 0;
+}
+
+/**
+ * A plan carried out only once its rehearsal on the paths it touches went through (src/domain/
+ * versions-migration.ts, `rehearse`): a plan that could stop half-way is a refusal, nothing written.
+ */
+export function carryOut(
+  paperDir: string,
+  plan: MigrationPlan,
+  card: Scorecard,
+  deps: VersionsCommandDeps,
+): number {
+  const ran = rehearse(plan, (p) =>
+    deps.files.isFile(callerPath(resolve(paperDir, p))),
+  );
+  return ran.ok
+    ? migrate(paperDir, plan, card, deps)
+    : refused([...ran.error, "nothing was moved"], deps);
+}
+
+/** The lock already there, or the line saying it must be written first. */
+function lockBefore(
+  paperDir: string,
+  deps: VersionsCommandDeps,
+): Result<Lock, string> {
+  const lock = readLock(paperDir, deps.files) ?? ok({});
+  return lock.ok
+    ? lock
+    : err(
+        `versions/lock.json: ${lock.error} — \`npx paperlint versions lock ${shown(deps.cwd, paperDir)}\` writes it anew; then migrate`,
+      );
+}
+
+function runMigrate(
+  paperDir: string,
+  cycles: Cycles,
+  deps: VersionsCommandDeps,
+): number {
+  const card = scorecard(paperDir, deps);
+  if (!card.ok) return (deps.err(card.error), 2);
+  const lock = lockBefore(paperDir, deps);
+  if (!lock.ok) return (deps.err(lock.error), 2);
+  const plan = planMigration({
+    cycleIds: cycles.list.map((c) => c.id),
+    stages: card.value.stages,
+    root: entriesIn(versionsDir(paperDir), deps),
+    factsOf: paperFacts(paperDir, deps),
+    lock: lock.value,
+    exists: (rel) => deps.files.isFile(callerPath(resolve(paperDir, rel))),
+  });
+  if (!plan.ok) return refused([...plan.error, "nothing was moved"], deps);
+  // A copy always has its move: the last destination of a shared source is moved, not copied.
+  if (plan.value.moves.length === 0 && card.value.without === null)
+    return (
+      deps.log(
+        `nothing to migrate: ${STATUS_FILE} has no stages: list, and no file of the old layout is left in versions/`,
+      ),
+      0
+    );
+  return carryOut(paperDir, plan.value, card.value, deps);
+}
+
+const refused = (
+  lines: readonly string[],
+  deps: VersionsCommandDeps,
+): number => {
+  lines.forEach((l) => {
+    deps.err(l);
+  });
+  return 2;
+};
+
+// ── the command ─────────────────────────────────────────────────────────────────────────
+
+const NO_CYCLES_LOCK =
+  'the paper keeps no "cycles" in paperlint.json: there is no versions/<cycle>/ to lock (docs/configuration.md, "The paper\'s cycles")';
+
+const NO_CYCLES_MIGRATE =
+  'the paper keeps no "cycles" in paperlint.json: its stages: list stays its record — folders per attempt are named by cycle ids (docs/configuration.md, "The paper\'s cycles")';
+
+/** `paperlint versions …`: exit 0, or 2 for a command line or a paper it cannot run on. */
+export function runVersions(
+  words: readonly string[],
+  deps: VersionsCommandDeps,
+): number {
+  const a = versionsArgs(words);
+  if (a.extra.length > 0)
+    return (
+      deps.err(
+        `\`versions ${a.sub}\` takes one paper folder — got also \`${a.extra.join(" ")}\``,
+      ),
+      2
+    );
+  const paperDir = resolve(deps.cwd, a.paper);
+  if (a.sub === "show") {
+    const lines = versionLines(paperDir, deps);
+    if (!lines.ok) return (deps.err(lines.error), 2);
+    return (logAll(lines.value, deps), 0);
+  }
+  const cycles = cyclesIn(paperDir, deps.files);
+  if (cycles === null)
+    return (deps.err(a.sub === "lock" ? NO_CYCLES_LOCK : NO_CYCLES_MIGRATE), 2);
+  return a.sub === "lock"
+    ? runLock(paperDir, cycles, deps)
+    : runMigrate(paperDir, cycles, deps);
+}

package/src/versions.ts

@@ -0,0 +1,286 @@
+/**
+ * A PAPER'S FROZEN VERSIONS, read from the disk: the folder `versions/`, its lock, and the draft
+ * measured against the frozen source it left (`src/domain/versions.ts` holds the convention and every
+ * decision; this file reads and writes through the ports).
+ *
+ *   readVersions    the cycles, the lock and the files of `versions/`, as the rules and the table read them
+ *   draftDrift      paper.tex, assembled as the build read it, against the frozen source of the attempt
+ *   versionLines    the version → state table (`paperlint versions`, `paperlint submission show`)
+ *   freezePlan      before a `submission --save` sends: what it will freeze, or why it cannot
+ *   freezeSent      after the portal took it: the PDF sent and its source, written and locked
+ */
+import { join } from "node:path";
+import { callerPath } from "./caller-path.ts";
+import { venueCycleOf, type CycleId, type Cycles } from "./domain/cycle.ts";
+import { sha256Hex } from "./domain/sha256.ts";
+import { messageOf } from "./domain/text.ts";
+import { err, ok, type Result } from "./domain/result.ts";
+import {
+  driftBase,
+  frozenKey,
+  lineDrift,
+  lockText,
+  LOCK_FILE,
+  parseLock,
+  versionRows,
+  versionTable,
+  VERSIONS_DIR,
+  type DraftDrift,
+  type Entry,
+  type FileFacts,
+  type Lock,
+  type LockEntry,
+} from "./domain/versions.ts";
+import type { Files } from "./ports/files.ts";
+import type { ListDir } from "./ports/talk-media.ts";
+import { readCycles } from "./cycle-rules.ts";
+import { readPaper, decoded, type ProseDeps } from "./tex-paper.ts";
+import { MAIN } from "./build.ts";
+import { paperRecord } from "./paper-record.ts";
+
+/** The paper's `versions/` folder. */
+export const versionsDir = (paperDir: string): string =>
+  join(paperDir, VERSIONS_DIR);
+
+/** A frozen file's path, by its key. */
+export const frozenPath = (paperDir: string, key: string): string =>
+  join(paperDir, VERSIONS_DIR, key);
+
+/** Whether a frozen file is on disk, by its key. */
+export const hasFrozen =
+  (paperDir: string, files: Files) =>
+  (key: string): boolean =>
+    files.isFile(callerPath(frozenPath(paperDir, key)));
+
+/** A frozen file's text, by its key; null when it is not there. */
+export const frozenText = (
+  paperDir: string,
+  key: string,
+  files: Files,
+): string | null =>
+  decoded(files.readBytes(callerPath(frozenPath(paperDir, key))));
+
+/** The size and digest of a frozen file on disk, by its key: zero bytes of nothing when it is gone. */
+export const factsOfFrozen =
+  (paperDir: string, files: Files) =>
+  (key: string): FileFacts => {
+    const b =
+      files.readBytes(callerPath(frozenPath(paperDir, key))) ??
+      new Uint8Array();
+    return { bytes: b.length, sha256: sha256Hex(b) };
+  };
+
+/** `versions/lock.json`: null when there is none; else parsed, or why it does not parse. */
+export function readLock(
+  paperDir: string,
+  files: Files,
+): Result<Lock, string> | null {
+  const b = files.readBytes(callerPath(join(versionsDir(paperDir), LOCK_FILE)));
+  if (b === null) return null;
+  try {
+    return parseLock(JSON.parse(new TextDecoder().decode(b)));
+  } catch (e) {
+    return err(`not JSON: ${messageOf(e)}`);
+  }
+}
+
+/** What reading the folder needs: the disk and its listings. */
+export interface VersionsDeps {
+  readonly files: Files;
+  readonly listDir: ListDir;
+}
+
+/** The entries of a folder, each a file or a folder, by name. */
+export const entriesIn = (dir: string, deps: VersionsDeps): readonly Entry[] =>
+  [...deps.listDir(callerPath(dir))].sort().map((name) => ({
+    name,
+    kind: deps.files.isFile(callerPath(join(dir, name))) ? "file" : "dir",
+  }));
+
+/** The paper's cycles, when it keeps them and they read; null for the flat form or a broken record. */
+export function cyclesIn(paperDir: string, files: Files): Cycles | null {
+  const r = readCycles(paperDir, { files });
+  return r.ok ? r.value : null;
+}
+
+/** paper.tex, assembled as the last build read it (its includes spliced in); null without one. */
+export function draftText(paperDir: string, deps: ProseDeps): string | null {
+  const main = join(paperDir, MAIN);
+  const src = decoded(deps.files.readBytes(callerPath(main)));
+  return src === null ? null : readPaper(main, src, deps).text;
+}
+
+/** The draft against the frozen source of the paper's attempt: none, nothing frozen, the same, or drifted. */
+export function draftDrift(
+  paperDir: string,
+  cycles: Cycles,
+  draft: string,
+  files: Files,
+): DraftDrift {
+  const base = driftBase(cycles.current, hasFrozen(paperDir, files));
+  if (base === null) return { kind: "none" };
+  const frozen = frozenText(paperDir, base.key, files);
+  if (frozen === null) return { kind: "no-base", key: base.key };
+  const drift = lineDrift(frozen, draft);
+  return drift.added === 0 && drift.removed === 0
+    ? { kind: "same", key: base.key }
+    : { kind: "drift", key: base.key, drift };
+}
+
+/**
+ * The version → state table of the paper in `paperDir`: each attempt's frozen files and what they
+ * are, then the draft. Or why there is none: the paper keeps no `cycles`.
+ */
+export function versionLines(
+  paperDir: string,
+  deps: ProseDeps,
+): Result<readonly string[], string> {
+  const cycles = cyclesIn(paperDir, deps.files);
+  if (cycles === null)
+    return err(
+      'the paper keeps no "cycles" in paperlint.json (or they do not read — `paperlint lint` says why): versions are kept per attempt, versions/<cycle>/<stage>.pdf',
+    );
+  const lock = readLock(paperDir, deps.files);
+  const draft = draftText(paperDir, deps);
+  return ok(
+    versionTable(
+      versionRows({
+        cycles: cycles.list,
+        has: hasFrozen(paperDir, deps.files),
+        lock: lock?.ok === true ? lock.value : {},
+        draft:
+          draft === null
+            ? { kind: "none" }
+            : draftDrift(paperDir, cycles, draft, deps.files),
+      }),
+    ),
+  );
+}
+
+// ── freezing what a submission sends ────────────────────────────────────────────────────
+
+/** What a `--save` will freeze once the portal takes the PDF: nothing for the flat form, else where. */
+export type FreezePlan =
+  | { readonly kind: "flat" }
+  | {
+      readonly kind: "freeze";
+      readonly cycle: CycleId;
+      readonly stage: "submitted" | "camera-ready";
+      /** paper.tex as the build read it, includes spliced in: the source the PDF was built from. */
+      readonly source: string;
+    };
+
+const refusal = (why: string, cycle: string): string =>
+  `refused: ${why}, and the two could not be frozen together in versions/${cycle}/ — rebuild (\`paperlint build\`), run the dry run again, then --save; nothing was sent`;
+
+/** Why the source on disk cannot be frozen as the PDF's; null when the build's record says it can. */
+function sourceProblem(
+  paperDir: string,
+  deps: ProseDeps,
+): Result<string, string> {
+  const record = paperRecord(paperDir, deps);
+  if (record.kind === "none")
+    return err(
+      "no record of the build (_build/sources.json), so which source the PDF was built from is not known",
+    );
+  if (record.kind === "stale")
+    return err(
+      `${record.changed.map((x) => x.path).join(", ")} changed since the build, so the PDF is not what the source builds now`,
+    );
+  const source = draftText(paperDir, deps);
+  return source === null
+    ? err(`no ${MAIN} to freeze beside the PDF`)
+    : ok(source);
+}
+
+/**
+ * Before a `--save` sends: what it will freeze — the open cycle's `submitted`, or the accepted one's
+ * `camera-ready` — and the source to freeze beside the PDF. Refused when the build's record does not
+ * say the source on disk is the one the PDF was built from: a PDF frozen with another source is a
+ * pair that lies.
+ */
+export function freezePlan(
+  paperDir: string,
+  cycles: Cycles | null,
+  deps: ProseDeps,
+): Result<FreezePlan, string> {
+  const c = cycles === null ? null : venueCycleOf(cycles.current);
+  if (cycles === null || c === null) return ok({ kind: "flat" });
+  const source = sourceProblem(paperDir, deps);
+  return source.ok
+    ? ok({
+        kind: "freeze",
+        cycle: c.id,
+        stage:
+          cycles.current.kind === "accepted" ? "camera-ready" : "submitted",
+        source: source.value,
+      })
+    : err(refusal(source.error, c.id));
+}
+
+/** What freezing writes with: the disk, and the instant the lock records (ISO 8601). */
+export interface FreezeDeps {
+  readonly files: Files;
+  readonly now: () => string;
+}
+
+const lockEntry = (bytes: Uint8Array, frozen: string): LockEntry => ({
+  kind: "file",
+  bytes: bytes.length,
+  sha256: sha256Hex(bytes),
+  frozen,
+});
+
+/** What was sent: the paper, its plan, the PDF's bytes, and the paper as the command names it. */
+export interface Sent {
+  readonly paperDir: string;
+  readonly plan: Extract<FreezePlan, { readonly kind: "freeze" }>;
+  readonly pdf: Uint8Array;
+  readonly shownPaper: string;
+}
+
+/** The lock with the two frozen files recorded, written; or why the lock on disk does not read. */
+function lockSent(
+  s: Sent,
+  entries: Lock,
+  deps: FreezeDeps,
+): Result<null, string> {
+  const lock = readLock(s.paperDir, deps.files) ?? ok({});
+  if (!lock.ok) return lock;
+  deps.files.writeAtomic(
+    callerPath(join(versionsDir(s.paperDir), LOCK_FILE)),
+    new TextEncoder().encode(lockText({ ...lock.value, ...entries })),
+  );
+  return ok(null);
+}
+
+/**
+ * After the portal took the PDF: the PDF and its source written to `versions/<cycle>/<stage>.*`,
+ * replacing an earlier upload's, and recorded in the lock. The line to print; an error line when the
+ * lock does not read (the files are frozen, the lock left as it is).
+ */
+export function freezeSent(s: Sent, deps: FreezeDeps): Result<string, string> {
+  const { cycle, stage } = s.plan;
+  const source = new TextEncoder().encode(s.plan.source);
+  const pdfKey = frozenKey(cycle, stage, "pdf");
+  const texKey = frozenKey(cycle, stage, "tex");
+  deps.files.writeAtomic(callerPath(frozenPath(s.paperDir, pdfKey)), s.pdf);
+  deps.files.writeAtomic(callerPath(frozenPath(s.paperDir, texKey)), source);
+  const frozen = deps.now();
+  const locked = lockSent(
+    s,
+    { [pdfKey]: lockEntry(s.pdf, frozen), [texKey]: lockEntry(source, frozen) },
+    deps,
+  );
+  return locked.ok
+    ? ok(
+        `frozen        versions/${pdfKey} (${String(s.pdf.length)} bytes) and ${stage}.tex (${String(source.length)} bytes), recorded in versions/lock.json`,
+      )
+    : err(
+        `versions/lock.json does not read (${locked.error}): versions/${pdfKey} and ${stage}.tex are frozen, not recorded — \`npx paperlint versions lock ${s.shownPaper}\` records them`,
+      );
+}
+
+/** What a send in the flat form says instead of a freeze. */
+export const NOT_FROZEN =
+  'not frozen    the paper keeps no "cycles" in paperlint.json: versions are frozen per attempt, in versions/<cycle>/ (docs/configuration.md, "The paper\'s cycles")';

package/dist/eslint-rules/cycle-stage.d.ts

@@ -1,39 +0,0 @@
-import type { RuleContext } from "./rule-context.ts";
-interface Head {
-    readonly id: string;
-    readonly phase: string;
-}
-interface Finding {
-    readonly messageId: "noCycle" | "unknownCycle" | "porting";
-    readonly data: Readonly<Record<string, string>>;
-}
-/** Each stage against the declared cycles. Pure. */
-export declare function judgeStages(stages: readonly unknown[], cycles: readonly Head[]): readonly Finding[];
-declare const _default: {
-    rules: {
-        stage: {
-            meta: {
-                type: "problem";
-                docs: {
-                    description: string;
-                    url: string;
-                };
-                schema: never[];
-                messages: {
-                    noCycle: string;
-                    unknownCycle: string;
-                    porting: string;
-                };
-            };
-            create(context: RuleContext): {
-                yaml?: never;
-            } | {
-                yaml(node: {
-                    readonly value: string;
-                }): void;
-            };
-        };
-    };
-};
-export default _default;
-//# sourceMappingURL=cycle-stage.d.ts.map

package/dist/eslint-rules/cycle-stage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cycle-stage.d.ts","sourceRoot":"","sources":["../../eslint-rules/cycle-stage.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAwBrD,UAAU,IAAI;IACZ,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAuBD,UAAU,OAAO;IACf,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,cAAc,GAAG,SAAS,CAAC;IAC3D,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACjD;AAED,oDAAoD;AACpD,wBAAgB,WAAW,CACzB,MAAM,EAAE,SAAS,OAAO,EAAE,EAC1B,MAAM,EAAE,SAAS,IAAI,EAAE,GACtB,SAAS,OAAO,EAAE,CAgBpB;;;;;;;;;;;;;;;;;4BAsBqB,WAAW;;;2BAIZ;oBAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;iBAAE;;;;;AAxB/C,wBA0CE"}