paperlint 6.3.0 → 7.0.0

package/src/rule-cases.test.ts

@@ -18,7 +18,7 @@ import { z } from "zod";
 import { run, rulePlugins } from "./cli.ts";
 import { sha256Hex } from "./domain/sha256.ts";
 import { bibHash } from "./references.ts";
-import { useTempDir, writeTree } from "../test/support.ts";
+import { useTempDir, venuePreset, writeTree } from "../test/support.ts";
 
 const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 const fixture = (p: string): string =>
@@ -39,19 +39,87 @@ const paper = (
   ...extra,
 });
 
+// ── the venues: presets of the tree's own, never the shipped ones ──────────────────────────────
+//
+// A case judges a RULE, so every number it is sized against is written here, beside the facts and
+// the bodies that meet or miss it. A shipped venue preset changes when its call for papers does;
+// its own tests resolve and judge it (presets.test.ts, venue-rules.test.ts, tex-venue-rules.test.ts,
+// register-bands.test.ts, heading-case.test.ts). The one exception is the leftover rules, below:
+// they name SHIPPED venues by design, so their reporting cases need one shipped venue's name.
+// The venues below extend a template family only for what the schema asks of a chain's root (its
+// `tex`), and set every key a case reads themselves.
+
+/** A short-paper venue on the ACM template: the format the facts of `goodFacts` meet. */
+const EXAMPLECONF = venuePreset("ExampleConf", {
+  extends: "paperlint:acm-sigconf",
+  format: {
+    page_w_in: 8.5,
+    page_h_in: 11,
+    columns: 2,
+    body_pt: 9,
+    body_pt_tol: 0.5,
+    ref_pt_min: 7,
+    ref_pt_max: 9,
+    fonts_text: "LinLibertine",
+    fonts_title: "LinBiolinum",
+    kinds: { short: { body_pages_max: 5, ref_pages_max: 2 } },
+  },
+  // chicago-headline for the title and every heading (tex/heading-case).
+  rules: {
+    "tex/heading-case": [
+      "error",
+      { title: "chicago-headline", headings: "chicago-headline" },
+    ],
+  },
+});
+const IEEE = "\\documentclass[conference,compsoc]{IEEEtran}";
+const STATEMENT_TITLE = "LLM Usage Statement";
+/**
+ * A double-blind venue on the IEEE template: the class options it requires, the section it requires
+ * last, and one accepted paper of 10,000 words for the register bands. Its rates (contrast frames 4,
+ * claims in bold 4, relation markers 64 per 10,000 words), widened by two Poisson standard
+ * deviations, set the bands 0–8, 0–8 and 48–80.
+ */
+const BLINDCONF = venuePreset("BlindConf", {
+  extends: "paperlint:ieee-conference",
+  blind: true,
+  template: IEEE,
+  required_sections: [{ title: STATEMENT_TITLE, position: "last" }],
+  register: {
+    anchors: [
+      {
+        paper: "an-accepted-paper",
+        words: 10_000,
+        contrast_frames: 4,
+        claim_emphasis: 4,
+        relation_markers: 64,
+      },
+    ],
+  },
+});
+/** The venue presets every built paper carries beside it, extended or not. */
+const VENUES = {
+  [`${P}/exampleconf.jsonc`]: JSON.stringify(EXAMPLECONF),
+  [`${P}/blindconf.jsonc`]: JSON.stringify(BLINDCONF),
+};
+/** A paper folder on BlindConf: the preset beside its `paperlint.json`. */
+const onBlindConf = (dir: string): Record<string, string> => ({
+  [`${dir}/blindconf.jsonc`]: JSON.stringify(BLINDCONF),
+  [`${dir}/paperlint.json`]: JSON.stringify({ extends: "./blindconf.jsonc" }),
+});
+
 // ── the venue rules' inputs: a PDF and the facts `paperlint build` would write about it ─────────
 
 const PDF = "%PDF-1.5 a stand-in for the built PDF";
-const AGENTICDEV = { extends: "paperlint:agenticdev", kind: "short" };
+const EXAMPLE = { extends: "./exampleconf.jsonc", kind: "short" };
 /** A double-blind venue's paper that declares who wrote it (`anonymity/*`). */
 const BLIND = {
-  extends: "paperlint:aidc",
-  kind: "regular",
+  extends: "./blindconf.jsonc",
   identity: ["Ada Example", "adaexample"],
 };
 const ACM_TEX = tex("Text.", "\\documentclass[sigconf]{acmart}");
 
-/** The facts of a short agenticdev paper that meets every number in its preset. */
+/** The facts of a short ExampleConf paper that meets every number in its preset. */
 const goodFacts = (): Record<string, unknown> => ({
   schema: 3,
   pages_text: [],
@@ -61,7 +129,7 @@ const goodFacts = (): Record<string, unknown> => ({
   appendix_anchor_page: null,
   pdf: "paper.pdf",
   pdf_sha256: sha256Hex(new TextEncoder().encode(PDF)),
-  venue: "agenticdev",
+  venue: "exampleconf",
   kind: "short",
   npages: 7,
   fonts_source: "pdfjs-drawn",
@@ -85,12 +153,13 @@ const goodFacts = (): Record<string, unknown> => ({
   pages_by_type: { body: 5, bib: 2 },
 });
 
-/** An agenticdev paper, built: its settings, the PDF, and facts with `patch` applied. */
+/** An ExampleConf paper, built: its settings, the PDF, and facts with `patch` applied. */
 const built = (
   patch: Record<string, unknown> = {},
-  settings: Record<string, unknown> = AGENTICDEV,
+  settings: Record<string, unknown> = EXAMPLE,
 ): Record<string, string> =>
   paper(ACM_TEX, {
+    ...VENUES,
     [`${P}/paperlint.json`]: JSON.stringify(settings),
     [`${P}/paper.pdf`]: PDF,
     [`${P}/_build/paper.facts.json`]: JSON.stringify({
@@ -129,23 +198,26 @@ const checked = (exists: string, authors: string) => ({
   entries: [{ key: "a", exists, authors }],
 });
 
-// ── an AIDC paper, for the LaTeX venue rules ──────────────────────────────────────────────────
+// ── a BlindConf paper, for the LaTeX venue rules ──────────────────────────────────────────────
 
-const AIDC = {
-  [`${P}/paperlint.json`]: JSON.stringify({
-    extends: "paperlint:aidc",
-    kind: "short",
-  }),
+const BLIND_PAPER = onBlindConf(P);
+const ACM_CLASS = "\\documentclass[sigconf]{acmart}";
+/** A paper on ExampleConf's preset: it turns `tex/heading-case` on, chicago-headline for the title and every heading. */
+const ACM_PRESET = {
+  ...VENUES,
+  [`${P}/paperlint.json`]: JSON.stringify(EXAMPLE),
 };
-const IEEE = "\\documentclass[conference,compsoc]{IEEEtran}";
-const STATEMENT = "\\section*{LLM Usage Statement}\nNone.";
+const STATEMENT = `\\section*{${STATEMENT_TITLE}}\nNone.`;
 /** Two `\\documentclass` lines behind a switch: `article` for one venue, `second` for this one. */
 const switched = (second: string): string =>
   `\\def\\venue{2}\n\\if\\venue1\n\\documentclass{article}\n\\fi\n\\if\\venue2\n${second}\n\\fi`;
-const aidc = (body: string, cls = IEEE) =>
-  paper(tex(`\\section{Introduction}\n${body}\n${STATEMENT}`, cls), AIDC);
+const blind = (body: string, cls = IEEE) =>
+  paper(
+    tex(`\\section{Introduction}\n${body}\n${STATEMENT}`, cls),
+    BLIND_PAPER,
+  );
 
-// ── a paper that declares a talk: a preset of its own over agenticdev, and synthetic media ───────
+// ── a paper that declares a talk: a preset of its own over ExampleConf, and synthetic media ──────
 
 const media = (name: string): Uint8Array =>
   readFileSync(join(ROOT, "fixtures", "talk", name));
@@ -173,10 +245,13 @@ const talkPaper = (
   };
   return {
     ...paper(ACM_TEX, {
-      [`${P}/talk-venue.jsonc`]: JSON.stringify({
-        extends: "paperlint:agenticdev",
-        talk: { ...TALK_VENUE, ...venue },
-      }),
+      ...VENUES,
+      [`${P}/talk-venue.jsonc`]: JSON.stringify(
+        venuePreset("talk-venue", {
+          extends: "./exampleconf.jsonc",
+          talk: { ...TALK_VENUE, ...venue },
+        }),
+      ),
       [`${P}/paperlint.json`]: JSON.stringify({
         extends: "./talk-venue.jsonc",
         kind: "short",
@@ -226,7 +301,7 @@ const FORMAL = Array.from(
 /** FORMAL with `n` more sentences `s`: a body whose rate of one register measure is set. */
 const formalWith = (n: number, s: string): string =>
   `${FORMAL} ${Array.from({ length: n }, () => s).join(" ")}`;
-/** FORMAL with enough relation markers for AIDC's band (above 25.4 per 10,000 words). */
+/** FORMAL with 20 relation markers, 68.7 per 10,000 words: inside BlindConf's band (48–80). */
 const LINKED = formalWith(
   10,
   "Therefore, the rule counts the sentence because the body holds it.",
@@ -373,49 +448,60 @@ const CASES: Readonly<Record<string, RuleCases>> = {
   // The class picked behind a TeX switch: two candidates, one of them the venue's or none.
   "tex/template": {
     reports: {
-      tree: aidc("Text.", switched("\\documentclass[conference]{IEEEtran}")),
+      tree: blind("Text.", switched("\\documentclass[conference]{IEEEtran}")),
       file: TEX_FILE,
       severity: 2,
       line: 3,
     },
-    silent: aidc("Text.", switched(IEEE)),
+    silent: blind("Text.", switched(IEEE)),
   },
   "tex/required-section": {
     reports: {
-      tree: paper(tex("\\section{Introduction}\nText.", IEEE), AIDC),
+      tree: paper(tex("\\section{Introduction}\nText.", IEEE), BLIND_PAPER),
       file: TEX_FILE,
       severity: 2,
       line: 5,
     },
-    silent: aidc("Text."),
+    silent: blind("Text."),
+  },
+  "tex/heading-case": {
+    reports: {
+      tree: paper(tex("\\section{Related work}", ACM_CLASS), ACM_PRESET),
+      file: TEX_FILE,
+      severity: 2,
+      line: 3,
+    },
+    silent: paper(tex("\\section{Related Work}", ACM_CLASS), ACM_PRESET),
   },
   "paper/folder-venue-leftover": {
     reports: {
-      // An AIDC paper still in the folder it had when it targeted AISec.
+      // A BlindConf paper in a folder named for EMNLP. The rule knows only the SHIPPED venues'
+      // names (REALM's preset calls it by its conference, EMNLP), so the other venue is one of them.
       tree: {
-        "papers/aisec-2026/PIPELINE-STATUS.md": STATUS,
-        "papers/aisec-2026/paper.tex": tex("x"),
-        "papers/aisec-2026/paperlint.json": AIDC[`${P}/paperlint.json`],
+        "papers/emnlp-2026/PIPELINE-STATUS.md": STATUS,
+        "papers/emnlp-2026/paper.tex": tex("x"),
+        ...onBlindConf("papers/emnlp-2026"),
       },
-      file: "papers/aisec-2026/PIPELINE-STATUS.md",
+      file: "papers/emnlp-2026/PIPELINE-STATUS.md",
       severity: 1,
       line: 1,
     },
     // The folder names the paper's own venue.
     silent: {
-      "papers/aidc-2026/PIPELINE-STATUS.md": STATUS,
-      "papers/aidc-2026/paper.tex": tex("x"),
-      "papers/aidc-2026/paperlint.json": AIDC[`${P}/paperlint.json`],
+      "papers/blindconf-2026/PIPELINE-STATUS.md": STATUS,
+      "papers/blindconf-2026/paper.tex": tex("x"),
+      ...onBlindConf("papers/blindconf-2026"),
     },
   },
+  // EMNLP, a shipped venue's name (REALM's conference), in a BlindConf paper's text.
   "tex/venue-leftover": {
     reports: {
-      tree: aidc("First written for AISec."),
+      tree: blind("First written for EMNLP."),
       file: TEX_FILE,
       severity: 1,
       line: 4,
     },
-    silent: aidc("Text."),
+    silent: blind("Text."),
   },
   "tex/claim-provenance": {
     reports: {
@@ -439,31 +525,31 @@ const CASES: Readonly<Record<string, RuleCases>> = {
     },
     silent: paper(tex(FORMAL)),
   },
-  // The three register bands judge a body against the anchors of AIDC's preset; the body opens on
-  // line 3, right after the \\section, where the finding about the whole body stands.
+  // The three register bands judge a body against the anchor of BlindConf's preset; the body opens
+  // on line 3, right after the \\section, where the finding about the whole body stands.
   "tex/contrast-frames": {
     reports: {
-      tree: aidc(formalWith(5, "It reads the word, not the operation.")),
+      tree: blind(formalWith(5, "It reads the word, not the operation.")),
       file: TEX_FILE,
       severity: 1,
       line: 3,
     },
-    silent: aidc(LINKED),
+    silent: blind(LINKED),
   },
   "tex/claim-emphasis": {
     reports: {
-      tree: aidc(
+      tree: blind(
         formalWith(6, "We find that \\textbf{the rule counts 46 sentences}."),
       ),
       file: TEX_FILE,
       severity: 1,
       line: 3,
     },
-    silent: aidc(LINKED),
+    silent: blind(LINKED),
   },
   "tex/relation-markers": {
-    reports: { tree: aidc(FORMAL), file: TEX_FILE, severity: 1, line: 3 },
-    silent: aidc(LINKED),
+    reports: { tree: blind(FORMAL), file: TEX_FILE, severity: 1, line: 3 },
+    silent: blind(LINKED),
   },
   "bib/reachable-entry": {
     reports: {
@@ -518,23 +604,23 @@ const CASES: Readonly<Record<string, RuleCases>> = {
   },
   "format/layout-override": {
     reports: {
-      tree: aidc("\\linespread{0.9}Text."),
+      tree: blind("\\linespread{0.9}Text."),
       file: TEX_FILE,
       severity: 2,
       line: 4,
     },
-    silent: aidc("\\vspace{-2mm}Text."),
+    silent: blind("\\vspace{-2mm}Text."),
   },
   "pdf/last-page-balance": {
     reports: onPdf(
       built(
         { last_page: { kind: "measured", columns_pt: [621.5, 264.8] } },
-        { ...AGENTICDEV, rules: { "pdf/last-page-balance": "error" } },
+        { ...EXAMPLE, rules: { "pdf/last-page-balance": "error" } },
       ),
     ),
     silent: built(
       {},
-      { ...AGENTICDEV, rules: { "pdf/last-page-balance": "error" } },
+      { ...EXAMPLE, rules: { "pdf/last-page-balance": "error" } },
     ),
   },
   "talk/profile": {

package/src/submission.test.ts

@@ -27,6 +27,7 @@ import {
   usageProblem,
   type SubmissionArgs,
 } from "./submission.ts";
+import { venuePreset } from "../test/support.ts";
 
 const PAPER = "/w/papers/p";
 const SITE = "http://127.0.0.1:9";
@@ -41,7 +42,7 @@ const withPresets = (fs: Files): Files => ({
 });
 
 const venue = (portal: unknown): string =>
-  JSON.stringify({ extends: "paperlint:aidc", portal });
+  JSON.stringify(venuePreset("venue", { extends: "paperlint:aidc", portal }));
 const files = (o: {
   readonly portal?: unknown;
   readonly paper?: Readonly<Record<string, unknown>>;

package/src/talk-rules.test.ts

@@ -23,7 +23,7 @@ import {
   talkRules,
   type TalkRuleName,
 } from "./talk-rules.ts";
-import { useTempDir, writeTree } from "../test/support.ts";
+import { useTempDir, venuePreset, writeTree } from "../test/support.ts";
 
 const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 const media = (name: string): Uint8Array =>
@@ -62,8 +62,11 @@ function run(
   const dir = useTempDir("paperlint-talk-rules-");
   const venue =
     o.venue === null
-      ? { extends: "paperlint:acm-sigconf" }
-      : { extends: "paperlint:agenticdev", talk: { ...VENUE, ...o.venue } };
+      ? { type: "family", extends: "paperlint:acm-sigconf" }
+      : venuePreset("venue", {
+          extends: "paperlint:agenticdev",
+          talk: { ...VENUE, ...o.venue },
+        });
   writeTree(dir, {
     "package.json": "{}",
     "p/paper.tex": "x",

package/src/tex-requirements.harness.ts

@@ -130,32 +130,40 @@ copyFileSync(join(VENUES, R.SCHEMA_FILE), join(tmp, R.SCHEMA_FILE));
 const bad = (text: string) =>
   throws(() => R.parseProfile(text, "bad.jsonc", tmp));
 const BAD: [string, string, string][] = [
-  ["no `tex` block at all", `{ "template": "acmart" }`, "tex"],
+  [
+    "no `tex` block at all",
+    `{ "type": "family", "template": "acmart" }`,
+    "tex",
+  ],
   // Guards: typo detection — `templat` would be accepted and the field silently unread.
   [
     "an unknown top-level key (a typo)",
-    `{ "tex": { "packages": { "a": ["a.sty"] } }, "templat": "x" }`,
+    `{ "type": "family", "tex": { "packages": { "a": ["a.sty"] } }, "templat": "x" }`,
     "additional properties",
   ],
   [
     "a package with NO proof file",
-    `{ "tex": { "packages": { "acmart": [] } } }`,
+    `{ "type": "family", "tex": { "packages": { "acmart": [] } } }`,
     ".tex.packages['acmart']",
   ],
   [
     "a package name tlmgr would not know (upper case)",
-    `{ "tex": { "packages": { "Acmart": ["acmart.cls"] } } }`,
+    `{ "type": "family", "tex": { "packages": { "Acmart": ["acmart.cls"] } } }`,
     "property name",
   ],
   [
     "a proof that is a path, not a file name",
-    `{ "tex": { "packages": { "a": ["tex/a.sty"] } } }`,
+    `{ "type": "family", "tex": { "packages": { "a": ["tex/a.sty"] } } }`,
     "pattern",
   ],
-  ["an empty packages map", `{ "tex": { "packages": {} } }`, "fewer than 1"],
+  [
+    "an empty packages map",
+    `{ "type": "family", "tex": { "packages": {} } }`,
+    "fewer than 1",
+  ],
   [
     "an unknown key inside tex",
-    `{ "tex": { "packages": { "a": ["a.sty"] }, "pkgs": {} } }`,
+    `{ "type": "family", "tex": { "packages": { "a": ["a.sty"] }, "pkgs": {} } }`,
     "additional properties",
   ],
 ];
@@ -174,7 +182,9 @@ check(
 );
 check(
   "comments and trailing commas ARE JSONC",
-  bad(`// quote\n{ "tex": { "packages": { "a": ["a.sty"], }, }, }`) === "",
+  bad(
+    `// quote\n{ "type": "family", "tex": { "packages": { "a": ["a.sty"], }, }, }`,
+  ) === "",
 );
 rmSync(tmp, { recursive: true, force: true });
 
@@ -239,7 +249,7 @@ rmSync(tmp, { recursive: true, force: true });
 // ── 5. the parser's tolerances: an optional block left out, and Ajv's optional fields ───
 {
   const bare = R.parsePreset(
-    '{ "extends": "paperlint:aisec" }',
+    '{ "type": "venue", "name": "X", "url": "https://x.org/", "extends": "paperlint:aisec" }',
     "bare.jsonc",
     VENUES,
   );
@@ -254,9 +264,13 @@ rmSync(tmp, { recursive: true, force: true });
   check(
     "a tex block without `packages` is refused by the schema, before anything reads it",
     /tex\.jsonc: \.tex should have required property 'packages'/.test(
-      throws(() => R.parsePreset('{ "tex": {} }', "tex.jsonc", VENUES)),
+      throws(() =>
+        R.parsePreset('{ "type": "family", "tex": {} }', "tex.jsonc", VENUES),
+      ),
+    ),
+    throws(() =>
+      R.parsePreset('{ "type": "family", "tex": {} }', "tex.jsonc", VENUES),
     ),
-    throws(() => R.parsePreset('{ "tex": {} }', "tex.jsonc", VENUES)),
   );
   check(
     "violations: Ajv's null `errors` is no violation; a message Ajv left out is an empty one",

package/src/tex-requirements.test.ts

@@ -1,6 +1,11 @@
 import assert from "node:assert/strict";
 import { test } from "vitest";
-import { loadTypescript } from "./tex-requirements.ts";
+import {
+  identityHint,
+  identityHints,
+  loadTypescript,
+  parsePreset,
+} from "./tex-requirements.ts";
 
 test("loadTypescript refuses a module without the two functions a profile is read with", () => {
   assert.throws(
@@ -19,3 +24,124 @@ test("loadTypescript hands back what `require` loaded when it has them", () => {
     ts,
   );
 });
+
+// ── what a preset is: the identity its `type` declares ─────────────────────────────────────
+
+/** What `parsePreset` throws for `preset`, as text; "" when it parses. */
+function refusalOf(name: string, preset: object): string {
+  try {
+    parsePreset(JSON.stringify(preset), name);
+    return "";
+  } catch (e) {
+    return e instanceof Error ? e.message : String(e);
+  }
+}
+
+test("a venue without the link to its call for papers is refused at load, saying what to add", () => {
+  // Guards: the wrong state the identity exists to make unrepresentable — a venue nobody can check.
+  assert.equal(
+    refusalOf("v.jsonc", {
+      type: "venue",
+      name: "X",
+      extends: "paperlint:acm-sigconf",
+    }),
+    [
+      "v.jsonc does not match venue-profile.schema.json:",
+      '  a venue preset names its venue and links its call for papers: "name": "<the venue, as its call spells it>", "url": "https://<the call for papers>"',
+      "  v.jsonc: (top level) should have required property 'url'",
+      '  v.jsonc: (top level) should match "then" schema',
+    ].join("\n"),
+  );
+});
+
+test("a template family with a venue's name and url is refused, naming each key", () => {
+  assert.equal(
+    refusalOf("f.jsonc", {
+      type: "family",
+      name: "ACM",
+      url: "https://acm.org/",
+      extends: "paperlint:acm-sigconf",
+    }),
+    [
+      "f.jsonc does not match venue-profile.schema.json:",
+      '  a template family names no venue: drop "name" — "name" and "url" belong to the venue presets that extend it',
+      '  a template family names no venue: drop "url" — "name" and "url" belong to the venue presets that extend it',
+      "  f.jsonc: .name boolean schema is false",
+      "  f.jsonc: .url boolean schema is false",
+      '  f.jsonc: (top level) should match "then" schema',
+    ].join("\n"),
+  );
+});
+
+test("a preset that does not say what it is is refused, with the three answers", () => {
+  assert.equal(
+    refusalOf("n.jsonc", { extends: "paperlint:acm-sigconf" }),
+    [
+      "n.jsonc does not match venue-profile.schema.json:",
+      '  say what this preset is: "type": "venue" (one venue\'s call for papers), "family" (a publisher\'s template that venues extend) or "base" (the TeX base set)',
+      "  n.jsonc: (top level) should have required property 'type'",
+    ].join("\n"),
+  );
+});
+
+test("the TeX base set holds its packages and nothing else", () => {
+  assert.equal(
+    refusalOf("b.jsonc", {
+      type: "base",
+      tex: { packages: { a: ["a.sty"] } },
+      format: { columns: 2 },
+    }),
+    [
+      "b.jsonc does not match venue-profile.schema.json:",
+      '  the TeX base set holds "type" and "tex" only — a venue\'s or a family\'s settings go in its own preset',
+      "  b.jsonc: (top level) should NOT have more than 2 properties",
+      '  b.jsonc: (top level) should match "then" schema',
+    ].join("\n"),
+  );
+});
+
+test("a venue is parsed into its identity; a family and the base set carry none of a venue's fields", () => {
+  const read = (p: object) =>
+    parsePreset(JSON.stringify(p), "p.jsonc").identity;
+  assert.deepEqual(
+    [
+      read({
+        type: "venue",
+        name: "X",
+        url: "https://x.org/cfp",
+        extends: "paperlint:acm-sigconf",
+      }),
+      read({ type: "family", extends: "paperlint:acm-sigconf" }),
+      read({ type: "base", tex: { packages: { a: ["a.sty"] } } }),
+    ],
+    [
+      { type: "venue", name: "X", url: "https://x.org/cfp" },
+      { type: "family" },
+      { type: "base" },
+    ],
+  );
+});
+
+test("identityHint has nothing to add to a violation that is not about the identity", () => {
+  assert.equal(
+    identityHint({
+      keyword: "additionalProperties",
+      dataPath: "",
+      params: { additionalProperty: "colums" },
+    }),
+    null,
+  );
+});
+
+test("identityHints: Ajv's null errors give none; a hint two violations share is given once", () => {
+  assert.deepEqual(identityHints({ errors: null }), []);
+  const missing = {
+    keyword: "required",
+    dataPath: "",
+    schemaPath: "#/required",
+    params: { missingProperty: "type" },
+  };
+  const hints = identityHints({ errors: [missing, missing] });
+  assert.equal(hints.length, 1);
+  assert.deepEqual(hints, [identityHint(missing)]);
+});