paperlint 7.1.0 → 8.0.0

package/dist/cycle-rules.js

@@ -0,0 +1,212 @@
+/**
+ * THE CYCLE RULES over a paper's settings file — the `cycle` plugin, judged once per paper on its
+ * `PIPELINE-STATUS.md` (every paper folder has one, whatever its source format; `paper/folder-venue-leftover`
+ * reports there for the same reason):
+ *
+ *   cycle/record    error  `cycles` in paperlint.json parses and names one current attempt: no two
+ *                          open cycles, the open one last, ids unique, every deadline an instant
+ *                          with its zone; each source's deadlines in order; no portal reading the
+ *                          venue's preset already carries
+ *   cycle/evidence  error  every closed cycle's `outcome.evidence`, and every deadline override's
+ *                          `evidence`, is a file in the paper folder
+ *
+ * ── WHY ERROR, NOT WARN ───────────────────────────────────────────────────────────
+ * A warning is read once and never again. Each of these names a state that cannot be worked in:
+ * two open cycles is dual submission or a decision nobody recorded; a deadline without its zone is
+ * the mistake the record exists to prevent; a decision or an override whose evidence is not in the
+ * folder is a claim with nothing behind it. Nothing here depends on a clock or the network — the
+ * record is judged against itself, the installed venue preset and the disk, like `paper/stages`.
+ *
+ * ── THE PRESET'S READINGS ARE DERIVED, NOT COPIED ──────────────────────────────────
+ * A cycle whose venue is a preset gets that preset's `deadlines` (the portal's readings, refreshed in
+ * the package); the paper adds the call's readings and its overrides. A paper's own portal reading
+ * of a deadline the preset carries is a second copy of one fact, and it drifts the day the preset is
+ * updated — so it is reported.
+ *
+ * ── WHO SPEAKS WHEN THERE IS NOTHING TO JUDGE ──────────────────────────────────────
+ * No `paperlint.json`, one that is not JSON, or one without `cycles` (the flat form): silent — the
+ * flat form is still valid, and `pdf/profile` says when the whole file is broken. A `cycles` that
+ * does not parse, or names no current attempt (two open cycles), never reaches this rule through
+ * `paperlint lint`: `paperRuleBlocks` (src/cli.ts) refuses the settings file before ESLint runs, one
+ * line naming the file and the problem, exit 2 — the same strictness as an unknown key (measured
+ * 2026-10-05). The `broken` message below is what the rule says when a host runs it without that
+ * refusal; under the CLI only `order` is reachable.
+ */
+import { basename, dirname, join } from "node:path";
+import { callerPath } from "./caller-path.js";
+import { cycleProblemText, cyclesOf, parseCycles, } from "./domain/cycle.js";
+import { deadlineOrderProblems } from "./domain/deadline.js";
+import { resolvePreset } from "./presets.js";
+import { fieldOf } from "./domain/record.js";
+import { err, ok } from "./domain/result.js";
+import { rulePageUrl } from "./venue-rules.js";
+import { CONFIG_FILE } from "#lib/paper-config";
+const STATUS_FILE = "PIPELINE-STATUS.md";
+/** The `cycles` value of the paper's settings file; undefined when there is no file, no JSON, or no key. */
+function cyclesValue(dir, deps) {
+    const bytes = deps.files.readBytes(callerPath(join(dir, CONFIG_FILE)));
+    if (bytes === null)
+        return undefined;
+    try {
+        return fieldOf(JSON.parse(new TextDecoder().decode(bytes)), "cycles");
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The paper's cycles, parsed and consistent, or the one line that says what is wrong. */
+export function readCycles(dir, deps) {
+    const list = parseCycles(cyclesValue(dir, deps));
+    if (!list.ok)
+        return list;
+    if (list.value === null)
+        return ok(null);
+    const cycles = cyclesOf(list.value);
+    return cycles.ok ? cycles : err(cycleProblemText(cycles.error));
+}
+/** A paper's portal readings of deadlines its venue's preset already carries. */
+function presetCopies(c, preset) {
+    return c.deadlines.flatMap((d) => {
+        const theirs = preset.readings.find((r) => r.what === d.what && r.source === "portal");
+        const ours = d.observed.some((o) => o.source === "portal");
+        return theirs !== undefined && ours
+            ? [
+                {
+                    messageId: "presetCopy",
+                    data: {
+                        id: c.id,
+                        what: d.what,
+                        preset: preset.spec,
+                        at: theirs.at,
+                        read: theirs.read,
+                    },
+                },
+            ]
+            : [];
+    });
+}
+/** `cycle/record`: the record's own problems. Pure over the read and the presets' readings. */
+export function judgeRecord(read, presetReadings) {
+    if (!read.ok)
+        return [{ messageId: "broken", data: { why: read.error } }];
+    if (read.value === null)
+        return [];
+    return read.value.list.flatMap((c) => {
+        const preset = presetReadings(c);
+        return [
+            ...deadlineOrderProblems(c.deadlines, preset?.readings ?? []).map((why) => ({ messageId: "order", data: { id: c.id, why } })),
+            ...(preset === null ? [] : presetCopies(c, preset)),
+        ];
+    });
+}
+/** The overrides whose evidence is not on disk. */
+const overrideEvidence = (c, isFile) => c.deadlines.flatMap((d) => d.override !== null && !isFile(d.override.evidence)
+    ? [
+        {
+            messageId: "overrideMissing",
+            data: {
+                id: c.id,
+                what: d.what,
+                at: d.override.at,
+                evidence: d.override.evidence,
+            },
+        },
+    ]
+    : []);
+/** The closed cycles, and the overrides, whose evidence is not on disk. */
+export function judgeEvidence(cycles, isFile) {
+    return cycles.flatMap((c) => {
+        const o = c.outcome;
+        return [
+            ...(o.kind !== "open" && !isFile(o.evidence)
+                ? [
+                    {
+                        messageId: "missing",
+                        data: {
+                            id: c.id,
+                            outcome: o.kind,
+                            date: o.date,
+                            evidence: o.evidence,
+                        },
+                    },
+                ]
+                : []),
+            ...overrideEvidence(c, isFile),
+        ];
+    });
+}
+const META = {
+    record: {
+        type: "suggestion",
+        docs: {
+            description: "the paper's `cycles` record parses and names one current attempt, each source's deadlines in order, no copy of the preset's portal readings",
+            url: rulePageUrl("cycle/record"),
+        },
+        schema: [],
+        messages: {
+            broken: `${CONFIG_FILE}: {{why}}`,
+            order: `${CONFIG_FILE}, cycle «{{id}}»: {{why}} — a date typed wrong, or an AoE day miscounted (write a call's date as "YYYY-MM-DD AoE" and paperlint converts it)`,
+            presetCopy: `${CONFIG_FILE}, cycle «{{id}}»: the "{{what}}" deadline records a portal reading, and the preset {{preset}} carries the portal's reading of it ({{at}}, read {{read}}) — a second copy drifts when paperlint updates the preset: delete this one (the call's reading and an override stay)`,
+        },
+    },
+    evidence: {
+        type: "suggestion",
+        docs: {
+            description: "every closed cycle's decision, and every deadline override, points at a file in the paper folder — the mail, the reviews, the note",
+            url: rulePageUrl("cycle/evidence"),
+        },
+        schema: [],
+        messages: {
+            missing: "cycle «{{id}}» is {{outcome}} ({{date}}) with evidence `{{evidence}}`, which is not in the paper folder — save the decision mail, the reviews or the note that records the decision there, or correct the path",
+            overrideMissing: 'cycle «{{id}}»: the override of the "{{what}}" deadline ({{at}}) rests on `{{evidence}}`, which is not in the paper folder — save the mail or the page that grants it there, or correct the path',
+        },
+    },
+};
+/** Each cycle's venue preset's readings, resolved from the paper's settings file like `extends`. */
+const presetReadingsOf = (dir, deps) => (c) => {
+    if (c.venue.kind !== "preset")
+        return null;
+    const spec = c.venue.extends;
+    const p = resolvePreset(spec, join(dir, CONFIG_FILE), deps);
+    return p.ok ? { spec, readings: p.value.deadlines } : null;
+};
+/** The findings of one rule for the paper folder `dir`. */
+function findingsFor(name, dir, deps) {
+    const read = readCycles(dir, deps);
+    switch (name) {
+        case "record":
+            return judgeRecord(read, presetReadingsOf(dir, deps));
+        case "evidence":
+            return read.ok && read.value !== null
+                ? judgeEvidence(read.value.list, (rel) => deps.files.isFile(callerPath(join(dir, rel))))
+                : [];
+    }
+}
+function rule(name, deps) {
+    return {
+        meta: META[name],
+        create(context) {
+            if (basename(context.filename) !== STATUS_FILE)
+                return {};
+            return {
+                root() {
+                    const at = context.sourceCode.getLocFromIndex(0);
+                    findingsFor(name, dirname(context.filename), deps).forEach((f) => {
+                        context.report({ loc: { start: at, end: at }, ...f });
+                    });
+                },
+            };
+        },
+    };
+}
+/** The `cycle` plugin's rules over the settings file, for every paper's `PIPELINE-STATUS.md`. */
+export function cycleRules(deps) {
+    return { record: rule("record", deps), evidence: rule("evidence", deps) };
+}
+/** The level each `cycle/*` rule on PIPELINE-STATUS.md is on at in paperlint's own config — `stage` too (eslint-rules/cycle-stage.ts). */
+export const CYCLE_RULE_LEVELS = {
+    "cycle/record": "error",
+    "cycle/evidence": "error",
+    "cycle/stage": "error",
+};
+//# sourceMappingURL=cycle-rules.js.map

package/dist/cycle-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycle-rules.js","sourceRoot":"","sources":["../src/cycle-rules.ts"],"names":[],"mappings":"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"}

package/dist/domain/cycle.d.ts

@@ -0,0 +1,148 @@
+/**
+ * THE CYCLE — one attempt of a paper at one venue: where it goes, as what kind, when the attempt was
+ * decided, the venue's deadlines as they were read, which submission on the portal is this paper's,
+ * and how the attempt ended. A paper's `paperlint.json` holds them as a LIST, `cycles`, oldest first:
+ *
+ *   {
+ *     "id": "beta-2027",
+ *     "venue": { "kind": "preset", "extends": "paperlint:beta" },   // or { "kind": "named", "name", "url" }
+ *     "kind": "technical",
+ *     "opened": "2026-09-09",
+ *     "phase": "porting",                                             // default "prepared"
+ *     "deadlines": [{ "what": "submission", "observed": [{ "at": "2026-10-23 AoE", "source": "call", "url": "…", "read": "2026-09-09" }] }],
+ *     "submission": { "id": 7 },
+ *     "outcome": { "kind": "open" }
+ *   }
+ *
+ * ── WHY A LIST OF ATTEMPTS, NOT ONE VENUE ───────────────────────────────────────────────
+ * A paper goes to a venue, is rejected, and goes to the next one; the settings that every reader
+ * takes from the file — `extends`, `kind`, `submission` — are the CURRENT attempt's, and change
+ * together when the attempt changes. Held flat, they lag the decision (the preset is switched "when
+ * the port lands", weeks later) and the decision itself has no field, so it is written as a comment.
+ * Here it is a record: the new attempt is a new entry, the old one gets its `outcome`.
+ *
+ * ── THE PHASE, and why it is DECLARED ────────────────────────────────────────────────────
+ * The day a new venue is chosen, the source is still in the old venue's template. The venue's format
+ * checks are then not wrong, but not applicable: a page count under the wrong template says nothing
+ * about the new limit. `"phase": "porting"` says the port is open work; the format rules are silent
+ * under it, and `cycle/port-done` fires when the class line already matches the venue's template
+ * and the phase still says porting. The declaration cannot lie for long in either direction, and it
+ * is a record of work, not a softer severity. Absent, the phase is `prepared`.
+ *
+ * ── THE DEADLINES ARE READINGS ───────────────────────────────────────────────────────────
+ * Each deadline records what the portal and the call said, where and when, and an optional human
+ * override; the earlier reading binds unless overridden (`deadline.ts`). For a venue with a preset,
+ * the portal's readings come from the preset — updated with the package — and the paper adds the
+ * call's readings and its overrides on top.
+ *
+ * Parsed by hand: the domain imports no schema library (see `src/CLAUDE.md`).
+ */
+import { type Result } from "./result.ts";
+import { type Deadline, type IsoDate } from "./deadline.ts";
+/** The venue of an attempt: a preset paperlint resolves, or a venue named by hand (no preset yet). */
+export type CycleVenue = {
+    readonly kind: "preset";
+    readonly extends: string;
+} | {
+    readonly kind: "named";
+    readonly name: string;
+    readonly url: string;
+};
+/** How an attempt ended; `open` while it has not. */
+export type Outcome = {
+    readonly kind: "open";
+} | {
+    readonly kind: "accepted";
+    readonly date: IsoDate;
+    readonly evidence: string;
+} | {
+    readonly kind: "rejected";
+    readonly date: IsoDate;
+    readonly evidence: string;
+    /** A desk rejection (format, scope) — different work follows than after reviews. */
+    readonly desk: boolean;
+} | {
+    readonly kind: "withdrawn";
+    readonly date: IsoDate;
+    readonly evidence: string;
+};
+export declare const OUTCOME_KINDS: readonly Outcome["kind"][];
+export type Phase = "porting" | "prepared";
+export interface Cycle {
+    /** What a stage refers to (`stages[].cycle`): unique in the list. */
+    readonly id: string;
+    readonly venue: CycleVenue;
+    /** A key of the preset's `format.kinds`; null when the venue has one kind or none is chosen. */
+    readonly kind: string | null;
+    /** The day this attempt was decided: the rows of the scorecard are judged against it. */
+    readonly opened: IsoDate;
+    readonly phase: Phase;
+    readonly deadlines: readonly Deadline[];
+    /** Which submission on the venue's portal is this paper's; null before one exists. */
+    readonly submission: {
+        readonly id: number;
+    } | null;
+    readonly outcome: Outcome;
+}
+/**
+ * Which attempt the paper is on. An ACCEPTED last cycle is not "parked": the paper lives on at that
+ * venue — camera-ready, talk, proceedings — so its venue and kind stay the paper's.
+ */
+export type Current = {
+    readonly kind: "cycle";
+    readonly cycle: Cycle;
+} | {
+    readonly kind: "accepted";
+    readonly cycle: Cycle;
+}
+/** The last cycle was rejected or withdrawn and none is open: between venues. */
+ | {
+    readonly kind: "parked";
+    readonly last: Cycle;
+}
+/** `cycles: []`. */
+ | {
+    readonly kind: "none";
+};
+/** Why a list of cycles names no current attempt. */
+export type CycleProblem = {
+    readonly kind: "two-open";
+    readonly ids: readonly string[];
+} | {
+    readonly kind: "open-not-last";
+    readonly id: string;
+} | {
+    readonly kind: "duplicate-id";
+    readonly id: string;
+};
+/** A `cycles` value → the list, null when absent, or one line naming the entry and the key. Pure. */
+export declare function parseCycles(v: unknown): Result<readonly Cycle[] | null, string>;
+/**
+ * The attempt the paper is on. At most one cycle may be open, and it is the last: two open cycles is
+ * dual submission or a cycle nobody closed, and both are refused by name. Pure.
+ */
+export declare function currentCycle(cycles: readonly Cycle[]): Result<Current, CycleProblem>;
+/** One line for a problem, naming what to change. Pure. */
+export declare function cycleProblemText(p: CycleProblem): string;
+/** A paper's `cycles`, parsed, with the attempt they name: minted only when the list is consistent. */
+export interface Cycles {
+    readonly list: readonly Cycle[];
+    readonly current: Current;
+}
+/** The list with its current attempt, or why the list names none. Pure. */
+export declare const cyclesOf: (list: readonly Cycle[]) => Result<Cycles, CycleProblem>;
+/**
+ * The cycle whose venue and kind are the paper's: the open attempt, or the accepted one; null when
+ * the paper is between venues or has none.
+ */
+export declare const venueCycleOf: (c: Current) => Cycle | null;
+/** The current attempt's own deadline entries; none between venues or before the first attempt. Pure. */
+export declare const currentDeadlines: (c: Current) => readonly Deadline[];
+/**
+ * Whether the paper is judged as a blind submission: the venue reviews blind, and this attempt has
+ * not been accepted — an accepted paper's camera-ready carries its authors. Pure.
+ */
+export declare const effectiveBlind: (venueBlind: boolean, current: Current) => boolean;
+/** Whether the current attempt declares its port to the venue's template as open work. */
+export declare const isPorting: (current: Current) => boolean;
+//# sourceMappingURL=cycle.d.ts.map

package/dist/domain/cycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycle.d.ts","sourceRoot":"","sources":["../../src/domain/cycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAEnD,OAAO,EAIL,KAAK,QAAQ,EACb,KAAK,OAAO,EACb,MAAM,eAAe,CAAC;AAEvB,sGAAsG;AACtG,MAAM,MAAM,UAAU,GAClB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5E,qDAAqD;AACrD,MAAM,MAAM,OAAO,GACf;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,oFAAoF;IACpF,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;AACN,eAAO,MAAM,aAAa,EAAE,SAAS,OAAO,CAAC,MAAM,CAAC,EAKnD,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG,SAAS,GAAG,UAAU,CAAC;AAE3C,MAAM,WAAW,KAAK;IACpB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,gGAAgG;IAChG,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,yFAAyF;IACzF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,CAAC;IACxC,sFAAsF;IACtF,QAAQ,CAAC,UAAU,EAAE;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACpD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,MAAM,OAAO,GACf;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CAAE,GACjD;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CAAE;AACtD,iFAAiF;GAC/E;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;CAAE;AACnD,oBAAoB;GAClB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9B,qDAAqD;AACrD,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAC9D;IAAE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAoN3D,qGAAqG;AACrG,wBAAgB,WAAW,CACzB,CAAC,EAAE,OAAO,GACT,MAAM,CAAC,SAAS,KAAK,EAAE,GAAG,IAAI,EAAE,MAAM,CAAC,CAWzC;AAMD;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,KAAK,EAAE,GACvB,MAAM,CAAC,OAAO,EAAE,YAAY,CAAC,CAmB/B;AAED,2DAA2D;AAC3D,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CASxD;AAED,uGAAuG;AACvG,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,SAAS,KAAK,EAAE,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,2EAA2E;AAC3E,eAAO,MAAM,QAAQ,GACnB,MAAM,SAAS,KAAK,EAAE,KACrB,MAAM,CAAC,MAAM,EAAE,YAAY,CAG7B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY,GAAI,GAAG,OAAO,KAAG,KAAK,GAAG,IAWjD,CAAC;AAEF,yGAAyG;AACzG,eAAO,MAAM,gBAAgB,GAAI,GAAG,OAAO,KAAG,SAAS,QAAQ,EAC7B,CAAC;AAEnC;;;GAGG;AACH,eAAO,MAAM,cAAc,GACzB,YAAY,OAAO,EACnB,SAAS,OAAO,KACf,OAAoD,CAAC;AAExD,0FAA0F;AAC1F,eAAO,MAAM,SAAS,GAAI,SAAS,OAAO,KAAG,OACkB,CAAC"}

package/dist/domain/cycle.js

@@ -0,0 +1,281 @@
+/**
+ * THE CYCLE — one attempt of a paper at one venue: where it goes, as what kind, when the attempt was
+ * decided, the venue's deadlines as they were read, which submission on the portal is this paper's,
+ * and how the attempt ended. A paper's `paperlint.json` holds them as a LIST, `cycles`, oldest first:
+ *
+ *   {
+ *     "id": "beta-2027",
+ *     "venue": { "kind": "preset", "extends": "paperlint:beta" },   // or { "kind": "named", "name", "url" }
+ *     "kind": "technical",
+ *     "opened": "2026-09-09",
+ *     "phase": "porting",                                             // default "prepared"
+ *     "deadlines": [{ "what": "submission", "observed": [{ "at": "2026-10-23 AoE", "source": "call", "url": "…", "read": "2026-09-09" }] }],
+ *     "submission": { "id": 7 },
+ *     "outcome": { "kind": "open" }
+ *   }
+ *
+ * ── WHY A LIST OF ATTEMPTS, NOT ONE VENUE ───────────────────────────────────────────────
+ * A paper goes to a venue, is rejected, and goes to the next one; the settings that every reader
+ * takes from the file — `extends`, `kind`, `submission` — are the CURRENT attempt's, and change
+ * together when the attempt changes. Held flat, they lag the decision (the preset is switched "when
+ * the port lands", weeks later) and the decision itself has no field, so it is written as a comment.
+ * Here it is a record: the new attempt is a new entry, the old one gets its `outcome`.
+ *
+ * ── THE PHASE, and why it is DECLARED ────────────────────────────────────────────────────
+ * The day a new venue is chosen, the source is still in the old venue's template. The venue's format
+ * checks are then not wrong, but not applicable: a page count under the wrong template says nothing
+ * about the new limit. `"phase": "porting"` says the port is open work; the format rules are silent
+ * under it, and `cycle/port-done` fires when the class line already matches the venue's template
+ * and the phase still says porting. The declaration cannot lie for long in either direction, and it
+ * is a record of work, not a softer severity. Absent, the phase is `prepared`.
+ *
+ * ── THE DEADLINES ARE READINGS ───────────────────────────────────────────────────────────
+ * Each deadline records what the portal and the call said, where and when, and an optional human
+ * override; the earlier reading binds unless overridden (`deadline.ts`). For a venue with a preset,
+ * the portal's readings come from the preset — updated with the package — and the paper adds the
+ * call's readings and its overrides on top.
+ *
+ * Parsed by hand: the domain imports no schema library (see `src/CLAUDE.md`).
+ */
+import { err, ok } from "./result.js";
+import { fieldOf, isRecord } from "./record.js";
+import { isIsoDate, parseDeadlines, unknownKey, } from "./deadline.js";
+export const OUTCOME_KINDS = [
+    "open",
+    "accepted",
+    "rejected",
+    "withdrawn",
+];
+// ── parsing ────────────────────────────────────────────────────────────────────────────
+const KNOWN_KEYS = [
+    "id",
+    "venue",
+    "kind",
+    "opened",
+    "phase",
+    "deadlines",
+    "submission",
+    "outcome",
+];
+const where = (i) => `cycles[${String(i)}]`;
+const nonEmpty = (v) => typeof v === "string" && v !== "";
+const VENUE_KEYS = {
+    preset: ["kind", "extends"],
+    named: ["kind", "name", "url"],
+};
+/** The fields of a venue of `kind`, when they are there. */
+function venueFields(kind, v) {
+    const { extends: ext, name, url } = v;
+    switch (kind) {
+        case "preset":
+            return nonEmpty(ext) ? { kind, extends: ext } : null;
+        case "named":
+            return nonEmpty(name) && nonEmpty(url) ? { kind, name, url } : null;
+    }
+}
+/** The venue's own keys refused when unknown, then its shape; null when the kind is neither. */
+function venueShape(v, at) {
+    const kind = v["kind"];
+    if (kind !== "preset" && kind !== "named")
+        return null;
+    const unknown = unknownKey(v, VENUE_KEYS[kind], `${at}.venue`, `a ${kind} venue's`);
+    if (unknown !== null)
+        return err(unknown);
+    const venue = venueFields(kind, v);
+    return venue === null ? null : ok(venue);
+}
+function parseVenue(v, at) {
+    const shaped = isRecord(v) ? venueShape(v, at) : null;
+    return (shaped ??
+        err(`${at}: "venue" must be { "kind": "preset", "extends": … } or { "kind": "named", "name": …, "url": … }`));
+}
+const isOutcomeKind = (v) => OUTCOME_KINDS.some((k) => k === v);
+/** A decision's shape by kind: `rejected` also says whether it was a desk rejection. */
+const decisionOf = (kind, decided, desk, at) => {
+    switch (kind) {
+        case "accepted":
+            return ok({ kind, ...decided });
+        case "withdrawn":
+            return ok({ kind, ...decided });
+        case "rejected":
+            return typeof desk === "boolean" || desk === undefined
+                ? ok({ kind, ...decided, desk: desk === true })
+                : err(`${at}: "outcome.desk" must be true or false`);
+    }
+};
+const OUTCOME_KEYS = {
+    open: ["kind"],
+    accepted: ["kind", "date", "evidence"],
+    rejected: ["kind", "date", "evidence", "desk"],
+    withdrawn: ["kind", "date", "evidence"],
+};
+function parseOutcome(v, at) {
+    const kind = fieldOf(v, "kind");
+    if (!isRecord(v) || !isOutcomeKind(kind))
+        return err(`${at}: "outcome" kind must be one of ${OUTCOME_KINDS.join(", ")}, got ${JSON.stringify(kind)}`);
+    const unknown = unknownKey(v, OUTCOME_KEYS[kind], `${at}.outcome`, `${kind === "open" || kind === "accepted" ? "an" : "a"} ${kind} outcome's`);
+    if (unknown !== null)
+        return err(unknown);
+    if (kind === "open")
+        return ok({ kind });
+    const date = v["date"];
+    if (!isIsoDate(date))
+        return err(`${at}: "outcome" of kind ${kind} needs "date" (YYYY-MM-DD)`);
+    const evidence = v["evidence"];
+    if (typeof evidence !== "string" || evidence === "")
+        return err(`${at}: "outcome" of kind ${kind} needs "evidence": a file in the paper folder (the decision mail, the reviews, the note that records the withdrawal)`);
+    return decisionOf(kind, { date, evidence }, v["desk"], at);
+}
+function parseSubmission(v, at) {
+    if (v === undefined || v === null)
+        return ok(null);
+    const unknown = isRecord(v)
+        ? unknownKey(v, ["id"], `${at}.submission`, "a submission's")
+        : null;
+    if (unknown !== null)
+        return err(unknown);
+    const id = fieldOf(v, "id");
+    return typeof id === "number" && Number.isInteger(id) && id > 0
+        ? ok({ id })
+        : err(`${at}: "submission" must be { "id": <the submission number on the venue's portal> }`);
+}
+const isPhase = (v) => v === "porting" || v === "prepared";
+/** `kind`: a string, or null when absent — the venue has one kind, or none is chosen yet. */
+const kindOf = (v) => v === undefined || v === null
+    ? ok(null)
+    : typeof v === "string"
+        ? ok(v)
+        : err('"kind" must be a string or null');
+function parseHead(v, at) {
+    const id = v["id"];
+    if (typeof id !== "string" || id === "")
+        return err(`${at}: "id" must be a non-empty string (what stages refer to)`);
+    const venue = parseVenue(v["venue"], at);
+    if (!venue.ok)
+        return venue;
+    const kind = kindOf(v["kind"]);
+    if (!kind.ok)
+        return err(`${at}: ${kind.error}`);
+    const opened = v["opened"];
+    if (!isIsoDate(opened))
+        return err(`${at}: "opened" must be a date YYYY-MM-DD — the day this attempt was decided`);
+    const phase = v["phase"] ?? "prepared";
+    if (!isPhase(phase))
+        return err(`${at}: "phase" must be "porting" or "prepared"`);
+    return ok({
+        id,
+        venue: venue.value,
+        kind: kind.value,
+        opened,
+        phase,
+    });
+}
+function parseTail(v, at) {
+    const deadlines = parseDeadlines(v["deadlines"], at);
+    if (!deadlines.ok)
+        return deadlines;
+    const submission = parseSubmission(v["submission"], at);
+    if (!submission.ok)
+        return submission;
+    const outcome = parseOutcome(v["outcome"] ?? { kind: "open" }, at);
+    if (!outcome.ok)
+        return outcome;
+    return ok({
+        deadlines: deadlines.value,
+        submission: submission.value,
+        outcome: outcome.value,
+    });
+}
+function parseCycle(v, i) {
+    const at = where(i);
+    if (!isRecord(v))
+        return err(`${at} must be an object`);
+    const unknown = Object.keys(v).find((k) => !KNOWN_KEYS.includes(k));
+    if (unknown !== undefined)
+        return err(`${at}: unknown key "${unknown}" — known keys: ${KNOWN_KEYS.join(", ")}`);
+    const head = parseHead(v, at);
+    if (!head.ok)
+        return head;
+    const tail = parseTail(v, at);
+    return tail.ok ? ok({ ...head.value, ...tail.value }) : tail;
+}
+/** A `cycles` value → the list, null when absent, or one line naming the entry and the key. Pure. */
+export function parseCycles(v) {
+    if (v === undefined)
+        return ok(null);
+    if (!Array.isArray(v))
+        return err(`"cycles" must be a LIST of attempts, oldest first — a paper can go to several venues`);
+    return v.reduce((acc, c, i) => {
+        if (!acc.ok)
+            return acc;
+        const p = parseCycle(c, i);
+        return p.ok ? ok([...acc.value, p.value]) : p;
+    }, ok([]));
+}
+// ── deriving ───────────────────────────────────────────────────────────────────────────
+const isOpen = (c) => c.outcome.kind === "open";
+/**
+ * The attempt the paper is on. At most one cycle may be open, and it is the last: two open cycles is
+ * dual submission or a cycle nobody closed, and both are refused by name. Pure.
+ */
+export function currentCycle(cycles) {
+    const dup = cycles.find((c, i) => cycles.findIndex((d) => d.id === c.id) !== i);
+    if (dup !== undefined)
+        return err({ kind: "duplicate-id", id: dup.id });
+    const open = cycles.filter(isOpen);
+    if (open.length > 1)
+        return err({ kind: "two-open", ids: open.map((c) => c.id) });
+    const last = cycles.at(-1);
+    if (last === undefined)
+        return ok({ kind: "none" });
+    const [only] = open;
+    if (only !== undefined && only !== last)
+        return err({ kind: "open-not-last", id: only.id });
+    if (isOpen(last))
+        return ok({ kind: "cycle", cycle: last });
+    return ok(last.outcome.kind === "accepted"
+        ? { kind: "accepted", cycle: last }
+        : { kind: "parked", last });
+}
+/** One line for a problem, naming what to change. Pure. */
+export function cycleProblemText(p) {
+    switch (p.kind) {
+        case "two-open":
+            return `cycles ${p.ids.map((id) => `«${id}»`).join(" and ")} are both open — a paper is on one attempt at a time; two open attempts at two venues is dual submission. Close the one that ended: "outcome": { "kind": "rejected" | "withdrawn" | "accepted", "date", "evidence" }`;
+        case "open-not-last":
+            return `cycle «${p.id}» is open but is not the last entry — cycles are listed oldest first, and the open one is the current attempt`;
+        case "duplicate-id":
+            return `two cycles carry the id «${p.id}» — a stage's \`cycle:\` could name either; give each attempt its own id`;
+    }
+}
+/** The list with its current attempt, or why the list names none. Pure. */
+export const cyclesOf = (list) => {
+    const current = currentCycle(list);
+    return current.ok ? ok({ list, current: current.value }) : current;
+};
+/**
+ * The cycle whose venue and kind are the paper's: the open attempt, or the accepted one; null when
+ * the paper is between venues or has none.
+ */
+export const venueCycleOf = (c) => {
+    switch (c.kind) {
+        case "cycle":
+            return c.cycle;
+        case "accepted":
+            return c.cycle;
+        case "parked":
+            return null;
+        case "none":
+            return null;
+    }
+};
+/** The current attempt's own deadline entries; none between venues or before the first attempt. Pure. */
+export const currentDeadlines = (c) => venueCycleOf(c)?.deadlines ?? [];
+/**
+ * Whether the paper is judged as a blind submission: the venue reviews blind, and this attempt has
+ * not been accepted — an accepted paper's camera-ready carries its authors. Pure.
+ */
+export const effectiveBlind = (venueBlind, current) => venueBlind && current.kind !== "accepted";
+/** Whether the current attempt declares its port to the venue's template as open work. */
+export const isPorting = (current) => current.kind === "cycle" && current.cycle.phase === "porting";
+//# sourceMappingURL=cycle.js.map