chaffjs 0.25.0 → 0.27.0

package/src/detectors/structure-tree.ts

@@ -1,11 +1,15 @@
-import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.ts";
 import { danglingReferences, duplicateDefinitions, inDocumentOrder, type StructureIssue } from "../structure/issues.ts";
 import { numberingBreaks } from "../structure/numbering.ts";
+import { listNumberBreaks, writtenNumbers } from "../structure/list-numbering.ts";
 import { weekdayMismatches } from "../structure/weekday.ts";
+import { documentDateOf } from "./document-date.ts";
 import { dateOrderBreaks } from "../structure/date-order.ts";
 import { totalMismatches, type Amount } from "../structure/total.ts";
+import { proseTotalMismatches } from "../structure/prose-total.ts";
 import { rangeFrameOf, reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
 import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
+import { proseShareMismatches } from "../structure/percent-sum-prose.ts";
 import { isQuotedAlone } from "../quoted-span.ts";
 
 const QUOTE_LENGTH = 80;
@@ -34,7 +38,39 @@ const findingsOf =
         }));
 
 export const danglingReference: Detector = findingsOf("dangling-reference", danglingReferences);
-export const numberingGap: Detector = findingsOf("numbering-gap", numberingBreaks);
+const structureNumberingGap: Detector = findingsOf("numbering-gap", numberingBreaks);
+
+const lineStartAt = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
+
+/** The written numbers of the document's Markdown ordered lists that skip or repeat (structure/list-numbering.ts). */
+const QUOTED_LINE = /^[ \t]*>/u;
+
+/** 引用の中の箇条書きは、ほかの文書の例で、この文書の番号ではない。 */
+const isQuotedList = (source: string, start: number): boolean => QUOTED_LINE.test(source.slice(lineStartAt(source, start), start));
+
+const listNumberingGaps = (doc: ProseDocument): Finding[] =>
+  doc.lists
+    .filter((list) => !isQuotedList(doc.source, list.span.start))
+    .flatMap((list) => listNumberBreaks(writtenNumbers(doc.source, list.itemSpans) ?? []))
+    .map((issue) => ({
+      rule: "numbering-gap",
+      severity: "error",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: { ...issue.values, offset: issue.offset },
+    }));
+
+/**
+ * 番号の抜けと重なり: 番地の木の並び（条、項、号）と、Markdown の番号付きの箇条書きに書いた番号。条の中の「1.」「2.」は
+ * 両方に読まれるので、木が指した行の箇条書きは重ねて言わない。
+ */
+export const numberingGap: Detector = (doc, options): Finding[] => {
+  const fromTree = structureNumberingGap(doc, options);
+  const reported = new Set(fromTree.map((finding) => lineStartAt(doc.source, Number(finding.values["offset"]))));
+  const fromLists = listNumberingGaps(doc).filter((finding) => !reported.has(lineStartAt(doc.source, Number(finding.values["offset"]))));
+  return [...fromTree, ...fromLists].toSorted((left, right) => Number(left.values["offset"]) - Number(right.values["offset"]));
+};
 export const duplicateDefinition: Detector = findingsOf("duplicate-definition", duplicateDefinitions);
 
 /** 曜日の名前は言語パッケージの語彙表（weekday、日曜日から順）から取る。無ければ番号のまま。 */
@@ -58,10 +94,33 @@ const quotedDates = (doc: ProseDocument, from: DatedSpan | undefined, until: Dat
 
 const dateAt = (dates: readonly DatedSpan[], offset: number): number => dates.findIndex((date) => date.offset === offset);
 
+/** A year written as figures in a heading: 2024年度, FY2024, "2024 events". */
+const YEAR_FIGURES = /(?<![0-9０-９])(?:1[89]|20)\d{2}(?![0-9０-９])/u;
+const ERA_YEAR_NUMBER = /^[ \t]?(?:[0-9０-９]{1,2}|元)/u;
+
+/** 見出しが年を名指すか: 数字の年（2024年度、FY2024）か、暦の元号の年（語彙表 calendar-era、令和6年度）。 */
+const namesYear = (heading: string, eras: readonly string[]): boolean =>
+  YEAR_FIGURES.test(heading) ||
+  eras.some((era) => {
+    const at = heading.indexOf(era);
+    return at !== -1 && ERA_YEAR_NUMBER.test(heading.slice(at + era.length));
+  });
+
 export const dateWeekdayMismatch: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
   const dates = datedSpans(doc.structure);
-  return weekdayMismatches(doc.structure)
+  const sections = doc.sections.filter((section) => section.depth > 0);
+  const eras = (doc.lexicons["calendar-era"] ?? []).map((entry) => entry.pattern);
+  const context = {
+    stamp: documentDateOf(doc, doc.structure),
+    sectionStarts: sections.map((section) => section.span.start),
+    yearHeadings: sections.filter((section) => namesYear(section.heading, eras)).map((section) => section.span.start),
+    anchorable: (node: StructureNode): boolean => {
+      const date = dates[dateAt(dates, node.span.start)];
+      return !quotedDates(doc, date, date, WEEKDAY_WORDS);
+    },
+  };
+  return weekdayMismatches(doc.structure, context)
     .filter((issue) => {
       const date = dates[dateAt(dates, issue.offset)];
       return !quotedDates(doc, date, date, WEEKDAY_WORDS);
@@ -104,15 +163,35 @@ const amountsOf = (tree: NonNullable<ProseDocument["structure"]>): Amount[] =>
     node.kind === "quantity" ? [{ offset: node.span.start, end: node.span.end, value: Number(node.attrs["value"]), unit: String(node.attrs["unit"]) }] : [],
   );
 
-/** 合計の行が、上の金額の和と合わない。合計の語は言語パッケージの語彙表（total-label）から取る。 */
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+/** 合計の行と内訳の行、文の中の合計と内訳。同じ金額は一度だけ言う。 */
+const totalIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["structure"]>): StructureIssue[] => {
+  const amounts = amountsOf(tree);
+  const lines = totalMismatches(doc.source, amounts, patternsOf(doc, "total-label"));
+  const words = {
+    totals: patternsOf(doc, "total-phrase"),
+    breakdowns: patternsOf(doc, "breakdown-phrase"),
+    discounts: patternsOf(doc, "discount-word"),
+    joiners: patternsOf(doc, "breakdown-gap-joiner"),
+  };
+  const prose = proseTotalMismatches(
+    doc.source,
+    doc.sentences.map((sentence) => sentence.span),
+    amounts,
+    words,
+  );
+  return [...lines, ...prose.filter((issue) => !lines.some((line) => line.offset === issue.offset))];
+};
+
+/**
+ * 合計が内訳の和と合わない。表と箇条書きの合計の行（合計の語は total-label）と、文の中の合計（total-phrase、breakdown-phrase）。
+ * 語は言語パッケージの語彙表から取る。
+ */
 export const totalMismatch: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : totalMismatches(
-        doc.source,
-        amountsOf(doc.structure),
-        (doc.lexicons["total-label"] ?? []).map((entry) => entry.pattern),
-      ).map((issue) => ({
+    : totalIssues(doc, doc.structure).map((issue) => ({
         rule: "total-mismatch",
         severity: "error",
         line: 0,
@@ -127,6 +206,7 @@ const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
   closers: (doc.lexicons["range-closer"] ?? []).map((entry) => entry.pattern),
   frames: (doc.lexicons["range-frame"] ?? []).flatMap((entry) => rangeFrameOf(entry.pattern) ?? []),
   changes: (doc.lexicons["date-change-word"] ?? []).map((entry) => entry.pattern),
+  weekdays: (doc.lexicons["weekday"] ?? []).map((entry) => entry.pattern),
 });
 
 /** 期間の終わりが始まりより前。範囲の記号と語は言語パッケージの語彙表（range-connector、range-opener、range-closer）から取る。 */
@@ -156,10 +236,24 @@ const shareWordsOf = (doc: ProseDocument): ShareWords => ({
 });
 
 /** 構成比や内訳の百分率の和が 100% にならない。割合の語と百分率の単位は言語パッケージの語彙表から取る。 */
+/**
+ * 表や箇条書きの内訳と、一つの文に並べた内訳（「構成比は、Aが50%、Bが30%、Cが20%」）。箇条書きの項目の文は両方に読まれうるので、
+ * 表や箇条書きが指した行の文は重ねて言わない。
+ */
+const percentSumIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["structure"]>): StructureIssue[] => {
+  const amounts = amountsOf(tree);
+  const words = shareWordsOf(doc);
+  const runs = percentSumMismatches(doc.source, amounts, words);
+  const reported = new Set(runs.map((issue) => lineStartAt(doc.source, issue.offset)));
+  const sentences = doc.sentences.map((sentence) => sentence.span);
+  const prose = proseShareMismatches(doc.source, sentences, amounts, words).filter((issue) => !reported.has(lineStartAt(doc.source, issue.offset)));
+  return [...runs, ...prose].toSorted((left, right) => left.offset - right.offset);
+};
+
 export const percentSumMismatch: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : percentSumMismatches(doc.source, amountsOf(doc.structure), shareWordsOf(doc)).map((issue) => ({
+    : percentSumIssues(doc, doc.structure).map((issue) => ({
         rule: "percent-sum-mismatch",
         severity: "warning",
         line: 0,

package/src/detectors/unbalanced-bracket.ts

@@ -108,25 +108,40 @@ export const bracketProblems = (text: string): BracketProblem[] => {
   return [...scan.problems, ...scan.open.map(unclosedOf)].toSorted((left, right) => left.offset - right.offset);
 };
 
-/** sorted（昇順・重ならない）のどれかが offset を含むか。何万もの字の節があっても、URL ごとに全部をなめない。 */
-const coversOffset = (sorted: readonly Span[], offset: number): boolean => {
-  const span = sorted[firstEndingAfter(sorted, offset)];
-  return span !== undefined && span.start <= offset;
+/** sorted（昇順・接しもしない）で、offset の後ろの最初の境目: offset を含む範囲の終わりか、次の範囲の始まり。 */
+const borderAfter = (sorted: readonly Span[], offset: number): number => {
+  const next = sorted[firstEndingAfter(sorted, offset)];
+  if (next === undefined) return Number.POSITIVE_INFINITY;
+  return next.start <= offset ? next.end : next.start;
 };
 
+/** 覆いの中で URL そのものが終わる位置。ASCII でない字か、コードと字のまま見える範囲の境目（「`https://…`）」の「`」）で終わる。 */
+const urlProperEnd = (written: string, start: number, readable: readonly Span[]): number => {
+  const nonAscii = written.search(/[^\p{ASCII}]/u);
+  return Math.min(nonAscii === -1 ? written.length : nonAscii, borderAfter(readable, start) - start, written.length);
+};
+
+/** sorted（昇順・重ならない）のうち range に重なるものを、range の中に切り詰めたもの。何万もの字の節があっても、URL ごとに全部をなめない。 */
+const clippedTo = (sorted: readonly Span[], range: Span): Span[] =>
+  sorted
+    .slice(firstEndingAfter(sorted, range.start), firstEndingAfter(sorted, range.end) + 1)
+    .filter((span) => span.start < range.end)
+    .map((span) => ({ start: Math.max(span.start, range.start), end: Math.min(span.end, range.end) }));
+
 /**
  * 本文（prose）では URL を覆うが、覆いは空白まで取るので、URL の直後に続けて書いた字（「（https://example.jp/）」の「）」）まで消える。
- * 読み手には見えている字なので、ASCII でない字から先を元に戻す。コードの中の URL（texts の外）は戻さない。
+ * 読み手には見えている字なので、URL が終わった後ろの、字のまま見える範囲（texts）を元に戻す。コードの中の URL の後ろも同じ。
  */
 export const withRunOnRestored = (prose: string, source: string, texts: readonly Span[]): string => {
-  const readable = mergeSpans(texts, false);
+  const readable = mergeSpans(texts, true);
   const parts: string[] = [];
   const cursor = { at: 0 };
   [...source.matchAll(BARE_URL)].forEach((match) => {
-    const tail = match[0].search(/[^\p{ASCII}]/u);
-    if (tail === -1 || !coversOffset(readable, match.index)) return;
-    parts.push(prose.slice(cursor.at, match.index + tail), source.slice(match.index + tail, match.index + match[0].length));
-    cursor.at = match.index + match[0].length;
+    const tail = { start: match.index + urlProperEnd(match[0], match.index, readable), end: match.index + match[0].length };
+    clippedTo(readable, tail).forEach((span) => {
+      parts.push(prose.slice(cursor.at, span.start), source.slice(span.start, span.end));
+      cursor.at = span.end;
+    });
   });
   parts.push(prose.slice(cursor.at));
   return parts.join("");

package/src/detectors/vague-deadline.ts

@@ -0,0 +1,132 @@
+// A time limit a contract leaves to the reader (速やかに, 遅滞なく, promptly, within a reasonable time) where the same
+// contract writes most of its limits as numbers (7日以内, within thirty days): who decides whether 速やかに was met?
+// Which way to write limits is the drafter's choice; only the minority in one document is pointed at. A sentence that
+// also gives a number of days (速やかに、遅くとも7日以内に) has a deadline, and a sentence that grants a right (may
+// promptly suspend, 速やかに解除することができる) sets no deadline. The words come from the language package's word
+// lists: vague-deadline, concrete-deadline (a stated limit: 日以内, "within … days") and deadline-permission. Pure.
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument } from "../plugin.ts";
+
+export type VagueDeadline = { readonly offset: number; readonly word: string };
+
+type Text = { readonly start: number; readonly text: string };
+
+type Hit = { readonly at: number; readonly word: string };
+
+/** What the three word lists give the decision. */
+export type DeadlineWords = {
+  readonly vague: readonly string[];
+  /** A phrase, or a frame "within … days": the second part within FRAME_REACH characters after the first. */
+  readonly concrete: readonly string[];
+  /** A right, not a duty: a word anywhere in the sentence, or (position: after) the sentence's ending. */
+  readonly permissions: readonly LexiconEntry[];
+};
+
+const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+const FRAME = "…";
+/** How far after "within" the unit of a frame may come: "within fourteen (14) business days". */
+const FRAME_REACH = 30;
+const SENTENCE_MARKS = new Set(["。", "．", ".", "!", "?", "！", "？"]);
+
+/** The sentence without its closing marks and spaces. */
+const withoutEnding = (text: string): string => {
+  const chars = [...text.trimEnd()];
+  const last = chars.findLastIndex((char) => !SENTENCE_MARKS.has(char) && char.trim() !== "");
+  return chars.slice(0, last + 1).join("");
+};
+
+/** An English word is not read inside a longer one (promptly in unpromptly, may in mayor). */
+const isWordAt = (text: string, word: string, at: number): boolean =>
+  !LATIN.test(word) || (!LETTER.test(text.charAt(at - 1)) && !LETTER.test(text.charAt(at + word.length)));
+
+const indexesOf = (text: string, word: string): number[] => {
+  const found: number[] = [];
+  if (word === "") return found;
+  let at = text.indexOf(word);
+  while (at !== -1) {
+    found.push(at);
+    at = text.indexOf(word, at + word.length);
+  }
+  return found;
+};
+
+const wordIn = (lower: string, word: string): boolean => indexesOf(lower, word.toLowerCase()).some((at) => isWordAt(lower, word, at));
+
+/** A phrase, or a frame whose second part follows its first within reach. */
+const concreteIn = (lower: string, entry: string): boolean => {
+  const [lead = "", tail, ...rest] = entry
+    .toLowerCase()
+    .split(FRAME)
+    .map((part) => part.trim());
+  if (rest.length > 0) return false;
+  if (tail === undefined) return lead !== "" && lower.includes(lead);
+  return (
+    lead !== "" &&
+    tail !== "" &&
+    indexesOf(lower, lead).some((at) => isWordAt(lower, lead, at) && lower.slice(at + lead.length, at + lead.length + FRAME_REACH).includes(tail))
+  );
+};
+
+const statesConcrete = (text: Text, concrete: readonly string[]): boolean => {
+  const lower = text.text.toLowerCase();
+  return concrete.some((entry) => concreteIn(lower, entry));
+};
+
+const grantsRight = (text: Text, permissions: readonly LexiconEntry[]): boolean => {
+  const lower = text.text.toLowerCase();
+  const ending = withoutEnding(lower);
+  return permissions
+    .filter((entry) => entry.pattern !== "")
+    .some((entry) => (entry.position === "after" ? ending.endsWith(entry.pattern.toLowerCase()) : wordIn(lower, entry.pattern)));
+};
+
+/** A hit inside a longer hit at the same place (速やかに in 可及的速やかに) is that longer word. */
+const isInsideLonger = (hit: Hit, hits: readonly Hit[]): boolean =>
+  hits.some((other) => other.word.length > hit.word.length && other.at <= hit.at && hit.at + hit.word.length <= other.at + other.word.length);
+
+/** The vague limits in one sentence, in order. Matching ignores case. */
+const vagueIn = (text: Text, vague: readonly string[]): VagueDeadline[] => {
+  const lower = text.text.toLowerCase();
+  const hits = vague
+    .filter((word) => word !== "")
+    .flatMap((word) =>
+      indexesOf(lower, word.toLowerCase())
+        .filter((at) => isWordAt(lower, word, at))
+        .map((at) => ({ at, word })),
+    );
+  return hits
+    .filter((hit) => !isInsideLonger(hit, hits))
+    .toSorted((left, right) => left.at - right.at)
+    .map((hit) => ({ offset: text.start + hit.at, word: text.text.slice(hit.at, hit.at + hit.word.length) }));
+};
+
+/**
+ * Each vague limit in a sentence that states no concrete one and grants no right, when more sentences of the document
+ * state a concrete one than hold such a vague one: the vague limits are then the document's minority.
+ */
+export const vagueDeadlines = (texts: readonly Text[], words: DeadlineWords): VagueDeadline[] => {
+  const perSentence = texts.map((text) => (statesConcrete(text, words.concrete) || grantsRight(text, words.permissions) ? [] : vagueIn(text, words.vague)));
+  const vagueSentences = perSentence.filter((hits) => hits.length > 0).length;
+  const concreteSentences = texts.filter((text) => statesConcrete(text, words.concrete)).length;
+  return concreteSentences > vagueSentences ? perSentence.flat() : [];
+};
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+export const vagueDeadline: Detector = (doc): Finding[] =>
+  vagueDeadlines(
+    doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text })),
+    {
+      vague: patternsOf(doc, "vague-deadline"),
+      concrete: patternsOf(doc, "concrete-deadline"),
+      permissions: doc.lexicons["deadline-permission"] ?? [],
+    },
+  ).map((hit) => ({
+    rule: "vague-deadline",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, hit.offset),
+    values: { word: hit.word, offset: hit.offset },
+  }));

package/src/detectors/version-mismatch.ts

@@ -0,0 +1,23 @@
+// version-mismatch: the version a code block's lead-in names against the one the block shows (structure/version-mismatch.ts).
+// The words that make a version a bound (「から」「以上」, "from", "or later") are the lexicon version-range; the words that
+// lead to the version installed (version, install) are version-lead.
+import type { Detector, Finding } from "../plugin.ts";
+import { versionMismatches, type RangeWord, type VersionWords } from "../structure/version-mismatch.ts";
+import { codeFences } from "./code-fences.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+export const versionMismatch: Detector = (doc): Finding[] => {
+  const words: VersionWords = {
+    ranges: (doc.lexicons["version-range"] ?? []).map((entry): RangeWord => ({ word: entry.pattern, position: entry.position ?? "before" })),
+    versionWords: (doc.lexicons["version-lead"] ?? []).map((entry) => entry.pattern),
+  };
+  const blocks = codeFences(doc.source).map((fence) => ({ start: fence.start, code: fence.lines.join("\n") }));
+  return versionMismatches(doc.source, doc.prose ?? doc.source, blocks, words).map((issue) => ({
+    rule: "version-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/furigana.ts

@@ -0,0 +1,20 @@
+import type { Span } from "./plugin.ts";
+
+/** ひらがなと、読みの中に書く長音・中黒・空白だけの括弧書き。 */
+const KANA_ASIDE = /[（(][\p{Script=Hiragana}ー・ \u3000]+[）)]/gu;
+
+const HIRAGANA = /\p{Script=Hiragana}/u;
+/** 読みを付ける語の終わりの字。ひらがなの後ろの括弧書きは読みではなく挟んだ言葉（「これは（たぶん）」）。 */
+const WORD_END = /[\p{L}\p{N}]/u;
+
+/**
+ * text の中の、語の直後のふりがなの括弧（「HTTP（えいちてぃーてぃーぴー）」「脆弱性（ぜいじゃくせい）」）の範囲。括弧を含む。
+ * 語の読みであって、語の書き方ではない。位置は text の先頭を 0 とする。
+ */
+export const furiganaSpans = (text: string): Span[] =>
+  [...text.matchAll(KANA_ASIDE)]
+    .filter((match) => {
+      const before = text.charAt(match.index - 1);
+      return HIRAGANA.test(match[0]) && WORD_END.test(before) && !HIRAGANA.test(before);
+    })
+    .map((match) => ({ start: match.index, end: match.index + match[0].length }));

package/src/genre-load.ts

@@ -1,13 +1,11 @@
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import { parse } from "yaml";
 import { parseGenres, presetLevelsOf, presetProfileOf, withRuleOffs, type GenreData, type PresetLevels } from "./genre-parse.ts";
 import { loadRuleOffs } from "./rule-offs.ts";
+import { PACKAGE_DIR, readText } from "./package-files.ts";
 
-const PACKAGE = join(dirname(fileURLToPath(import.meta.url)), "..");
-const GENRES_FILE = join(PACKAGE, "genres.yaml");
-const RULES_DIR = join(PACKAGE, "rules");
+const GENRES_FILE = join(PACKAGE_DIR, "genres.yaml");
+const RULES_DIR = join(PACKAGE_DIR, "rules");
 
 const loaded: { value: GenreData | undefined } = { value: undefined };
 
@@ -15,7 +13,7 @@ const loaded: { value: GenreData | undefined } = { value: undefined };
 export const loadGenres = (): GenreData => {
   if (loaded.value !== undefined) return loaded.value;
   try {
-    loaded.value = withRuleOffs(parseGenres(parse(readFileSync(GENRES_FILE, "utf8"))), loadRuleOffs(RULES_DIR));
+    loaded.value = withRuleOffs(parseGenres(parse(readText(GENRES_FILE))), loadRuleOffs(RULES_DIR));
   } catch (error) {
     throw new Error(`cannot read ${GENRES_FILE}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
   }

package/src/grade/ai-score.ts

@@ -0,0 +1,32 @@
+import { shownSignsOf, type AiLevel, type AiScore, type NotScored } from "../ai-score/score.ts";
+
+// The AI-likeness quick score as one output's result carries it, and its levels counted over many outputs. Pure.
+
+/** One output's quick score: its level (null when not scored, and why), the signs, and which showed. */
+export type GradeAiScore = {
+  readonly level: AiLevel | null;
+  readonly notScored: NotScored["reason"] | null;
+  readonly signs: number;
+  readonly compared: number;
+  /** The signs that counted: rule ids, and structure measures as structure:<id>. */
+  readonly shown: readonly string[];
+};
+
+/** How many outputs reached each level, and how many were not scored. */
+export type AiLevelCounts = Readonly<Record<AiLevel | "notScored", number>>;
+
+export const gradeAiScoreOf = (score: AiScore): GradeAiScore => ({
+  level: score.level ?? null,
+  notScored: score.notScored?.reason ?? null,
+  signs: score.signs,
+  compared: score.compared,
+  shown: shownSignsOf(score),
+});
+
+/** The levels of the outputs that carry a score, or undefined when none does (results written before the score existed). */
+export const aiLevelCountsOf = (scores: readonly (GradeAiScore | undefined)[]): AiLevelCounts | undefined => {
+  const scored = scores.filter((score) => score !== undefined);
+  if (scored.length === 0) return undefined;
+  const count = (level: AiLevel): number => scored.filter((score) => score.level === level).length;
+  return { low: count("low"), medium: count("medium"), high: count("high"), notScored: scored.filter((score) => score.level === null).length };
+};

package/src/grade/finding.ts

@@ -0,0 +1,16 @@
+import type { SourceCheck } from "../check-source.ts";
+import type { Finding } from "../plugin.ts";
+import { messageOf } from "../render/text.ts";
+import type { GradeFinding } from "./result.ts";
+
+/** One finding as `chaff grade` writes it: the rule, the level, where, and the message the command line prints. */
+export const findingOf = (finding: Finding, check: SourceCheck): GradeFinding => {
+  const rule = check.rules.find((entry) => entry.id === finding.rule);
+  return {
+    rule: finding.rule,
+    level: finding.severity,
+    line: finding.line,
+    column: finding.column,
+    message: rule === undefined ? finding.rule : messageOf(rule, finding, check.language),
+  };
+};

package/src/grade/grade-item.ts

@@ -1,9 +1,8 @@
 import { checkSource, type SourceCheck } from "../check-source.ts";
 import type { Allowed } from "../compare/outcome.ts";
 import { missingSections } from "../detectors/team.ts";
-import { messageOf } from "../render/text.ts";
 import { uiLanguageOf, type UiLanguage } from "../ui.ts";
-import type { Finding } from "../plugin.ts";
+import { findingOf } from "./finding.ts";
 import { citationsAgainst, factsAgainst, OUTPUT_PATH, type CitationsRead, type ItemReading } from "./checks.ts";
 import { contextsAgainst, type ContextsRead } from "./contexts.ts";
 import type { GradeItem } from "./item.ts";
@@ -13,22 +12,13 @@ import type { Rubric } from "./rubric.ts";
 import { rubricVerdict } from "./rubric-verdict.ts";
 import type { GradeSettings } from "./stamp.ts";
 import { GRADE_TEXT } from "./text.ts";
+import { aiScoreOfDocument } from "../ai-score/of-document.ts";
+import { gradeAiScoreOf } from "./ai-score.ts";
 import { defaultVerdict, type Verdict } from "./verdict.ts";
 
 /** One run's settings, its `grade:` rubric when chaff.yaml has one, and its stamp, which every result carries. */
 export type GradeSetup = GradeSettings & { readonly stamp: Stamp; readonly rubric?: Rubric | undefined };
 
-const findingOf = (finding: Finding, check: SourceCheck): GradeFinding => {
-  const rule = check.rules.find((entry) => entry.id === finding.rule);
-  return {
-    rule: finding.rule,
-    level: finding.severity,
-    line: finding.line,
-    column: finding.column,
-    message: rule === undefined ? finding.rule : messageOf(rule, finding, check.language),
-  };
-};
-
 /** The fact kinds the rubric lets change (`allow_dropped`, `allow_added`), as compare's --allow-dropped and --allow-added. */
 const allowedBy = (rubric: Rubric | undefined): Allowed => ({
   dropped: new Set(rubric?.facts?.allowDropped ?? []),
@@ -126,6 +116,7 @@ export const gradeItem = async (item: GradeItem, setup: GradeSetup): Promise<Gra
     citations: citationsOf(checked),
     ...(checked.contexts === undefined ? {} : { contexts: checked.contexts.contexts }),
     ...(score === undefined ? {} : { score }),
+    aiScore: gradeAiScoreOf(aiScoreOfDocument(checked.check.doc, checked.check.rules, checked.check.genre.genre)),
     pass: verdict.pass,
     failedBecause: verdict.failedBecause,
     stamp: setup.stamp,

package/src/grade/render-variants.ts

@@ -14,11 +14,15 @@ type Rows = readonly (readonly string[])[];
 const passedCell = (column: VariantColumn, text: VariantText): string =>
   text.passedCell(column.passed, column.outputs, column.passRate === undefined ? "–" : `${String(column.passRate)}%`);
 
+const aiScoreCellOf = (column: VariantColumn, text: VariantText): string =>
+  column.aiScore === undefined ? "–" : text.aiScoreCell(column.aiScore.low, column.aiScore.medium, column.aiScore.high, column.aiScore.notScored);
+
 /** The header and one row per measure, a column per variant. */
 const measureRows = (comparison: VariantComparison, text: VariantText): Rows => {
   const { columns } = comparison;
   const scored = columns.some((column) => column.penalty !== undefined);
   const grounded = columns.some((column) => column.contexts !== undefined);
+  const aiScored = columns.some((column) => column.aiScore !== undefined);
   return [
     ["", ...comparison.variants],
     [text.passed, ...columns.map((column) => passedCell(column, text))],
@@ -29,6 +33,7 @@ const measureRows = (comparison: VariantComparison, text: VariantText): Rows =>
       ? [[text.unsupportedFacts, ...columns.map((column) => text.citationsCell(column.contexts?.unsupported ?? 0, column.contexts?.checked ?? 0))]]
       : []),
     ...(scored ? [[text.penalty, ...columns.map((column) => String(column.penalty ?? 0))]] : []),
+    ...(aiScored ? [[text.aiScore, ...columns.map((column) => aiScoreCellOf(column, text))]] : []),
   ];
 };
 

package/src/grade/render.ts

@@ -65,6 +65,7 @@ export const renderSummary = (path: string, summary: GradeSummary, text: GradeTe
     text.citations(summary.citations.checked, summary.citations.failed),
     ...contextsLine(summary, text),
     ...(summary.penalty === undefined ? [] : [text.penalty(summary.penalty)]),
+    ...(summary.aiScore === undefined ? [] : [text.aiScore(summary.aiScore.low, summary.aiScore.medium, summary.aiScore.high, summary.aiScore.notScored)]),
     ...block(text.notRunHeading(summary.notRun.length), table(summary.notRun.map((entry) => [entry.rule, text.inOutputs(entry.outputs), entry.reason]))),
     ...stampLines(summary, text),
   ].join("\n");

package/src/grade/result.ts

@@ -2,6 +2,7 @@ import type { AtomKind } from "../compare/atom.ts";
 import type { CitationStatus } from "../structure/cite.ts";
 import type { Severity } from "../plugin.ts";
 import type { OutputSize } from "./rates.ts";
+import type { GradeAiScore } from "./ai-score.ts";
 
 // The shape of one line of `chaff grade --out`, and of what `grade()` returns. Spec §29.3.
 
@@ -75,6 +76,8 @@ export type GradeResult = {
   readonly contexts?: GradeContexts | undefined;
   /** Only with a `grade:` rubric. */
   readonly score?: GradeScore | undefined;
+  /** The AI-likeness quick score. Absent only in results written before it existed. Never part of pass or fail. */
+  readonly aiScore?: GradeAiScore | undefined;
   readonly pass: boolean;
   /** Each condition the output failed, with how far: `facts.dropped 3 > 0`. */
   readonly failedBecause: readonly string[];

package/src/grade/results-read.ts

@@ -52,6 +52,19 @@ const isScoreItem = (value: unknown): boolean => isRecord(value) && isNumber(val
 
 const isScore = (value: unknown): boolean => value === undefined || (isRecord(value) && isNumber(value["penalty"]) && isArrayOf(value["items"], isScoreItem));
 
+const AI_LEVELS: ReadonlySet<unknown> = new Set(["low", "medium", "high", null]);
+const NOT_SCORED: ReadonlySet<unknown> = new Set(["too-short", "no-baseline", null]);
+
+/** Absent in results written before the quick score existed. */
+const isAiScore = (value: unknown): boolean =>
+  value === undefined ||
+  (isRecord(value) &&
+    AI_LEVELS.has(value["level"]) &&
+    NOT_SCORED.has(value["notScored"]) &&
+    isNumber(value["signs"]) &&
+    isNumber(value["compared"]) &&
+    isArrayOf(value["shown"], isString));
+
 const isNotRun = (value: unknown): boolean => isRecord(value) && isString(value["rule"]) && isString(value["reason"]);
 
 const isRates = (value: unknown): boolean => isRecord(value) && Object.values(value).every(isNumber);
@@ -59,6 +72,9 @@ const isRates = (value: unknown): boolean => isRecord(value) && Object.values(va
 /** The id, and the variant when the output had one. */
 const isLabel = (value: Record<string, unknown>): boolean => isString(value["id"]) && (value["variant"] === undefined || isString(value["variant"]));
 
+/** The parts a result carries only sometimes: contexts, a rubric's score, the quick score. Each is checked when present. */
+const hasOptionalParts = (value: Record<string, unknown>): boolean => isContexts(value["contexts"]) && isScore(value["score"]) && isAiScore(value["aiScore"]);
+
 /** A line `--out` writes, every field checked: a line that only looks like one would be compared as if it had been graded. */
 export const isGradeResult = (value: unknown): value is GradeResult =>
   isRecord(value) &&
@@ -71,8 +87,7 @@ export const isGradeResult = (value: unknown): value is GradeResult =>
   isArrayOf(value["notRun"], isNotRun) &&
   isFacts(value["facts"]) &&
   isCitations(value["citations"]) &&
-  isContexts(value["contexts"]) &&
-  isScore(value["score"]) &&
+  hasOptionalParts(value) &&
   typeof value["pass"] === "boolean" &&
   isArrayOf(value["failedBecause"], isString) &&
   isStamp(value["stamp"]);

package/src/grade/summary.ts

@@ -2,6 +2,7 @@ import type { LengthUnit } from "../plugin.ts";
 import { compareText, sortedByKey, tally } from "./order.ts";
 import { rateOf } from "./rates.ts";
 import type { GradeFact, GradeResult, NotRunEntry, Stamp } from "./result.ts";
+import { aiLevelCountsOf, type AiLevelCounts } from "./ai-score.ts";
 
 // The summary of a run (spec §29.3), from the per-output results alone, so the same results always sum the same way.
 
@@ -23,6 +24,8 @@ export type GradeSummary = {
   readonly notRun: readonly (NotRunEntry & { readonly outputs: number })[];
   /** The penalty points of every output, added up. Only with a `grade:` rubric. */
   readonly penalty?: number | undefined;
+  /** How many outputs reached each level of the AI-likeness quick score. Absent when no result carries one. */
+  readonly aiScore?: AiLevelCounts | undefined;
   readonly stamp: Stamp | undefined;
 };
 
@@ -86,6 +89,11 @@ const contextsOf = (results: readonly GradeResult[]): Pick<GradeSummary, "contex
   };
 };
 
+const aiScoreOf = (results: readonly GradeResult[]): Pick<GradeSummary, "aiScore"> => {
+  const counts = aiLevelCountsOf(results.map((result) => result.aiScore));
+  return counts === undefined ? {} : { aiScore: counts };
+};
+
 export const summaryOf = (results: readonly GradeResult[]): GradeSummary => {
   const sizes = sizesOf(results);
   return {
@@ -107,6 +115,7 @@ export const summaryOf = (results: readonly GradeResult[]): GradeSummary => {
     ...contextsOf(results),
     notRun: notRunOf(results),
     ...penaltyOf(results),
+    ...aiScoreOf(results),
     stamp: results[0]?.stamp,
   };
 };