chaffjs 0.31.0 → 0.32.0

package/src/detectors/fact-consistency.ts

@@ -2,8 +2,11 @@ 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";
@@ -13,25 +16,135 @@ 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[]>();
 
-/** 単位の語彙表の量（410 g、1.2 kg）も値として読む。木が単位を読まない量は、数だけでは升や文の値にならない。 */
+/** 期間の単位と、年数にもなる単位（「保証期間は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 = valuesWith(tree, doc, measuredOf(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 が読むので、文書ごとに一度だけ読む。 */
@@ -112,8 +225,33 @@ const retentionFindings = (doc: ProseDocument): Finding[] => {
   }));
 };
 
+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)), ...retentionFindings(doc)];
+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/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"]),
+  );
 };

package/src/detectors/installment-total-mismatch.ts

@@ -0,0 +1,68 @@
+// installment-total-mismatch: a number of payments times the amount of each that is not the stated total of payments
+// (structure/installment-total.ts). The amounts are currency-notation's, read with amount-multiplier's words of scale; the
+// labels are installment-label, the other words installment-word, approximate-marker, number-word (digit), range-connector
+// and amount-range-word.
+import type { Detector, Finding, Lexicon, ProseDocument } from "../plugin.ts";
+import { installmentTotalMismatches, type InstallmentAmount, type InstallmentWords, type PositionedWord } from "../structure/installment-total.ts";
+import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
+import { amountsIn, formsOf } from "./currency-notation.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAround } from "./quote-around.ts";
+
+const entriesOf = (doc: ProseDocument, lexicon: string, group?: string): Lexicon =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group);
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] => entriesOf(doc, lexicon, group).map((entry) => entry.pattern);
+
+const markersOf = (doc: ProseDocument): PositionedWord[] =>
+  entriesOf(doc, "approximate-marker").map((entry) => ({ word: entry.pattern, position: entry.position === "after" ? "after" : "before" }));
+
+const numberWordsOf = (doc: ProseDocument): InstallmentWords["numberWords"] =>
+  entriesOf(doc, "number-word", "digit").flatMap((entry) => (entry.weight === undefined ? [] : [{ word: entry.pattern, value: entry.weight }]));
+
+const labelsOf = (doc: ProseDocument): InstallmentWords["labels"] => ({
+  count: patternsOf(doc, "installment-label", "count"),
+  each: patternsOf(doc, "installment-label", "each"),
+  first: patternsOf(doc, "installment-label", "first"),
+  last: patternsOf(doc, "installment-label", "last"),
+  total: patternsOf(doc, "installment-label", "total"),
+});
+
+const wordsOf = (doc: ProseDocument): InstallmentWords => ({
+  labels: labelsOf(doc),
+  units: patternsOf(doc, "installment-word", "unit"),
+  qualifiers: patternsOf(doc, "installment-word", "qualifier"),
+  links: patternsOf(doc, "installment-word", "link"),
+  per: patternsOf(doc, "installment-word", "per"),
+  rounding: patternsOf(doc, "installment-word", "rounding"),
+  skips: patternsOf(doc, "installment-word", "skip"),
+  markers: markersOf(doc),
+  connectors: [...patternsOf(doc, "range-connector"), ...patternsOf(doc, "amount-range-word")],
+  numberWords: numberWordsOf(doc),
+});
+
+const amountsOf = (text: string, doc: ProseDocument): InstallmentAmount[] => {
+  const scales = scaleWordsOf(doc);
+  return amountsIn(
+    text,
+    formsOf(doc),
+    scales.map((scale) => scale.word),
+  ).flatMap((amount) => {
+    const read = scaledAmountOf(text, amount, scales);
+    return read === undefined
+      ? []
+      : [{ offset: read.offset, end: amount.offset + amount.written.length, currency: read.currency, value: read.value, scale: read.unit }];
+  });
+};
+
+export const installmentTotalMismatch: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  return installmentTotalMismatches(text, amountsOf(text, doc), wordsOf(doc)).map((issue) => ({
+    rule: "installment-total-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/interest.ts

@@ -0,0 +1,43 @@
+// interest-mismatch: the reading half. Reads the document's lines outside tables and the lexicon interest-label, and
+// leaves the deciding to structure/interest.ts.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { linesOf } from "../structure/lines.ts";
+import { TABLE_ROW } from "../structure/runs.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { interestMismatches, type InterestPeriod, type InterestRole, type InterestWords, type PeriodWord } from "../structure/interest.ts";
+
+const RULE = "interest-mismatch";
+const ROLES: readonly string[] = ["interest", "base", "rate", "net"] satisfies readonly InterestRole[];
+const isRole = (group: string | undefined): group is InterestRole => group !== undefined && ROLES.includes(group);
+/** group rate-year: a rate for a year (年利, APR); interest-month: interest for a month (当月, for the month). */
+const PERIOD_GROUP = /^(rate|interest)-(year|month)$/u;
+
+const periodOf = (pattern: string, group: string | undefined): PeriodWord[] => {
+  const match = PERIOD_GROUP.exec(group ?? "");
+  const [of, period] = [match?.[1], match?.[2]];
+  return (of === "rate" || of === "interest") && (period === "year" || period === "month") ? [{ pattern, of, period: period satisfies InterestPeriod }] : [];
+};
+
+/** Lexicon interest-label: the words of the interest, the balance, the rate and after-tax interest, and the period words. */
+const interestWordsOf = (doc: ProseDocument): InterestWords => {
+  const entries = doc.lexicons["interest-label"] ?? [];
+  return {
+    labels: entries.flatMap((entry) => (isRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : [])),
+    periods: entries.flatMap((entry) => periodOf(entry.pattern, entry.group)),
+  };
+};
+
+export const interest: Detector = (doc): Finding[] => {
+  const words = interestWordsOf(doc);
+  if (words.labels.length === 0) return [];
+  const lines = linesOf(proseAndTablesOf(doc)).filter((line) => !TABLE_ROW.test(line.text) && line.text.trim() !== "");
+  return interestMismatches(lines, 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/lab-columns.ts

@@ -0,0 +1,9 @@
+// The heading words of a lab results table: lab-result-column, which every lab-table rule reads, then the words only one rule
+// reads (its own lexicon).
+import type { ProseDocument } from "../plugin.ts";
+import { isLabColumn, type LabColumnWord } from "../structure/lab-columns.ts";
+
+export const labColumnWordsOf = (doc: ProseDocument, ownLexicon: string): LabColumnWord[] =>
+  [...(doc.lexicons["lab-result-column"] ?? []), ...(doc.lexicons[ownLexicon] ?? [])].flatMap((entry) =>
+    isLabColumn(entry.group) ? [{ pattern: entry.pattern, column: entry.group }] : [],
+  );

package/src/detectors/labelled-age.ts

@@ -0,0 +1,154 @@
+// An age beside a labelled date of birth, compared with the exact age on a labelled reference date (elapsed-years-mismatch).
+import type { Detector, Finding, LexiconEntry, ProseDocument, Span, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { documentYearFindings } from "./derived-numbers.ts";
+import { calendarDateOf } from "../derived/date-arithmetic.ts";
+import {
+  ageMismatches,
+  ageVerdicts,
+  agesIn,
+  labelAfter,
+  labelBefore,
+  type AgeWords,
+  type LabelledBirth,
+  type LabelWord,
+  type LabelledReference,
+} from "../derived/age-on-date.ts";
+
+type DateNode = Span & { readonly value: string };
+
+const entriesOf = (doc: ProseDocument, id: string): readonly LexiconEntry[] => doc.lexicons[id] ?? [];
+
+const patternsAt = (doc: ProseDocument, id: string, position: "before" | "after"): string[] =>
+  entriesOf(doc, id)
+    .filter((entry) => (entry.position ?? "before") === position)
+    .map((entry) => entry.pattern);
+
+const ageWords = (doc: ProseDocument): AgeWords => ({
+  before: patternsAt(doc, "age-marker", "before"),
+  after: [...patternsAt(doc, "age-marker", "after"), ...entriesOf(doc, "age-unit").map((entry) => entry.pattern)],
+  skip: entriesOf(doc, "duration-year").map((entry) => entry.pattern),
+  approximateBefore: patternsAt(doc, "approximate-marker", "before"),
+  approximateAfter: patternsAt(doc, "approximate-marker", "after"),
+});
+
+const datesOf = (tree: StructureNode): DateNode[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ ...node.span, value: String(node.attrs["value"]) }] : []));
+
+const lineStartOf = (source: string, at: number): number => source.lastIndexOf("\n", at - 1) + 1;
+
+const lineEndOf = (source: string, at: number): number => {
+  const end = source.indexOf("\n", at);
+  return end === -1 ? source.length : end;
+};
+
+const isFullDate = (value: string): boolean => calendarDateOf(value)?.year !== undefined;
+
+/** A clause or bracket ends here: past a reference date, the age is read only up to the first of these. */
+const CLAUSE_END = /[)）\]］】。;；]/u;
+
+const blanked = (text: string, from: number, spans: readonly Span[]): string =>
+  spans.reduce((written, span) => [written.slice(0, span.start - from), " ".repeat(span.end - span.start), written.slice(span.end - from)].join(""), text);
+
+type AgeRegion = { readonly text: string; readonly passed: readonly LabelledReference[] };
+
+const referenceAt = (references: readonly LabelledReference[], date: DateNode): LabelledReference | undefined =>
+  references.find((reference) => reference.start === date.start);
+
+/** The reference dates right after a date of birth on its line, before the first date that is not one. */
+const passedReferences = (later: readonly DateNode[], references: readonly LabelledReference[]): LabelledReference[] => {
+  const stop = later.findIndex((date) => referenceAt(references, date) === undefined);
+  return later.slice(0, stop === -1 ? later.length : stop).flatMap((date) => referenceAt(references, date) ?? []);
+};
+
+/** Where the age beside a date of birth is written: up to the next date that is not a reference date, or the line end.
+ * Past a reference date ("（2026年9月30日現在、23歳）"), only to the end of its bracket or clause; its digits are blanked. */
+const ageRegionOf = (doc: ProseDocument, date: DateNode, dates: readonly DateNode[], references: readonly LabelledReference[]): AgeRegion => {
+  const lineEnd = lineEndOf(doc.source, date.end);
+  const later = dates.filter((other) => other.start >= date.end && other.start < lineEnd);
+  const passed = passedReferences(later, references);
+  const last = passed.at(-1);
+  const open = later[passed.length]?.start ?? lineEnd;
+  const clauseEnd = last === undefined ? -1 : doc.source.slice(last.end, open).search(CLAUSE_END);
+  const end = last === undefined || clauseEnd === -1 ? open : last.end + clauseEnd;
+  return { text: blanked(doc.source.slice(date.end, end), date.end, passed), passed };
+};
+
+/** The age after a labelled date of birth, in its region (ageRegionOf): one age, or none. */
+const birthOf = (doc: ProseDocument, date: DateNode, dates: readonly DateNode[], references: readonly LabelledReference[]): LabelledBirth[] => {
+  if (
+    !isFullDate(date.value) ||
+    labelBefore(doc.source.slice(lineStartOf(doc.source, date.start), date.start), entriesOf(doc, "birth-date-label")) === undefined
+  )
+    return [];
+  const { text: region, passed } = ageRegionOf(doc, date, dates, references);
+  const ages = agesIn(region, ageWords(doc));
+  const [age] = ages;
+  if (ages.length !== 1 || age === undefined) return [];
+  const lead = region.slice(0, age.start).toLowerCase();
+  const tail = region.slice(age.end).trimStart().toLowerCase();
+  const mark = entriesOf(doc, "age-time-mark").find((entry) => lead.includes(entry.pattern.toLowerCase()) || tail.startsWith(entry.pattern.toLowerCase()));
+  const group = mark?.group ?? (passed.length === 1 ? passed[0]?.group : undefined);
+  return [{ start: date.start, end: date.end, birth: date.value, age: { ...age, start: date.end + age.start, end: date.end + age.end }, group }];
+};
+
+const ownLabel = (doc: ProseDocument, date: DateNode): LabelWord | undefined => {
+  const labels = entriesOf(doc, "age-reference-label");
+  return (
+    labelBefore(doc.source.slice(lineStartOf(doc.source, date.start), date.start), labels, ageWords(doc)) ??
+    labelAfter(doc.source.slice(date.end, lineEndOf(doc.source, date.end)), labels)
+  );
+};
+
+/** Dates with a reference label. A later date on the same line without a label of its own takes the label before it
+ * ("Examination date: March 1, 2026 and March 3, 2026" is two examination dates, and the age is then undecided). */
+const referencesOf = (doc: ProseDocument, dates: readonly DateNode[]): LabelledReference[] => {
+  const labelled = dates.reduce<{ readonly line: number; readonly label: LabelWord | undefined; readonly found: LabelledReference[] }>(
+    (state, date) => {
+      const line = lineStartOf(doc.source, date.start);
+      const label = ownLabel(doc, date) ?? (line === state.line ? state.label : undefined);
+      if (label !== undefined && isFullDate(date.value))
+        state.found.push({ start: date.start, end: date.end, date: date.value, group: label.group ?? label.pattern });
+      return { line, label, found: state.found };
+    },
+    { line: -1, label: undefined, found: [] },
+  );
+  return labelled.found;
+};
+
+const recordsOf = (doc: ProseDocument, tree: StructureNode): { births: LabelledBirth[]; references: LabelledReference[] } => {
+  const dates = datesOf(tree);
+  const references = referencesOf(doc, dates);
+  return { births: dates.flatMap((date) => birthOf(doc, date, dates, references)), references };
+};
+
+/** Where the ages whose reference date was decided start: the year-only check stays silent on them. */
+const decidedAgeStarts = (doc: ProseDocument, tree: StructureNode): ReadonlySet<number> => {
+  const { births, references } = recordsOf(doc, tree);
+  return new Set(ageVerdicts(births, references).map((verdict) => verdict.birth.age.start));
+};
+
+const written = (doc: ProseDocument, span: Span): string => doc.source.slice(span.start, span.end);
+
+const labelledAgeFindings = (doc: ProseDocument, tree: StructureNode): Finding[] => {
+  const { births, references } = recordsOf(doc, tree);
+  return ageMismatches(births, references).map(({ birth, reference, expected }) => ({
+    rule: "elapsed-years-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, birth.age.start),
+    variant: "birth-date",
+    values: { written: written(doc, birth.age), birth: written(doc, birth), reference: written(doc, reference), expected, offset: birth.age.start },
+  }));
+};
+
+/** 起点の年から数えた年数が文書の日付と合わない。生年月日の横の年齢が、受診日などの満年齢と合わない。 */
+export const elapsedYearsMismatch: Detector = (doc) => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const decided = decidedAgeStarts(doc, tree);
+  const byDocumentYear = documentYearFindings(doc, tree).filter((finding) => !decided.has(Number(finding.values?.["offset"])));
+  return [...labelledAgeFindings(doc, tree), ...byDocumentYear];
+};