paperlint 5.0.0 → 6.1.0

package/src/domain/register.ts

@@ -0,0 +1,261 @@
+/**
+ * THE REGISTER OF A PAPER'S BODY, COUNTED — the measures the register rules judge, and the band a
+ * venue's accepted papers set for each. Pure: passages and emphasised phrases in, counts out.
+ *
+ * Three measures, each per 10,000 words of the body, each read off the same passages and cut into
+ * the same sentences as every other rule over the body (`sentences.ts`):
+ *
+ *   contrast_frames    a claim set against a rejected alternative: «X, not Y», «not X but Y»,
+ *                      «X rather than Y», «instead of Y», «as opposed to Y»
+ *   claim_emphasis     a phrase in bold INSIDE a sentence that states something: six words or more,
+ *                      or holding a number — not a label opening a paragraph or an item, and not a
+ *                      term of a few words
+ *   relation_markers   a word that names how a sentence relates to the one before: because,
+ *                      therefore, however, in contrast, for example, that is …
+ *
+ * ── THE BAND IS THE ANCHORS', NOT A CONSTANT ────────────────────────────────────
+ * A venue preset records its anchors — accepted papers of the venue (or its parent conference),
+ * each with its word count and its count of every measure, as these counters give them. The band
+ * of a measure is the anchors' range, widened at each end by two Poisson standard deviations of
+ * the anchor standing there: a paper of that anchor's length and register would fall outside it
+ * about one time in forty. An anchor with no occurrence is widened as if it had one. Below zero is
+ * zero. So every number a message names comes from the preset's anchors, and changing an anchor
+ * changes the band.
+ */
+import type { Emphasis, Passage, Span, TextRun } from "./tex-document.ts";
+import { runText, spanIn } from "./tex-document.ts";
+import { CITATION, MATH, REFERENCE, runOf, sentences } from "./sentences.ts";
+
+/** The measures a venue's anchors set a band for. */
+export type RegisterMeasureName =
+  "contrast_frames" | "claim_emphasis" | "relation_markers";
+
+export const REGISTER_MEASURES: readonly RegisterMeasureName[] = [
+  "contrast_frames",
+  "claim_emphasis",
+  "relation_markers",
+];
+
+/** One accepted paper of the venue, as the counters measured it. */
+export interface RegisterAnchor {
+  /** What the preset calls it: a directory under `fixtures/accepted-papers/`, or a citation. */
+  readonly paper: string;
+  readonly words: number;
+  readonly counts: Readonly<Record<RegisterMeasureName, number>>;
+}
+
+/** How far the band reaches past the anchors: this many Poisson standard deviations. */
+export const NOISE_SDS = 2;
+
+/** The words a rate is taken over. */
+export const PER = 10_000;
+
+/** A rate per `PER` words; 0 for a body with no words. */
+export const rateOf = (count: number, words: number): number =>
+  words === 0 ? 0 : (PER * count) / words;
+
+/** A measure's band, and the anchors' own range it was widened from. */
+export interface Band {
+  readonly min: number;
+  readonly max: number;
+  readonly anchorMin: number;
+  readonly anchorMax: number;
+  readonly anchors: number;
+}
+
+/** One anchor's rate of a measure, and how far one standard deviation of its count reaches. */
+const anchorRate = (a: RegisterAnchor, m: RegisterMeasureName) => {
+  const count = a.counts[m];
+  return {
+    rate: rateOf(count, a.words),
+    sd: rateOf(Math.sqrt(Math.max(count, 1)), a.words),
+  };
+};
+
+/** The band the anchors set for a measure; null when there are no anchors. */
+export function bandOf(
+  anchors: readonly RegisterAnchor[],
+  m: RegisterMeasureName,
+): Band | null {
+  const rates = anchors.map((a) => anchorRate(a, m));
+  const low = rates.reduce<(typeof rates)[number] | null>(
+    (lo, r) => (lo === null || r.rate < lo.rate ? r : lo),
+    null,
+  );
+  const high = rates.reduce<(typeof rates)[number] | null>(
+    (hi, r) => (hi === null || r.rate > hi.rate ? r : hi),
+    null,
+  );
+  if (low === null || high === null) return null;
+  return {
+    min: Math.max(0, low.rate - NOISE_SDS * low.sd),
+    max: high.rate + NOISE_SDS * high.sd,
+    anchorMin: low.rate,
+    anchorMax: high.rate,
+    anchors: anchors.length,
+  };
+}
+
+// ── sentences, as every register measure reads them ───────────────────────────────
+
+/** The characters a mark or math stands as in a sentence's text. */
+const MARK = new RegExp(`[${CITATION}${REFERENCE}${MATH}]`, "gu");
+
+const WORDS = new Intl.Segmenter("en", { granularity: "word" });
+
+/** A sentence of the body: its text as the reader sees it, its words, its first word, where it stands. */
+export interface BodySentence {
+  /** The text with marks and math left out and spaces collapsed, for a message. */
+  readonly text: string;
+  /** The text with each mark and math as one character, for matching. */
+  readonly raw: string;
+  /** Its word-like words, and one for each mark or math, as it reads on the page. */
+  readonly words: number;
+  readonly first: string;
+  /** The run it was cut from, and where in that run's text it starts. */
+  readonly run: TextRun;
+  readonly from: number;
+}
+
+/** The body's sentences that hold a word, in order. */
+export function bodySentences(
+  passages: readonly Passage[],
+): readonly BodySentence[] {
+  return passages.flatMap((p) => {
+    const run = runOf(p);
+    const text = runText(run);
+    return sentences(text).flatMap(([from, to]) => {
+      const raw = text.slice(from, to);
+      const words = [...WORDS.segment(raw)].filter((w) => w.isWordLike);
+      const [first] = words;
+      if (first === undefined) return [];
+      return [
+        {
+          text: raw.replace(MARK, "").replace(/\s+/gu, " ").trim(),
+          raw,
+          words: words.length + (raw.match(MARK)?.length ?? 0),
+          first: first.segment,
+          run,
+          from,
+        },
+      ];
+    });
+  });
+}
+
+/** The body's words. */
+export const wordsOf = (ss: readonly BodySentence[]): number =>
+  ss.reduce((n, s) => n + s.words, 0);
+
+// ── the measures ──────────────────────────────────────────────────────────────────
+
+/**
+ * One occurrence of a measure: the words around it as the reader sees them, the sentence it stands
+ * in, and where it is.
+ */
+export interface Occurrence {
+  readonly match: string;
+  readonly sentence: string;
+  readonly at: Span | null;
+}
+
+/** The forms as one pattern: matched left to right, so one phrase is never two occurrences. */
+const anyOf = (forms: readonly RegExp[]): Readonly<RegExp> =>
+  new RegExp(forms.map((r) => `(?:${r.source})`).join("|"), "giu");
+
+/**
+ * «not» after a comma, a dash (`---` as the source spells it) or a semicolon — «the word, not the
+ * operation», «--- not authenticity» —
+ * unless it opens a phrase that rejects nothing («not only», «not yet», «not already in the corpus»).
+ */
+const COMMA_NOT =
+  /(?:[,;—–]|--)\s*(?:and\s+|but\s+)?not\s+(?!(?:only|least|yet|always|necessarily|all|even|just|merely|surprisingly|already|to)\b)/giu;
+
+/** «not X but Y» inside one clause — no comma, colon or semicolon between — but not «not only … but also». */
+const NOT_BUT = /\bnot\b(?!\s+only\b)[^.;:,]{1,60}?\bbut\b(?!\s+also\b)/giu;
+
+/** Every form of a contrast frame, as one pattern over one sentence. */
+const CONTRAST_FRAME = anyOf([
+  COMMA_NOT,
+  NOT_BUT,
+  /\brather\s+than\b/u,
+  /\binstead\s+of\b/u,
+  /\bas\s+opposed\s+to\b/u,
+]);
+
+/**
+ * Words that name the relation between a sentence and the one before it: cause, consequence,
+ * contrast, concession, example, restatement. The list is the one the register diagnosis measured
+ * (every marker whose meaning does not depend on context), not tuned to this corpus.
+ */
+const RELATION_MARKERS =
+  /(?<![\p{L}])(?:therefore|thus|hence|consequently|as a result|because|since|this means|this implies|which explains|in turn|that is,|i\.e\.|in contrast|by contrast|however|nevertheless|nonetheless|whereas|in other words|for this reason|it follows|accordingly|specifically,|in particular,|for example|for instance|e\.g\.)(?![\p{L}])/giu;
+
+/** How many characters of context an excerpt keeps on each side of a match. */
+const CONTEXT = 40;
+
+/**
+ * The words around `[from, to)` of a sentence as the reader sees them: the match with up to
+ * `CONTEXT` characters on each side, cut at a word, marks and math left out.
+ */
+export function excerpt(raw: string, from: number, to: number): string {
+  const start = Math.max(0, from - CONTEXT);
+  const end = Math.min(raw.length, to + CONTEXT);
+  const words = raw
+    .slice(start, end)
+    .replace(MARK, "")
+    .split(/\s+/u)
+    .filter((w) => w !== "");
+  const inner = words.slice(
+    start > 0 ? 1 : 0,
+    end < raw.length ? -1 : words.length,
+  );
+  return `${start > 0 ? "…" : ""}${inner.join(" ")}${end < raw.length ? "…" : ""}`;
+}
+
+/** Every match of `pattern` in every sentence, in order, with where it stands. */
+function occurrences(
+  ss: readonly BodySentence[],
+  pattern: Readonly<RegExp>,
+): readonly Occurrence[] {
+  return ss.flatMap((s) =>
+    [...s.raw.matchAll(pattern)].map((m) => ({
+      match: excerpt(s.raw, m.index, m.index + m[0].length),
+      sentence: s.text,
+      at: spanIn(s.run, s.from + m.index, s.from + m.index + m[0].length),
+    })),
+  );
+}
+
+/** The contrast frames of the body's sentences. */
+export const contrastFrames = (
+  ss: readonly BodySentence[],
+): readonly Occurrence[] => occurrences(ss, CONTRAST_FRAME);
+
+/** The relation markers of the body's sentences. */
+export const relationMarkers = (
+  ss: readonly BodySentence[],
+): readonly Occurrence[] => occurrences(ss, RELATION_MARKERS);
+
+/** A phrase this long or longer states something rather than names it. */
+export const CLAIM_WORDS = 6;
+
+const wordCount = (s: string): number =>
+  [...WORDS.segment(s)].filter((w) => w.isWordLike).length;
+
+/**
+ * Whether an emphasised phrase is a claim set in bold: bold, inside its sentence (not a label that
+ * opens a paragraph or an item), and either `CLAIM_WORDS` words long or holding a number.
+ */
+export const isClaimEmphasis = (e: Emphasis): boolean =>
+  e.style === "bold" &&
+  e.place === "inline" &&
+  (wordCount(e.text) >= CLAIM_WORDS || /\p{N}/u.test(e.text));
+
+/** The claims the body sets in bold. */
+export const claimEmphasis = (es: readonly Emphasis[]): readonly Occurrence[] =>
+  es.filter(isClaimEmphasis).map((e) => ({
+    match: e.text,
+    sentence: e.text,
+    at: e.span,
+  }));

package/src/domain/tex-document.ts

@@ -110,9 +110,21 @@ export const runText = (run: TextRun): string =>
 
 /** The source offset of the `i`-th character of the text these segments make, or null outside it. */
 function offsetIn(segments: readonly Segment[], i: number): number | null {
-  const [s, ...rest] = segments;
-  if (s === undefined || i < 0) return null;
-  return i < s.text.length ? s.at + i : offsetIn(rest, i - s.text.length);
+  if (i < 0) return null;
+  // One pass, no copy of the rest per segment: a paragraph's run holds thousands of segments.
+  const found = segments.reduce<{
+    readonly rest: number;
+    readonly at: number | null;
+  }>(
+    (acc, s) =>
+      acc.at !== null
+        ? acc
+        : acc.rest < s.text.length
+          ? { rest: acc.rest, at: s.at + acc.rest }
+          : { rest: acc.rest - s.text.length, at: null },
+    { rest: i, at: null },
+  );
+  return found.at;
 }
 
 /**
@@ -141,3 +153,35 @@ export type ProsePiece =
 export interface Passage {
   readonly pieces: readonly [ProsePiece, ...ProsePiece[]];
 }
+
+/** How an emphasised phrase is set: bold, italic (or `\emph`), or underlined. */
+export type EmphasisStyle = "bold" | "italic" | "underline";
+
+/**
+ * Where an emphasised phrase stands: opening its paragraph or list item — a label, set like a run-in
+ * heading even without the full stop (`\item \textbf{A corpus of questions}: …`) — or inside the
+ * running text, after other words of its sentence.
+ */
+export type EmphasisPlace = "opening" | "inline";
+
+/**
+ * A phrase set in bold, italics or underline inside the body's running prose — not a heading, a
+ * run-in heading, a caption, a float or a table, which are never prose (`LatexReader.bodyProse`).
+ * `text` is what it typesets, marks and math left out.
+ */
+export interface Emphasis {
+  readonly style: EmphasisStyle;
+  readonly place: EmphasisPlace;
+  readonly text: string;
+  readonly span: Span;
+}
+
+/**
+ * A command that changes the page layout a venue's template sets: the text block, the margins,
+ * the line spacing, or space pulled back with a negative skip. `command` is how a message names it
+ * (`\setlength{\textheight}`, `\vspace{-2mm}`).
+ */
+export interface LayoutOverride {
+  readonly command: string;
+  readonly place: Place;
+}

package/src/facts-file.test.ts

@@ -82,14 +82,24 @@ const doc = (last: PageText, geometry: Geometry = NONE) =>
     sha: "a".repeat(64),
     venue: "agenticdev",
     kind: "short",
-    read: { pages: 4, fonts: FONTS, last, layout: [] },
+    read: {
+      pages: 4,
+      fonts: FONTS,
+      last,
+      layout: [],
+      pageTexts: [],
+      links: [],
+      bibAnchorPage: null,
+      appendixAnchorPage: null,
+      metadata: {},
+    },
     geometry,
   });
 
 // ── the document ────────────────────────────────────────────────────────────────────────
-test("schema 2; a measured last page gives both heights, in both fields", () => {
+test("schema 3; a measured last page gives both heights, in both fields", () => {
   const d = doc(lastPage(60, 30));
-  assert.equal(d.schema, 2);
+  assert.equal(d.schema, 3);
   assert.deepEqual(d.last_page, { kind: "measured", columns_pt: [600, 300] });
   assert.deepEqual(d.last_page_cols_pt, [600, 300]);
   assert.equal(d.npages, 4);
@@ -150,7 +160,17 @@ const PDF_BYTES = "%PDF-pretend";
 const good: PdfReader = () =>
   Promise.resolve({
     ok: true,
-    facts: { pages: 2, fonts: FONTS, last: lastPage(60, 60), layout: [] },
+    facts: {
+      pages: 2,
+      fonts: FONTS,
+      last: lastPage(60, 60),
+      layout: [],
+      pageTexts: [],
+      links: [],
+      bibAnchorPage: null,
+      appendixAnchorPage: null,
+      metadata: {},
+    },
   });
 /** The shipped presets at their real paths: `extends` resolves through the same Files port. */
 const SHIPPED_PRESETS = Object.fromEntries(
@@ -290,6 +310,11 @@ test("a PDF with no text has an empty font list, not a failed document", () => {
       fonts: { kind: "no-text" },
       last: lastPage(0, 0),
       layout: [],
+      pageTexts: [],
+      links: [],
+      bibAnchorPage: null,
+      appendixAnchorPage: null,
+      metadata: {},
     },
     geometry: NONE,
   });
@@ -387,3 +412,74 @@ test("parseFactsText: a missing schema is reported as null, another schema by it
   const other = parse({ ...written(), schema: 1 });
   assert.deepEqual(!other.ok && other.error, { kind: "schema", got: "1" });
 });
+
+test("schema 3: what the PDF says is written, and reads back typed", () => {
+  const said = {
+    ...written(),
+    pages_text: ["Ada Example\nIntroduction", "References"],
+    metadata: { Author: "Ada Example" },
+    links: [{ page: 1, uri: "https://github.com/adaexample" }],
+    bib_anchor_page: 2,
+    appendix_anchor_page: 3,
+  };
+  const r = parse(said);
+  assert.ok(r.ok);
+  assert.deepEqual(r.value.text, {
+    pages: ["Ada Example\nIntroduction", "References"],
+    metadata: { Author: "Ada Example" },
+    links: [{ page: 1, uri: "https://github.com/adaexample" }],
+    bibAnchorPage: 2,
+    appendixAnchorPage: 3,
+  });
+  const d = factsDocument({
+    pdf: "paper.pdf",
+    sha: "a".repeat(64),
+    venue: null,
+    kind: null,
+    read: {
+      pages: 1,
+      fonts: FONTS,
+      last: lastPage(1, 0),
+      layout: [],
+      pageTexts: ["x"],
+      links: [{ page: 1, uri: "u" }],
+      bibAnchorPage: 1,
+      appendixAnchorPage: null,
+      metadata: { Title: "t" },
+    },
+    geometry: MEASURED,
+  });
+  assert.deepEqual(
+    [
+      d.pages_text,
+      d.links,
+      d.bib_anchor_page,
+      d.appendix_anchor_page,
+      d.metadata,
+    ],
+    [["x"], [{ page: 1, uri: "u" }], 1, null, { Title: "t" }],
+  );
+});
+
+test("schema 3: a missing or malformed text field is refused, naming it", () => {
+  const noText = Object.fromEntries(
+    Object.entries(written()).filter(([k]) => k !== "pages_text"),
+  );
+  assert.equal(why(noText), "`pages_text` is not a list of strings");
+  assert.equal(
+    why({ ...written(), metadata: { Author: 3 } }),
+    "`metadata` is not an object of strings",
+  );
+  assert.equal(
+    why({ ...written(), links: [{ page: 0, uri: "u" }] }),
+    "`links` is not a list of { page, uri }",
+  );
+  assert.equal(
+    why({ ...written(), bib_anchor_page: 0 }),
+    "`bib_anchor_page` is neither a page number nor null",
+  );
+  assert.equal(
+    why({ ...written(), appendix_anchor_page: "3" }),
+    "`appendix_anchor_page` is neither a page number nor null",
+  );
+});

package/src/facts-file.ts

@@ -26,6 +26,14 @@
  * fonts are all named `Type3`; `embedded` means a usable program is present, so a corrupted one is
  * false. `pdf` is now relative to the PAPER directory, not to wherever the command ran.
  *
+ * ── SCHEMA 3 (2026-09-29) ───────────────────────────────────────────────────────
+ * Adds what the PDF SAYS, for the rules that judge text rather than geometry: `pages_text` (each
+ * page's text, in content order), `metadata` (the Info dictionary and the XMP packet, flat),
+ * `links` (every link annotation's target and page), `bib_anchor_page` and `appendix_anchor_page`
+ * (the pages hyperref anchored the bibliography's first entry and the appendix on, or null). Every schema-2 field keeps its name and meaning. The number moves anyway: `anonymity/identity` and `format/page-limit` read these fields,
+ * and schema-2 facts without them would be judged as a PDF that says nothing — a clean pass over no
+ * input. A schema-2 file is refused by `pdf/fresh` with "rebuild", which is one `paperlint build`.
+ *
  * 🔴 STALENESS. The PDF is not committed, so neither are these facts: they live in `_build/` and
  * carry `pdf_sha256`. A rule compares it with the PDF on disk and refuses facts about another build.
  */
@@ -52,7 +60,7 @@ import { paperPreset, paperPresetProblem } from "./presets.ts";
 import { presetsDir } from "./package-dirs.ts";
 import { messageOf } from "./domain/text.ts";
 
-export const FACTS_SCHEMA = 2;
+export const FACTS_SCHEMA = 3;
 export const FACTS_DIR = "_build";
 export const FACTS_FILE = "paper.facts.json";
 
@@ -123,7 +131,17 @@ export type FactsDocument = {
   readonly last_page: LastPageEntry;
   /** Schema 1's field, kept: the two heights, or null when the last page is a stub or a review build. */
   readonly last_page_cols_pt: readonly [number, number] | null;
-} & FactsGeometryFields;
+} & FactsTextFields &
+  FactsGeometryFields;
+
+/** Schema 3's fields: what the PDF says (see the module header). */
+export interface FactsTextFields {
+  readonly pages_text: readonly string[];
+  readonly metadata: Readonly<Record<string, string>>;
+  readonly links: readonly { readonly page: number; readonly uri: string }[];
+  readonly bib_anchor_page: number | null;
+  readonly appendix_anchor_page: number | null;
+}
 
 export function fontEntry(f: FontFact): FontEntry {
   return {
@@ -170,6 +188,11 @@ export function factsDocument(i: FactsInput): FactsDocument {
       i.read.fonts.kind === "drawn" ? i.read.fonts.list.map(fontEntry) : [],
     last_page: last,
     last_page_cols_pt: last.kind === "measured" ? last.columns_pt : null,
+    pages_text: i.read.pageTexts,
+    metadata: i.read.metadata,
+    links: i.read.links,
+    bib_anchor_page: i.read.bibAnchorPage,
+    appendix_anchor_page: i.read.appendixAnchorPage,
     ...flatGeometry(i.geometry),
   };
 }
@@ -249,6 +272,19 @@ export interface ReadFacts {
   readonly fonts: readonly FontEntry[];
   /** The geometry columns, or null when no measurer ran (`geometry_source` is null). */
   readonly geometry: FlatGeometry | null;
+  /** What the PDF says: schema 3's fields, parsed. */
+  readonly text: TextFacts;
+}
+
+/** Schema 3's fields as a rule reads them. */
+export interface TextFacts {
+  readonly pages: readonly string[];
+  readonly metadata: Readonly<Record<string, string>>;
+  readonly links: readonly { readonly page: number; readonly uri: string }[];
+  /** The page of the first bibliography entry hyperref anchored, or null. */
+  readonly bibAnchorPage: number | null;
+  /** The page hyperref anchored the appendix on, or null. */
+  readonly appendixAnchorPage: number | null;
 }
 
 /** Why a facts file cannot be judged. */
@@ -331,6 +367,56 @@ function geometryOf(
   });
 }
 
+const isPage = (v: unknown): v is number =>
+  typeof v === "number" && Number.isInteger(v) && v > 0;
+const isPageOrNull = (v: unknown): v is number | null =>
+  v === null || isPage(v);
+const isStrings = (v: unknown): v is readonly string[] =>
+  Array.isArray(v) && v.every((x) => typeof x === "string");
+const isStringRecord = (v: unknown): v is Readonly<Record<string, string>> =>
+  isRecord(v) && Object.values(v).every((x) => typeof x === "string");
+const isLinks = (
+  v: unknown,
+): v is readonly { readonly page: number; readonly uri: string }[] =>
+  Array.isArray(v) &&
+  v.every(
+    (l) => isRecord(l) && isPage(l["page"]) && typeof l["uri"] === "string",
+  );
+
+/** Schema 3's fields, or which one is wrong. */
+function textOf(
+  d: Readonly<Record<string, unknown>>,
+): Result<TextFacts, string> {
+  const { pages_text, metadata, links } = d;
+  const { bib_anchor_page, appendix_anchor_page } = d;
+  if (!isStrings(pages_text))
+    return err("`pages_text` is not a list of strings");
+  if (!isStringRecord(metadata))
+    return err("`metadata` is not an object of strings");
+  if (!isLinks(links)) return err("`links` is not a list of { page, uri }");
+  if (!isPageOrNull(bib_anchor_page))
+    return err("`bib_anchor_page` is neither a page number nor null");
+  if (!isPageOrNull(appendix_anchor_page))
+    return err("`appendix_anchor_page` is neither a page number nor null");
+  return ok({
+    pages: pages_text,
+    metadata,
+    links,
+    bibAnchorPage: bib_anchor_page,
+    appendixAnchorPage: appendix_anchor_page,
+  });
+}
+
+/** What the PDF measures and what it says: the geometry columns and schema 3's fields. */
+function contentOf(
+  d: Readonly<Record<string, unknown>>,
+): Result<Pick<ReadFacts, "geometry" | "text">, string> {
+  const geometry = geometryOf(d);
+  if (!geometry.ok) return geometry;
+  const text = textOf(d);
+  return text.ok ? ok({ geometry: geometry.value, text: text.value }) : text;
+}
+
 /** The PDF the facts describe: its path and its sha256. */
 function artifactOf(
   d: Readonly<Record<string, unknown>>,
@@ -368,11 +454,7 @@ export function parseFactsText(text: string): Result<ReadFacts, FactsProblem> {
       kind: "broken",
       why: "`fonts` is not a list of { name, type, embedded, program }",
     });
-  const geometry = geometryOf(d);
-  if (!geometry.ok) return err({ kind: "broken", why: geometry.error });
-  return ok({
-    ...artifact.value,
-    fonts,
-    geometry: geometry.value,
-  });
+  const content = contentOf(d);
+  if (!content.ok) return err({ kind: "broken", why: content.error });
+  return ok({ ...artifact.value, fonts, ...content.value });
 }

package/src/new-paper.test.ts

@@ -51,7 +51,13 @@ describe("paperlint new — paperlint.json", () => {
     expect(String(s["$comment"])).toMatch(/paperlint:agenticdev/);
     expect(parsePaperSettings(s)).toEqual({
       ok: true,
-      value: { extends: null, kind: null, pdf: null, rules: null },
+      value: {
+        extends: null,
+        kind: null,
+        pdf: null,
+        rules: null,
+        identity: null,
+      },
     });
   });