chaffjs 0.30.0 → 0.32.0

package/src/detectors/email-letter.ts

@@ -1,6 +1,6 @@
 // A work email or letter's own parts: a greeting and a closing, a subject line, and an attachment the text mentions.
 // Pure. The words (お世話になっております, Dear, Best regards, 件名, attached) come from the language's email-greeting,
-// email-closing, email-subject-field, attachment-mention, attachment-not-mention and attachment-line lexicons. The
+// email-closing, email-sentence-end, email-subject-field, attachment-mention, attachment-not-mention and attachment-line lexicons. The
 // header and the signature are masked in doc.prose; a quoted reply is someone else's words and is left out.
 import { escapeRegExp } from "../orthography.ts";
 import { quoteAt } from "./structure-tree.ts";
@@ -8,6 +8,8 @@ import type { Detector, Finding, ProseDocument, Span } from "../plugin.ts";
 
 /** A greeting comes before the body: past the subject, the addressee (株式会社… / 総務部 山田様) and the writer's name. */
 const GREETING_LINES = 5;
+/** A letter's header before the greeting: the date, the sender's and the addressee's names and addresses, a title. */
+const HEADER_LINES = 12;
 /** A closing comes at the end, before the writer's name, title, company, address and contact lines, or an acceptance block. */
 const CLOSING_LINES = 10;
 
@@ -101,12 +103,37 @@ const partsOf = (lines: readonly BodyLine[]): BodyLine[][] => {
 
 export type FrameSlip = { readonly variant: "greeting" | "closing"; readonly offset: number };
 
-/** A missing greeting (none in the first lines) and a missing closing (none in the last lines of any part). */
-export const frameSlips = (lines: readonly BodyLine[], greetings: readonly string[], closings: readonly string[]): FrameSlip[] => {
+/** The brackets and quotes that may close a line after its sentence's end mark (…ます。」, …trip.”). */
+const CLOSERS = new Set(")）」』］]\"'”’");
+
+/** Whether a line ends a sentence: one of the marks at its end, past any closing bracket or quote. */
+export const endsSentence = (line: string, marks: readonly string[]): boolean => {
+  const chars = [...line.trimEnd()];
+  const body = chars.slice(0, chars.findLastIndex((char) => !CLOSERS.has(char)) + 1).join("");
+  return body !== "" && marks.some((mark) => body.endsWith(mark));
+};
+
+/**
+ * How many of the first lines the greeting may be in. A letter's header (the date, the addressee 保護者各位 or the
+ * address block, the sender, a title) is lines that end no sentence, and the greeting is the line after it at the latest.
+ * Without a sentence in the first lines there is no header to tell apart, and the first lines are read.
+ */
+export const greetingLineCount = (lines: readonly BodyLine[], sentenceEnds: readonly string[]): number => {
+  const firstSentence = lines.slice(0, HEADER_LINES).findIndex((line) => endsSentence(line.text, sentenceEnds));
+  return Math.max(GREETING_LINES, firstSentence + 1);
+};
+
+/** A missing greeting (none in the first lines, or past the letter's header) and a missing closing (none in the last lines of any part). */
+export const frameSlips = (
+  lines: readonly BodyLine[],
+  greetings: readonly string[],
+  closings: readonly string[],
+  sentenceEnds: readonly string[],
+): FrameSlip[] => {
   const first = lines[0];
   const last = lines.at(-1);
   if (first === undefined || last === undefined) return [];
-  const greeted = lines.slice(0, GREETING_LINES).some((line) => lineHas(line.text, greetings));
+  const greeted = lines.slice(0, greetingLineCount(lines, sentenceEnds)).some((line) => lineHas(line.text, greetings));
   const closed = partsOf(lines).some((part) => part.slice(-CLOSING_LINES).some((line) => lineHas(line.text, closings)));
   return [
     ...(greeted ? [] : [{ variant: "greeting" as const, offset: first.start }]),
@@ -115,17 +142,20 @@ export const frameSlips = (lines: readonly BodyLine[], greetings: readonly strin
 };
 
 export const emailFrame: Detector = (doc): Finding[] =>
-  frameSlips(bodyLines(doc.source, doc.prose ?? doc.source, doc.replyQuotes ?? []), patternsOf(doc, "email-greeting"), patternsOf(doc, "email-closing")).map(
-    (slip) => ({
-      rule: "email-greeting-closing",
-      severity: "info",
-      line: 0,
-      column: 0,
-      quote: quoteAt(doc.source, slip.offset),
-      values: { offset: slip.offset },
-      variant: slip.variant,
-    }),
-  );
+  frameSlips(
+    bodyLines(doc.source, doc.prose ?? doc.source, doc.replyQuotes ?? []),
+    patternsOf(doc, "email-greeting"),
+    patternsOf(doc, "email-closing"),
+    patternsOf(doc, "email-sentence-end"),
+  ).map((slip) => ({
+    rule: "email-greeting-closing",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.offset),
+    values: { offset: slip.offset },
+    variant: slip.variant,
+  }));
 
 export type SubjectLine = { readonly start: number; readonly subject: string };
 

package/src/detectors/en-shape.ts

@@ -123,9 +123,12 @@ export const conjunctionRun: Detector = (doc, options): Finding[] => {
     });
 };
 
-const headingsOf = (sections: readonly Section[]): { readonly section: Section; readonly title: boolean }[] =>
+/** Weekday and month names, capitalised in either style (the list leaves out May, March and August, also ordinary words). */
+const FIXED_CASE_LISTS = ["calendar-name"] as const;
+
+const headingsOf = (sections: readonly Section[], fixedCase: ReadonlySet<string>): { readonly section: Section; readonly title: boolean }[] =>
   sections.flatMap((section) => {
-    const title = isTitleCase(section.heading);
+    const title = isTitleCase(section.heading, fixedCase);
     return title === undefined ? [] : [{ section, title }];
   });
 
@@ -134,10 +137,14 @@ const headingsOf = (sections: readonly Section[]): { readonly section: Section;
  * 見るのは文書の中で揃っているかだけで、少数派のほうを指摘する。題名は指摘しない（minorityCase）。
  */
 export const titleCaseMix: Detector = (doc, options): Finding[] => {
+  const fixedCase = new Set(FIXED_CASE_LISTS.flatMap((id) => (doc.lexicons[id] ?? []).map((entry) => entry.pattern)));
   const pageTitle = pageTitleOf(doc.sections);
-  const judged = headingsOf(doc.sections.filter((section) => section !== pageTitle));
+  const judged = headingsOf(
+    doc.sections.filter((section) => section !== pageTitle),
+    fixedCase,
+  );
   const titleCase = judged.filter((entry) => entry.title).length;
-  const pageTitleCase = pageTitle === undefined ? undefined : isTitleCase(pageTitle.heading);
+  const pageTitleCase = pageTitle === undefined ? undefined : isTitleCase(pageTitle.heading, fixedCase);
   const minorityIsTitle = minorityCase({ titleCase, sentenceCase: judged.length - titleCase }, pageTitleCase);
   const few = minorityIsTitle === undefined ? [] : judged.filter((entry) => entry.title === minorityIsTitle);
   if (few.length > options.limit) return [];

package/src/detectors/event-deadline.ts

@@ -0,0 +1,39 @@
+// deadline-after-event: the reading half. The event-date, registration, deadline and follow-up words come from the language's
+// lexicons (event-date-label, event-registration-word, event-deadline-word, event-aside,
+// event-ticket-word, event-payment-word, event-bill-word, event-trip-word, event-start-label, event-payment-deadline-word, event-due-word); the dates are the structure tree's,
+// and the lines are read with code masked.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { deadlinesAfterEvent, type EventDeadlineWords } from "../structure/deadline-after-event.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { datedPoints, quoteAt } from "./structure-tree.ts";
+import { readableDates, withReadableDates } from "./readable-dates.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+const wordsOf = (doc: ProseDocument): EventDeadlineWords => ({
+  events: patternsOf(doc, "event-date-label"),
+  registrations: patternsOf(doc, "event-registration-word"),
+  deadlines: patternsOf(doc, "event-deadline-word"),
+  asides: patternsOf(doc, "event-aside"),
+  tickets: patternsOf(doc, "event-ticket-word"),
+  payments: patternsOf(doc, "event-payment-word"),
+  bills: patternsOf(doc, "event-bill-word"),
+  trips: patternsOf(doc, "event-trip-word"),
+  starts: patternsOf(doc, "event-start-label"),
+  paymentDeadlines: patternsOf(doc, "event-payment-deadline-word"),
+  dues: patternsOf(doc, "event-due-word"),
+});
+
+export const eventDeadline: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const sentences = doc.sentences.map((sentence) => sentence.span);
+  return deadlinesAfterEvent(proseAndTablesOf(doc), datedPoints(doc.structure), sentences, wordsOf(doc), doc.markup?.headings[0]?.text).map((issue) => ({
+    rule: "deadline-after-event",
+    severity: "error",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    ...(issue.kind === "payment" ? { variant: "payment" } : {}),
+    values: { ...withReadableDates(issue.values, ["deadline", "event"], readableDates(doc)), offset: issue.offset },
+  }));
+};

package/src/detectors/fact-consistency.ts

@@ -2,31 +2,149 @@ import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.
 import { countedFacts, countedPhraseAt, type CountedPhrase } from "../facts/counted-facts.ts";
 import { nameSpans } from "../compare/proper-nouns.ts";
 import { factValues, type FactValue } from "../facts/fact-values.ts";
-import { labelledFacts, type AttributePhrase, type FactWords } from "../facts/labelled-facts.ts";
-import { tableFacts } from "../facts/table-facts.ts";
+import { labelledFacts, type AttributePhrase, type Fact, type FactWords } from "../facts/labelled-facts.ts";
+import { tableFacts, type TotalColumns } from "../facts/table-facts.ts";
+import { withCellKeys } from "../facts/cell-keys.ts";
+import { verbQuantityFacts, type VerbQuantityWords } from "../facts/verb-quantity-facts.ts";
+import { countLabelWordsOf } from "../facts/count-labels.ts";
 import { partsAt, scopedFacts, type ScopedFact } from "../facts/fact-scope.ts";
 import { conditionPairConflicts, type ChangeSentence, type ChangeWords, type ConditionWord, type PairConflict, type WordAt } from "../facts/condition-pairs.ts";
 import { scopeConflicts, summaryConflicts, type FactConflict } from "../facts/fact-conflicts.ts";
 import { eventDateConflicts, type EventDateConflict, type EventWord } from "../facts/event-dates.ts";
+import { retentionConflicts, type LengthMark, type RetentionLength, type RetentionVerb, type RetentionWords } from "../facts/retention-periods.ts";
+import type { DurationUnit } from "../derived/date-arithmetic.ts";
+import { DURATION_LEXICONS, quantitiesOf, type Quantity } from "./derived-numbers.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { measuredOf, valuesWith } from "./measured-facts.ts";
+import { durationValues, type DurationWord } from "../facts/duration-values.ts";
+import { overlapsAny, spanIndex } from "../compare/spans.ts";
+import { documentTermConflicts, isTermName, termHomes, type TermWord, type TermWords } from "../facts/document-terms.ts";
+import { termValues, type PlacedWord, type TermValueWords } from "../facts/term-values.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { ageValues, type AgeWord, type AgeWords } from "../facts/age-values.ts";
+import { qualifiedKeyOf, qualifiedKeys, type QualifierWords } from "../facts/qualified-labels.ts";
+import { rowSentenceFindings } from "./row-sentence-amounts.ts";
+import type { RateWord, RateWords } from "../facts/rate-values.ts";
+import { wholeCountFindings } from "./whole-count-findings.ts";
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
+/** 率の基準の語彙表。鍵が基準の種類（期間、固定か変動か、何に対する率か）。 */
+const RATE_NOTES = { period: "fact-rate-period", kind: "fact-rate-kind", base: "fact-rate-base" } as const;
+
+const rateWordsOf = (doc: ProseDocument): RateWords => ({
+  units: patternsOf(doc, "percent-unit"),
+  notes: Object.fromEntries(
+    Object.entries(RATE_NOTES).map(([dimension, id]) => [
+      dimension,
+      (doc.lexicons[id] ?? []).map((entry): RateWord => ({ pattern: entry.pattern, group: entry.group, position: entry.position ?? "after" })),
+    ]),
+  ),
+  joiners: patternsOf(doc, "fact-rate-joiner"),
+});
+
 export const factWordsOf = (doc: ProseDocument): FactWords => ({
   separators: patternsOf(doc, "fact-separator"),
   valueEnds: patternsOf(doc, "fact-value-end"),
   determiners: patternsOf(doc, "fact-label-drop"),
   vague: patternsOf(doc, "fact-label-vague"),
   leads: patternsOf(doc, "fact-label-lead"),
+  rates: rateWordsOf(doc),
+  readings: { verbs: patternsOf(doc, "fact-reading-verb"), gauges: patternsOf(doc, "fact-reading-gauge"), clauses: patternsOf(doc, "fact-reading-clause") },
   attributes: (doc.lexicons["fact-attribute"] ?? []).map((entry): AttributePhrase => ({ pattern: entry.pattern, position: entry.position ?? "before" })),
 });
 
+const placedWordsOf = (doc: ProseDocument, id: string): PlacedWord[] =>
+  (doc.lexicons[id] ?? []).map((entry): PlacedWord => ({ pattern: entry.pattern, position: entry.position ?? "before" }));
+
+const termWordsOf = (doc: ProseDocument): TermWords => ({
+  terms: (doc.lexicons["fact-document-term"] ?? []).map((entry): TermWord => ({
+    pattern: qualifiedKeyOf(entry.pattern.normalize("NFKC").toLowerCase(), qualifierWordsOf(doc)),
+    group: entry.group ?? entry.pattern,
+  })),
+  determiners: patternsOf(doc, "fact-label-drop"),
+});
+
+const termValueWordsOf = (doc: ProseDocument): TermValueWords => ({
+  ...termWordsOf(doc),
+  separators: [...patternsOf(doc, "fact-separator"), ...patternsOf(doc, "fact-term-verb")],
+  selves: placedWordsOf(doc, "fact-term-self"),
+  starts: placedWordsOf(doc, "fact-term-start"),
+  valueEnds: patternsOf(doc, "fact-value-end"),
+});
+
+const totalColumnsOf = (doc: ProseDocument): TotalColumns => {
+  const words = termWordsOf(doc);
+  const labels = (doc.lexicons["total-label"] ?? []).filter((entry) => entry.group !== "subtotal").map((entry) => entry.pattern);
+  return { labels, isTerm: (heading) => isTermName(heading, words) };
+};
+
 const factsByDocument = new WeakMap<ProseDocument, readonly ScopedFact[]>();
 
+/** 期間の単位と、年数にもなる単位（「保証期間は1年」の 年。retention-unit の group が大きさ）。 */
+const durationWordsOf = (doc: ProseDocument): DurationWord[] => [
+  ...DURATION_LEXICONS.flatMap(([id, unit]) => patternsOf(doc, id).map((pattern): DurationWord => ({ pattern, unit }))),
+  ...(doc.lexicons["retention-unit"] ?? []).flatMap((entry): DurationWord[] =>
+    isDurationUnit(entry.group) ? [{ pattern: entry.pattern, unit: entry.group }] : [],
+  ),
+];
+
+const ageWordsAt = (doc: ProseDocument, id: string): AgeWord[] =>
+  (doc.lexicons[id] ?? []).map((entry): AgeWord => ({ pattern: entry.pattern, position: entry.position ?? "before" }));
+
+const ageWordsOf = (doc: ProseDocument): AgeWords => ({
+  marks: ageWordsAt(doc, "fact-age-mark"),
+  limits: ageWordsAt(doc, "fact-age-limit"),
+  joiners: patternsOf(doc, "fact-age-joiner"),
+});
+
+const qualifierWordsOf = (doc: ProseDocument): QualifierWords => ({
+  templates: patternsOf(doc, "fact-label-qualifier"),
+  determiners: patternsOf(doc, "fact-label-drop"),
+});
+
+const verbQuantityWordsOf = (doc: ProseDocument): VerbQuantityWords => ({
+  verbs: patternsOf(doc, "fact-quantity-verb"),
+  selves: patternsOf(doc, "fact-quantity-self"),
+  periods: patternsOf(doc, "fact-quantity-period"),
+  valueEnds: patternsOf(doc, "fact-value-end"),
+  qualifiers: qualifierWordsOf(doc),
+});
+
+/** 条件の付いた名前（待機期間（旅行キャンセル費用）、旅行キャンセル費用の待機期間）を一つの key に。 */
+const withQualifiedKeys = <T extends Fact>(doc: ProseDocument, facts: readonly T[]): T[] => {
+  const keys = qualifiedKeys(
+    facts.map((fact) => fact.key),
+    qualifierWordsOf(doc),
+  );
+  return facts.map((fact, index) => ({ ...fact, key: keys[index] ?? fact.key }));
+};
+
+/**
+ * 単位の語彙表の量（410 g、1.2 kg）と期間（3 months）と年齢（満70歳まで、aged 20 to 70）も値として読む。木が単位を読まない量は、
+ * 数だけでは升や文の値にならない。年齢と重なる期間（30 years old の 30 years）と、期間と重なる量（3 months の 3 m）は読まない。
+ */
 const readFacts = (doc: ProseDocument, tree: StructureNode): ScopedFact[] => {
-  const values = factValues(tree, doc.source, nameSpans(doc));
-  const facts = [...labelledFacts(doc.source, values, factWordsOf(doc)), ...tableFacts(doc.source, values)];
-  return scopedFacts(facts, tree, doc.source, patternsOf(doc, "summary-heading"));
+  const tagged = factValues(tree, doc.source, nameSpans(doc));
+  const ages = ageValues(doc.source, tagged, ageWordsOf(doc));
+  const aged = spanIndex(ages);
+  const durations = durationValues(
+    doc.source,
+    tagged.filter((value) => !overlapsAny(aged, value)),
+    durationWordsOf(doc),
+  );
+  const taken = spanIndex([...ages, ...durations]);
+  const values = valuesWith(tree, doc, [...measuredOf(doc).filter((value) => !overlapsAny(taken, value)), ...ages, ...durations]);
+  const terms = termValues(doc.source, values, termValueWordsOf(doc));
+  const termed = new Set(terms.map((fact) => fact.value.start));
+  const labelled = labelledFacts(doc.source, values, { ...factWordsOf(doc), qualifiers: qualifierWordsOf(doc) }).filter(
+    (fact) => !termed.has(fact.value.start),
+  );
+  const read = new Set([...termed, ...labelled.map((fact) => fact.value.start)]);
+  const verbs = verbQuantityFacts(doc.source, values, verbQuantityWordsOf(doc)).filter((fact) => !read.has(fact.value.start));
+  const tabled = tableFacts(doc.source, values, totalColumnsOf(doc), countLabelWordsOf(doc.lexicons));
+  const facts = withQualifiedKeys(doc, [...labelled, ...terms, ...verbs, ...tabled]);
+  return withCellKeys(scopedFacts(facts, tree, doc.source, patternsOf(doc, "summary-heading")), qualifierWordsOf(doc));
 };
 
 /** 文書の名前付きの値。二つの rule が読むので、文書ごとに一度だけ読む。 */
@@ -51,8 +169,89 @@ const findingOf =
     values: { label: conflict.fact.label, value: shown(doc, conflict.fact.value), other: shown(doc, conflict.other), offset: conflict.fact.value.start },
   });
 
-/** 同じ節で、同じ名前に二通りの値（締切：10月5日 と 締切：10月7日）。 */
-export const factConflict: Detector = (doc): Finding[] => scopeConflicts(factsOf(doc)).map(findingOf("fact-conflict", doc));
+const UNITS: readonly DurationUnit[] = ["day", "week", "month", "year"];
+
+const isDurationUnit = (group: string | undefined): group is DurationUnit => UNITS.some((unit) => unit === group);
+
+const retentionUnitOf = (doc: ProseDocument, unit: string): DurationUnit | undefined => {
+  const listed = DURATION_LEXICONS.find(([id]) => patternsOf(doc, id).some((pattern) => pattern.normalize("NFKC") === unit))?.[1];
+  const extra = (doc.lexicons["retention-unit"] ?? []).find((entry) => entry.pattern.normalize("NFKC") === unit)?.group;
+  return listed ?? (isDurationUnit(extra) ? extra : undefined);
+};
+
+/** 単位の語彙表に、書いた単位より長い形（か月 に対する か月間）があれば、そこまで。木の数量は か月 で終わる。 */
+const endWithLongerUnit = (doc: ProseDocument, quantity: Quantity): number => {
+  const unitStart = quantity.end - quantity.unit.length;
+  const longer = DURATION_LEXICONS.flatMap(([id]) => patternsOf(doc, id))
+    .filter((pattern) => pattern.length > quantity.unit.length && pattern.startsWith(quantity.unit) && doc.source.startsWith(pattern, unitStart))
+    .reduce((longest, pattern) => Math.max(longest, pattern.length), quantity.unit.length);
+  return unitStart + longer;
+};
+
+const retentionLengthsOf = (doc: ProseDocument, tree: StructureNode): RetentionLength[] =>
+  quantitiesOf(tree, doc.source).flatMap((quantity) => {
+    const unit = retentionUnitOf(doc, quantity.unit);
+    return unit === undefined ? [] : [{ start: quantity.start, end: endWithLongerUnit(doc, quantity), amount: quantity.amount, unit }];
+  });
+
+const retentionVerbsOf = (doc: ProseDocument): RetentionVerb[] =>
+  (doc.lexicons["retention-verb"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? "", position: entry.position ?? "before" }));
+
+const lengthMarksOf = (doc: ProseDocument): LengthMark[] =>
+  (doc.lexicons["retention-length-mark"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? "", position: entry.position ?? "before" }));
+
+const retentionWordsOf = (doc: ProseDocument): RetentionWords => ({
+  verbs: retentionVerbsOf(doc),
+  marks: lengthMarksOf(doc),
+  modifiers: patternsOf(doc, "retention-length-modifier"),
+  bounds: [...wordsAt(doc, "approximate-marker"), ...wordsAt(doc, "retention-bound")],
+  joiners: patternsOf(doc, "fact-name-joiner"),
+  objectMarks: patternsOf(doc, "retention-object-mark"),
+});
+
+/** 文書のどこかで、同じものの保存期間が二通り（1年間保存 と 3年間を経過したら削除）。 */
+const retentionFindings = (doc: ProseDocument): Finding[] => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const sentences = doc.sentences.map((sentence) => ({ ...sentence.span, tokens: sentence.tokens ?? [] }));
+  return retentionConflicts(doc.source, sentences, retentionLengthsOf(doc, tree), retentionWordsOf(doc)).map(({ object, value, other }): Finding => ({
+    rule: "fact-conflict",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, value.start),
+    variant: "retention",
+    values: { label: object, value: doc.source.slice(value.start, value.end), other: doc.source.slice(other.start, other.end), offset: value.start },
+  }));
+};
+
+const SECTION_KINDS: ReadonlySet<string> = new Set(["section", "chapter", "article"]);
+
+const sectionsOf = (tree: StructureNode | undefined): { heading: string; start: number; end: number }[] =>
+  tree === undefined
+    ? []
+    : inDocumentOrder(tree)
+        .filter((node) => SECTION_KINDS.has(node.kind))
+        .map((node) => ({ heading: String(node.attrs["heading"] ?? ""), start: node.span.start, end: node.span.end }));
+
+/** 文書全体で一つの項目（試用期間）の、拠り所（表の升、項目の名前を見出しにした節）の値と違う別の節の文の値。 */
+const termFindings = (doc: ProseDocument): Finding[] => {
+  const words = termWordsOf(doc);
+  return documentTermConflicts(factsOf(doc), words, termHomes(sectionsOf(doc.structure), words)).map((conflict): Finding => {
+    const finding = findingOf("fact-conflict", doc)(conflict);
+    if (conflict.section === undefined) return { ...finding, variant: "term" };
+    return { ...finding, variant: "term-section", values: { ...finding.values, section: conflict.section } };
+  });
+};
+
+/** 同じ節で、同じ名前に二通りの値（締切：10月5日 と 締切：10月7日）。文書のどこでも、同じものに二通りの保存期間。 */
+export const factConflict: Detector = (doc): Finding[] => [
+  ...scopeConflicts(factsOf(doc)).map(findingOf("fact-conflict", doc)),
+  ...termFindings(doc),
+  ...rowSentenceFindings(doc, factsOf(doc)),
+  ...retentionFindings(doc),
+  ...wholeCountFindings(doc),
+];
 
 const countedPhrasesOf = (doc: ProseDocument): CountedPhrase[] =>
   doc.sentences.flatMap((sentence) => {

package/src/detectors/gloss-year.ts

@@ -0,0 +1,21 @@
+// A date whose year is written twice, once in brackets (in another calendar), where the two name different years. Pure.
+import type { StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+
+/** A date node's year as written outside the brackets (from its value) and inside them (glossYear), both as Western years. */
+export type GlossedDate = { readonly offset: number; readonly end: number; readonly year: number; readonly glossYear: number };
+
+const YEAR_FIRST = /^(\d{4})(?:-|$)/u;
+
+const glossedOf = (node: StructureNode): GlossedDate[] => {
+  const glossYear = node.attrs["glossYear"];
+  const year = YEAR_FIRST.exec(String(node.attrs["value"] ?? ""))?.[1];
+  if (node.kind !== "date" || typeof glossYear !== "number" || year === undefined) return [];
+  return [{ offset: node.span.start, end: node.span.end, year: Number(year), glossYear }];
+};
+
+/** The dates of the tree whose bracketed year differs from the year outside the brackets, in document order. */
+export const yearDisagreements = (tree: StructureNode): GlossedDate[] =>
+  inDocumentOrder(tree)
+    .flatMap(glossedOf)
+    .filter((date) => date.year !== date.glossYear);

package/src/detectors/gpa-mismatch.ts

@@ -0,0 +1,43 @@
+// gpa-mismatch: the reading half. Reads the document's Markdown tables, its other lines, and the lexicons
+// transcript-column, grade-point and gpa-label, and leaves the deciding to structure/gpa.ts.
+import type { Detector, Finding, LexiconEntry, ProseDocument } from "../plugin.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { linesOf } from "../structure/lines.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { gpaMismatches, type GpaWords, type GradeWord, type TranscriptRole } from "../structure/gpa.ts";
+
+const RULE = "gpa-mismatch";
+const ROLES: readonly string[] = ["points", "grade", "credits", "course", "total"] satisfies readonly TranscriptRole[];
+const isRole = (group: string | undefined): group is TranscriptRole => group !== undefined && ROLES.includes(group);
+/** The grade-point group of grades that carry no points (認定, Pass). */
+const NO_POINTS = "none";
+
+const gradeWordOf = (entry: LexiconEntry): GradeWord[] => {
+  if (entry.group === NO_POINTS) return [{ pattern: entry.pattern, scale: NO_POINTS }];
+  return entry.group === undefined || entry.weight === undefined ? [] : [{ pattern: entry.pattern, scale: entry.group, points: entry.weight }];
+};
+
+const wordsOf = (doc: ProseDocument): GpaWords => ({
+  columns: (doc.lexicons["transcript-column"] ?? []).flatMap((entry) => (isRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : [])),
+  grades: (doc.lexicons["grade-point"] ?? []).flatMap(gradeWordOf),
+  labels: (doc.lexicons["gpa-label"] ?? []).map((entry) => ({ pattern: entry.pattern, part: entry.group === "part" })),
+});
+
+export const gpaMismatch: Detector = (doc): Finding[] => {
+  const words = wordsOf(doc);
+  if (words.columns.length === 0 || words.grades.length === 0 || words.labels.length === 0) return [];
+  const lines = linesOf(proseAndTablesOf(doc));
+  const found = tablesOf(lines);
+  const tableLines = new Set(found.flatMap((table) => [table.header.number, ...table.rows.map((row) => row.number)]));
+  const tables = found.map((table) => ({ header: cellsOf(table.header), rows: table.rows.map(cellsOf) }));
+  const prose = lines.filter((line) => !tableLines.has(line.number));
+  return gpaMismatches(tables, prose, words).map((issue) => ({
+    rule: RULE,
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/heading-case.ts

@@ -34,11 +34,20 @@ const ACRONYM = /^[A-Z]{2,}s?$/u;
 
 const TITLE_DEPTH = 1;
 
-/** 見出しが Title Case か。判定できなければ undefined。 */
-export const isTitleCase = (heading: string): boolean | undefined => {
-  const words = [...withoutCodeWords(straightApostrophes(heading)).matchAll(WORD)]
+/**
+ * 見出しの頭の番号の札（Section 3. / Day 1: / Part II:）。札の語は流儀によらず大文字で始まり、続く題の語数にも数えない。
+ * 番号は 3 桁までで、後ろに「.」「:」「)」か ダッシュがあるものだけ（Windows 11 Setup も Budget 2026: も札ではない）。
+ */
+const LEADING_LABEL = /^\s*\p{Lu}\p{Ll}+\s+(?:\d{1,3}(?:\.\d{1,3})*|[IVXLC]+)\s*[.:)\-\u2013\u2014]\s+/u;
+
+/**
+ * 見出しが Title Case か。判定できなければ undefined。fixedCase は流儀によらず大文字で書く語（曜日・月の名）で、
+ * どちらの流儀の証拠にもならないので数えない。
+ */
+export const isTitleCase = (heading: string, fixedCase: ReadonlySet<string> = new Set()): boolean | undefined => {
+  const words = [...withoutCodeWords(straightApostrophes(heading.replace(LEADING_LABEL, ""))).matchAll(WORD)]
     .map((match) => match[0])
-    .filter((word) => !MINOR_WORDS.has(word.toLowerCase()) && !ACRONYM.test(word));
+    .filter((word) => !MINOR_WORDS.has(word.toLowerCase()) && !ACRONYM.test(word) && !fixedCase.has(word));
   // 1 語の見出しは、どちらの流儀でも先頭が大文字になる。判定できない。
   if (words.length < 2) return undefined;
   const capitalized = words.filter((word) => word[0] === word[0]?.toUpperCase()).length;

package/src/detectors/heading-echo.ts

@@ -65,6 +65,22 @@ const pointsElsewhere = (doc: ProseDocument, section: Section): boolean => {
   return first !== undefined && (holdsLink(doc.source, first.span, doc.links) || namesLocation(doc.source.slice(first.span.start, first.span.end)));
 };
 
+/** A figure, with its thousands separators (1,320,000), compared without them. */
+const FIGURE = /\p{Nd}+(?:[,，]\p{Nd}{3})*/gu;
+/** Note marks are not figures: [^1], ※1, <sup>1</sup>. */
+const NOTE_MARK = /\[\^[^\]]*\]|※\p{Nd}+|<sup>[^<]*<\/sup>/gu;
+
+const figuresOf = (text: string): string[] => (text.replace(NOTE_MARK, "").match(FIGURE) ?? []).map((figure) => figure.replace(/[,，]/gu, ""));
+
+/**
+ * 最初の文が、見出しに無い数（金額・番号・日付）を述べている。見出しが約束した中身そのもので（## 見積金額 → 見積金額は1,320,000円です。
+ * Invoice → Invoice number: INV-2026-0318）、語が重なっても読者は何かを受け取る。
+ */
+export const statesFigure = (heading: string, sentence: string): boolean => {
+  const inHeading = new Set(figuresOf(heading));
+  return figuresOf(sentence).some((figure) => !inHeading.has(figure));
+};
+
 /** 見出しとの重なりを測る文。用語集や表記の手引きは見出しの語の別の書き方を引用する（Not “datacentre”）ので、それは数えない。 */
 const echoedText = (section: Section): string => withoutQuotedVariants(section.firstSentence?.text ?? "", measuredHeading(section));
 
@@ -72,7 +88,7 @@ export const headingEcho: Detector = (doc, options): Finding[] => {
   const leadIns = (doc.lexicons["lead-in"] ?? []).map((entry) => entry.pattern);
   return doc.sections
     .filter((section) => section.heading.length > 0 && section.firstSentence !== undefined && addsLittle(section, doc.lengthUnit))
-    .filter((section) => !leadsIn(doc, section, leadIns) && !pointsElsewhere(doc, section))
+    .filter((section) => !leadsIn(doc, section, leadIns) && !pointsElsewhere(doc, section) && !statesFigure(section.heading, section.firstSentence?.text ?? ""))
     .map((section) => ({ section, overlap: Math.round(containment(trigrams(measuredHeading(section)), trigrams(echoedText(section))) * 100) }))
     .filter(({ overlap }) => overlap >= options.limit)
     .map(({ section, overlap }) => ({

package/src/detectors/impossible-date.ts

@@ -1,6 +1,7 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { escapeRegExp } from "../orthography.ts";
 import { quoteAround } from "./quote-around.ts";
+import { yearDisagreements } from "./gloss-year.ts";
 
 // 暦に無い日付（2月30日、4月31日、2023-02-29）。月の長さとうるう年は暦で決まるので、書き損じは機械で言える。
 // 月の名前は語彙表 month-name（初めの十二が一月から順に）、年月日の単位は date-time-unit（大きい順の初めの三つ）、元号は calendar-era が言う。
@@ -127,9 +128,24 @@ export const calendarWordsOf = (doc: ProseDocument): CalendarWords => ({
   eras: patternsOf(doc, "calendar-era"),
 });
 
-export const impossibleDate: Detector = (doc): Finding[] => {
-  const text = doc.prose ?? doc.source;
-  return impossibleDates(text, calendarWordsOf(doc)).map((found) => ({
+/** 二つの暦で書いた年の、括弧の外と中が違うもの。二つの年は言語パッケージが日付の木に読んでおく。木は表と引用も読むので、本文に見える日付だけ。 */
+const yearsFindings = (doc: ProseDocument, text: string): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : yearDisagreements(doc.structure)
+        .filter((found) => text.slice(found.offset, found.end) === doc.source.slice(found.offset, found.end))
+        .map((found) => ({
+          rule: "",
+          severity: "warning",
+          line: 0,
+          column: 0,
+          quote: quoteAround(text, found.offset, found.end),
+          values: { written: doc.source.slice(found.offset, found.end), year: found.year, glossYear: found.glossYear, offset: found.offset },
+          variant: "years",
+        }));
+
+const calendarFindings = (text: string, doc: ProseDocument): Finding[] =>
+  impossibleDates(text, calendarWordsOf(doc)).map((found) => ({
     rule: "",
     severity: "warning",
     line: 0,
@@ -138,4 +154,10 @@ export const impossibleDate: Detector = (doc): Finding[] => {
     values: { written: found.written, month: found.month, days: found.days, offset: found.offset },
     variant: found.reason,
   }));
+
+export const impossibleDate: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  return [...calendarFindings(text, doc), ...yearsFindings(doc, text)].toSorted(
+    (left, right) => Number(left.values["offset"]) - Number(right.values["offset"]),
+  );
 };