chaffjs 0.28.0 → 0.30.0

package/src/detectors/derived-numbers.ts

@@ -6,6 +6,22 @@ import { yearOf, type DurationUnit } from "../derived/date-arithmetic.ts";
 import { durationMismatches, type DatedValue, type Duration } from "../derived/durations.ts";
 import { elapsedMismatches, type Elapsed, type OriginWord, type Year } from "../derived/elapsed.ts";
 import { numberWordCounts } from "../derived/number-word-counts.ts";
+import {
+  nightsDaysMismatches,
+  nightsDaysPairs,
+  stayNightsMismatches,
+  tableNightsMismatches,
+  type Count,
+  type NightsMismatch,
+  type StayColumnWords,
+} from "../derived/stays.ts";
+import { numeralCounts } from "../derived/unit-counts.ts";
+import { timeLengths, type LengthWords, type TimeLength } from "../derived/time-lengths.ts";
+import { workingHoursMismatches, type WorkingHoursMismatch } from "../derived/working-hours.ts";
+import { sessionHoursMismatches } from "../derived/session-hours.ts";
+import { clockTimes } from "../compare/clock-time.ts";
+import { secondsOf, type Mark } from "../structure/time-marks.ts";
+import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAt } from "./structure-tree.ts";
 
 /** 期間の単位の語彙表。木の数量の単位がどれかに入れば、その単位の期間。 */
@@ -29,11 +45,28 @@ const endWithUnit = (source: string, end: number, unit: string): number => {
   return unit !== "" && source.startsWith(unit, end + gap) ? end + gap + unit.length : end;
 };
 
+const OPEN_BRACKET = " (";
+const WORD_LETTER = /[\p{L}-]/u;
+
+/** Where the word before " (" starts ("six (" in "six (6) months"), or undefined when no word stands there. */
+const wordStartBeforeBracket = (source: string, at: number): number | undefined => {
+  if (source.slice(Math.max(0, at - OPEN_BRACKET.length), at) !== OPEN_BRACKET) return undefined;
+  let start = at - OPEN_BRACKET.length;
+  while (start > 0 && WORD_LETTER.test(source.charAt(start - 1))) start -= 1;
+  return start < at - OPEN_BRACKET.length ? start : undefined;
+};
+
+/** 「six (6) months」は語の数から単位まで。括弧の中の数だけでは、指摘に引いたとき何の期間か読めない。 */
+const withWordsAround = (source: string, start: number, end: number, unit: string): Span => {
+  const wordStart = source.charAt(end) === ")" ? wordStartBeforeBracket(source, start) : undefined;
+  return wordStart === undefined ? { start, end: endWithUnit(source, end, unit) } : { start: wordStart, end: endWithUnit(source, end + 1, unit) };
+};
+
 const quantitiesOf = (tree: StructureNode, source: string): Quantity[] =>
   inDocumentOrder(tree).flatMap((node): Quantity[] => {
     if (node.kind !== "quantity") return [];
     const unit = String(node.attrs["unit"] ?? "");
-    return [{ start: node.span.start, end: endWithUnit(source, node.span.end, unit), amount: Number(node.attrs["value"]), unit: unit.normalize("NFKC") }];
+    return [{ ...withWordsAround(source, node.span.start, node.span.end, unit), amount: Number(node.attrs["value"]), unit: unit.normalize("NFKC") }];
   });
 
 const datesOf = (tree: StructureNode): DatedValue[] =>
@@ -65,22 +98,153 @@ const durationsOf = (doc: ProseDocument, quantities: readonly Quantity[]): Durat
 
 const sentencesOf = (doc: ProseDocument): Span[] => doc.sentences.map((sentence) => sentence.span);
 
-/** 始まり + 期間 ≠ 終わり。 */
+/** 泊数（3泊、3 nights、three nights）。text は地の文と表（リンク先や code は読まない）。目安の泊数（最大3泊）は除く。 */
+/** 数と単位（3泊、15 sessions、three nights）。 */
+const unitCountsOf = (doc: ProseDocument, text: string, units: readonly string[]): Count[] => {
+  const numerals = numeralCounts(text, units);
+  const taken = spanIndex(numerals);
+  const worded = numberWordCounts(text, patternsOf(doc, "count-number"), units).filter((count) => !overlapsAny(taken, count));
+  return [...numerals, ...worded].toSorted((left, right) => left.start - right.start);
+};
+
+const nightsOf = (doc: ProseDocument, text: string): Count[] =>
+  unitCountsOf(doc, text, patternsOf(doc, "stay-night")).filter((count) => !isApproximate(doc, count));
+
+const finding = (doc: ProseDocument, offset: number, values: Record<string, string | number>, variant?: string): Finding => ({
+  rule: "duration-mismatch",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, offset),
+  ...(variant === undefined ? {} : { variant }),
+  values: { ...values, offset },
+});
+
+const written = (doc: ProseDocument, span: Span): string => doc.source.slice(span.start, span.end);
+
+const nightsFinding = (doc: ProseDocument, mismatch: NightsMismatch): Finding =>
+  finding(
+    doc,
+    mismatch.nights.start,
+    { start: written(doc, mismatch.start), end: written(doc, mismatch.end), nights: written(doc, mismatch.nights).trim(), expected: mismatch.expected },
+    "nights",
+  );
+
+const stayColumnWords = (doc: ProseDocument): StayColumnWords => ({
+  checkIn: patternsOf(doc, "stay-check-in-column"),
+  checkOut: patternsOf(doc, "stay-check-out-column"),
+  nights: patternsOf(doc, "stay-nights-column"),
+  units: patternsOf(doc, "stay-night"),
+});
+
+const marksOf = (doc: ProseDocument, id: string): Mark[] =>
+  (doc.lexicons[id] ?? []).map((entry) => ({ pattern: entry.pattern, position: entry.position, group: entry.group }));
+
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_MINUTE = 60;
+
+/** The hour and minute units of unit-time, told apart by their weight in seconds. */
+const unitsWeighing = (doc: ProseDocument, seconds: number): string[] =>
+  (doc.lexicons["unit-time"] ?? []).filter((entry) => entry.weight === seconds).map((entry) => entry.pattern);
+
+const lengthWords = (doc: ProseDocument): LengthWords => ({
+  hourUnits: unitsWeighing(doc, SECONDS_PER_HOUR),
+  minuteUnits: unitsWeighing(doc, SECONDS_PER_MINUTE),
+  halves: patternsOf(doc, "length-half"),
+  numberWords: patternsOf(doc, "count-number"),
+});
+
+const lengthsOf = (doc: ProseDocument, text: string): TimeLength[] => timeLengths(text, lengthWords(doc));
+
+const MINUTES_PER_HOUR = 60;
+const HOUR_DECIMALS = 100;
+
+const hoursOf = (minutes: number): number => Math.round((minutes / MINUTES_PER_HOUR) * HOUR_DECIMALS) / HOUR_DECIMALS;
+
+const workingHoursFinding = (doc: ProseDocument, mismatch: WorkingHoursMismatch): Finding =>
+  finding(
+    doc,
+    mismatch.total.start,
+    {
+      start: written(doc, mismatch.start),
+      end: written(doc, mismatch.end),
+      break: written(doc, mismatch.break),
+      total: written(doc, mismatch.total),
+      expected: hoursOf(mismatch.expected),
+    },
+    "working-hours",
+  );
+
+/** 始業から終業まで、休憩を除いた時間が、書いた実働と合わない。 */
+const workingHoursOf = (doc: ProseDocument, text: string): Finding[] => {
+  const times = clockTimes(text).map((time) => ({ start: time.start, end: time.end, seconds: secondsOf(time.key) }));
+  const words = {
+    joiners: patternsOf(doc, "clock-range-joiner"),
+    dayShifts: marksOf(doc, "day-shift-mark"),
+    breaks: marksOf(doc, "working-hours-break"),
+    totals: marksOf(doc, "working-hours-total"),
+    approximate: marksOf(doc, "approximate-marker"),
+  };
+  return workingHoursMismatches(text, doc.source, sentencesOf(doc), times, lengthsOf(doc, text), words).map((mismatch) => workingHoursFinding(doc, mismatch));
+};
+
+/** 始まり + 期間 ≠ 終わり。泊数が二つの日付の差と合わない。「2泊3日」の日数が泊数より一つ多くない。 */
 export const durationMismatch: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
+  const dates = datesOf(doc.structure);
   const durations = durationsOf(doc, quantitiesOf(doc.structure, doc.source));
-  return durationMismatches(sentencesOf(doc), datesOf(doc.structure), durations).map((mismatch) => ({
-    rule: "duration-mismatch",
+  const proseAndTables = proseAndTablesOf(doc);
+  const nights = nightsOf(doc, proseAndTables);
+  const pairs = nightsDaysPairs(
+    doc.source,
+    nights,
+    durations.filter((duration) => duration.unit === "day"),
+    patternsOf(doc, "stay-pair-joiner"),
+  );
+  const pairedDays = spanIndex(pairs.map((pair) => pair.days));
+  const lengths = durationMismatches(
+    sentencesOf(doc),
+    dates,
+    durations.filter((duration) => !overlapsAny(pairedDays, duration)),
+  ).map((mismatch) =>
+    finding(doc, mismatch.end.start, {
+      start: written(doc, mismatch.start),
+      duration: written(doc, mismatch.duration),
+      end: written(doc, mismatch.end),
+      expected: mismatch.expected,
+    }),
+  );
+  const stays = [...stayNightsMismatches(sentencesOf(doc), dates, nights), ...tableNightsMismatches(proseAndTables, dates, stayColumnWords(doc))];
+  const nightsDays = nightsDaysMismatches(pairs).map((mismatch) =>
+    finding(doc, mismatch.days.start, { nights: written(doc, mismatch.nights), days: written(doc, mismatch.days), expected: mismatch.expected }, "nights-days"),
+  );
+  return [...lengths, ...stays.map((mismatch) => nightsFinding(doc, mismatch)), ...nightsDays, ...workingHoursOf(doc, proseAndTables)];
+};
+
+/** 番号の書き方（ordinal-frame）の頭の語のすぐ後ろの数。「第15回」は15番目の回で、15回ではない。 */
+const isOrdinal = (doc: ProseDocument, text: string, count: Span): boolean =>
+  patternsOf(doc, "ordinal-frame").some((frame) => {
+    const head = frame.split("{n}")[0] ?? "";
+    return head !== "" && text.slice(Math.max(0, count.start - head.length), count.start).toLowerCase() === head.toLowerCase();
+  });
+
+/** 回数 × 1回の長さが、書いた合計と合わない（90分×15回（計24時間））。 */
+export const durationProductMismatch: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  const counts = unitCountsOf(doc, text, patternsOf(doc, "session-count-unit")).filter((count) => !isOrdinal(doc, text, count));
+  const words = { totals: marksOf(doc, "session-total"), approximate: marksOf(doc, "approximate-marker") };
+  return sessionHoursMismatches(text, doc.source, sentencesOf(doc), counts, lengthsOf(doc, text), words).map((mismatch) => ({
+    rule: "duration-product-mismatch",
     severity: "warning",
     line: 0,
     column: 0,
-    quote: quoteAt(doc.source, mismatch.end.start),
+    quote: quoteAt(doc.source, mismatch.total.start),
     values: {
-      start: doc.source.slice(mismatch.start.start, mismatch.start.end),
-      duration: doc.source.slice(mismatch.duration.start, mismatch.duration.end),
-      end: doc.source.slice(mismatch.end.start, mismatch.end.end),
-      expected: mismatch.expected,
-      offset: mismatch.end.start,
+      count: written(doc, mismatch.count),
+      length: written(doc, mismatch.length),
+      total: written(doc, mismatch.total),
+      expected: hoursOf(mismatch.expected),
+      offset: mismatch.total.start,
     },
   }));
 };

package/src/detectors/document-shape.ts

@@ -86,6 +86,11 @@ const SENTENCES_INSIDE = /[。．！？](?=\s*\S)|\p{Ll}{2}[.!?]["'”’)]?\s+[
 
 export const isParagraphHeading = (heading: string): boolean => SENTENCES_INSIDE.test(heading.trim());
 
+/** A heading that asks a question: its length is the reader's question, not a name to shorten (FAQ, "Will this … increase …?"). */
+const QUESTION_END = /[?？]["'”’)）」』]*$/u;
+
+export const isQuestionHeading = (heading: string): boolean => QUESTION_END.test(heading.trim());
+
 /** The heading's words without a number label at its head (Chapter 2, 1.), from the section the heading opens. */
 const unlabeledOf = (doc: ProseDocument, heading: MarkupHeading): string =>
   doc.sections.find((section) => section.span.start === heading.end)?.unlabeledHeading ?? heading.text;
@@ -96,7 +101,7 @@ export const titleLength: Detector = (doc, options): Finding[] => {
   const title = headings.find((heading) => heading.depth === 1);
   return headings
     .map((heading) => ({ heading, words: unlabeledOf(doc, heading) }))
-    .filter(({ words }) => !isParagraphHeading(words))
+    .filter(({ words }) => !isParagraphHeading(words) && !isQuestionHeading(words))
     .map(({ heading, words }) => ({ heading, count: headingLength(words, doc.lengthUnit) }))
     .filter(({ count }) => count > options.limit)
     .map(({ heading, count }) => ({

package/src/detectors/due-date.ts

@@ -0,0 +1,47 @@
+// due-before-issue: the reading half. The issue-date and due-date words come from the language's lexicons
+// (issue-date-label, due-date-label, deadline-passed-word), and so do the words of minutes (minutes-title-word, meeting-date-label,
+// action-section-heading, earlier-section-word, action-due-label, item-done-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 { actionDueBeforeMeeting, type ActionWords } from "../structure/action-due.ts";
+import { dueBeforeIssue, type DueWords } from "../structure/due-date.ts";
+import type { StructureIssue } from "../structure/issues.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { datedPoints, quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+const wordsOf = (doc: ProseDocument): DueWords => ({
+  issue: patternsOf(doc, "issue-date-label"),
+  due: patternsOf(doc, "due-date-label"),
+  passed: patternsOf(doc, "deadline-passed-word"),
+});
+
+const actionWordsOf = (doc: ProseDocument): ActionWords => ({
+  meeting: patternsOf(doc, "meeting-date-label"),
+  section: patternsOf(doc, "action-section-heading"),
+  earlier: patternsOf(doc, "earlier-section-word"),
+  due: patternsOf(doc, "action-due-label"),
+  done: patternsOf(doc, "item-done-word"),
+  minutes: patternsOf(doc, "minutes-title-word"),
+});
+
+const findingOf = (doc: ProseDocument, issue: StructureIssue, variant?: string): Finding => ({
+  rule: "due-before-issue",
+  severity: "error",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, issue.offset),
+  values: { ...issue.values, offset: issue.offset },
+  ...(variant === undefined ? {} : { variant }),
+});
+
+export const dueDate: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const text = proseAndTablesOf(doc);
+  const dates = datedPoints(doc.structure);
+  return [
+    ...dueBeforeIssue(text, dates, wordsOf(doc)).map((issue) => findingOf(doc, issue)),
+    ...actionDueBeforeMeeting(text, dates, doc.markup?.headings ?? [], actionWordsOf(doc)).map((issue) => findingOf(doc, issue, "meeting")),
+  ];
+};

package/src/detectors/en-shape.ts

@@ -1,7 +1,8 @@
 import { lengthOf } from "../measure.ts";
 import { isClosed } from "../sentence-shape.ts";
 import { isTitleCase, minorityCase, pageTitleOf } from "./heading-case.ts";
-import type { Detector, Finding, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
+import type { Detector, Finding, Lexicon, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
+import { entryOpens } from "./lexicon-match.ts";
 
 const PER = 1000;
 
@@ -74,21 +75,36 @@ const firstWord = (sentence: Sentence): string =>
     .split(/\s+/u)[0]
     ?.replace(/[^A-Za-z]/gu, "") ?? "";
 
-/**
- * 接続詞で始まる文が続く。1 つなら効くが、続くと文が前の文の付け足しに見えて、
- * 何が主張なのかが分からなくなる。
- */
-export const conjunctionRun: Detector = (doc, options): Finding[] => {
-  const heads = new Set((options.lexicon ?? []).map((entry) => entry.pattern.toLowerCase()));
-  const runs = doc.sentences.filter(isClosed).reduce<Sentence[][]>(
+/** A head written as one Latin word ("And") is read off the first word; any other (しかし) off the tokens, since Japanese has no spaces. */
+const LATIN_WORD = /^[A-Za-z]+$/u;
+
+type Heads = { readonly latin: ReadonlySet<string>; readonly other: Lexicon };
+
+const headsOf = (lexicon: Lexicon): Heads => ({
+  latin: new Set(lexicon.filter((entry) => LATIN_WORD.test(entry.pattern)).map((entry) => entry.pattern.toLowerCase())),
+  other: lexicon.filter((entry) => !LATIN_WORD.test(entry.pattern)),
+});
+
+const opensWithHead = (sentence: Sentence, heads: Heads): boolean =>
+  heads.latin.has(firstWord(sentence).toLowerCase()) || (sentence.tokens !== undefined && heads.other.some((entry) => entryOpens(sentence, entry)));
+
+const headRuns = (sentences: readonly Sentence[], heads: Heads): Sentence[][] =>
+  sentences.filter(isClosed).reduce<Sentence[][]>(
     (acc, sentence) => {
       const last = acc.at(-1) ?? [];
-      if (!heads.has(firstWord(sentence).toLowerCase())) return [...acc.slice(0, -1), last, []];
+      if (!opensWithHead(sentence, heads)) return [...acc.slice(0, -1), last, []];
       return [...acc.slice(0, -1), [...last, sentence]];
     },
     [[]],
   );
-  return runs
+
+/**
+ * 接続詞で始まる文が続く。1 つなら効くが、続くと文が前の文の付け足しに見えて、
+ * 何が主張なのかが分からなくなる。
+ */
+export const conjunctionRun: Detector = (doc, options): Finding[] => {
+  const joiner = doc.lengthUnit === "char" ? "" : " ";
+  return headRuns(doc.sentences, headsOf(options.lexicon ?? []))
     .filter((run) => run.length > options.limit)
     .flatMap((run) => {
       const first = run[0];
@@ -100,7 +116,7 @@ export const conjunctionRun: Detector = (doc, options): Finding[] => {
               severity: "info" as const,
               line: 0,
               column: 0,
-              quote: run.map((sentence) => sentence.text.trim()).join(" "),
+              quote: run.map((sentence) => sentence.text.trim()).join(joiner),
               values: { count: run.length, limit: options.limit, offset: first.span.start },
             },
           ];

package/src/detectors/fact-consistency.ts

@@ -4,8 +4,10 @@ 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 { scopedFacts, type ScopedFact } from "../facts/fact-scope.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 { quoteAt } from "./structure-tree.ts";
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
@@ -15,6 +17,7 @@ export const factWordsOf = (doc: ProseDocument): FactWords => ({
   valueEnds: patternsOf(doc, "fact-value-end"),
   determiners: patternsOf(doc, "fact-label-drop"),
   vague: patternsOf(doc, "fact-label-vague"),
+  leads: patternsOf(doc, "fact-label-lead"),
   attributes: (doc.lexicons["fact-attribute"] ?? []).map((entry): AttributePhrase => ({ pattern: entry.pattern, position: entry.position ?? "before" })),
 });
 
@@ -65,6 +68,95 @@ const countedFactsOf = (doc: ProseDocument): ScopedFact[] => {
   return scopedFacts(countedFacts(doc.source, values, countedPhrasesOf(doc)), tree, doc.source, patternsOf(doc, "summary-heading"));
 };
 
+const wordsAt = (doc: ProseDocument, id: string): WordAt[] =>
+  (doc.lexicons[id] ?? []).map((entry): WordAt => ({ pattern: entry.pattern, position: entry.position ?? "before" }));
+
+const conditionsOf = (doc: ProseDocument, id: string): ConditionWord[] =>
+  (doc.lexicons[id] ?? []).map((entry): ConditionWord => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
+
+const changeWordsOf = (doc: ProseDocument): ChangeWords => ({
+  from: wordsAt(doc, "fact-change-from"),
+  to: wordsAt(doc, "fact-change-to"),
+  notChange: patternsOf(doc, "fact-change-not"),
+  subjectMarks: patternsOf(doc, "fact-change-subject-mark"),
+  joiners: wordsAt(doc, "fact-name-joiner"),
+  conditionsFrom: conditionsOf(doc, "fact-condition-from"),
+  conditionsTo: conditionsOf(doc, "fact-condition-to"),
+});
+
+const changeSentencesOf = (doc: ProseDocument, tree: StructureNode): ChangeSentence[] => {
+  const parts = partsAt(
+    doc.sentences.map((sentence) => sentence.span.start),
+    tree,
+    patternsOf(doc, "summary-heading"),
+  );
+  return doc.sentences.map((sentence, index) => ({
+    span: sentence.span,
+    text: sentence.text,
+    tokens: sentence.tokens ?? [],
+    summary: parts[index] !== "body",
+  }));
+};
+
+const ARROW = " → ";
+
+const pairFinding =
+  (doc: ProseDocument) =>
+  ({ summary, body }: PairConflict): Finding => ({
+    rule: "summary-fact-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, summary.from.start),
+    values: {
+      label: summary.subject,
+      value: [shown(doc, summary.from), shown(doc, summary.to)].join(ARROW),
+      other: [shown(doc, body.from), shown(doc, body.to)].join(ARROW),
+      offset: summary.from.start,
+    },
+  });
+
+/** 要約の「XからYに」が、本文が条件で分けて書いた同じ名前の二つの値と違う。 */
+const conditionPairFindings = (doc: ProseDocument): Finding[] => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const values = factValues(tree, doc.source, nameSpans(doc));
+  return conditionPairConflicts(doc.source, changeSentencesOf(doc, tree), values, changeWordsOf(doc)).map(pairFinding(doc));
+};
+
+const eventWordsOf = (doc: ProseDocument): EventWord[] =>
+  (doc.lexicons["fact-event"] ?? []).map((entry): EventWord => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
+
+const eventDateFinding =
+  (doc: ProseDocument) =>
+  ({ label, value, other }: EventDateConflict): Finding => ({
+    rule: "summary-fact-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, value.start),
+    values: { label, value: shown(doc, value), other: shown(doc, other), offset: value.start },
+  });
+
+/** 冒頭や要約の出来事の日付（11月9日から提供します）が、本文の同じ出来事の日付と違う。 */
+const eventDateFindings = (doc: ProseDocument): Finding[] => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const values = factValues(tree, doc.source, nameSpans(doc));
+  const dates = values.filter((value) => value.kind === "date");
+  const names = values.filter((value) => value.kind === "name");
+  const sentences = changeSentencesOf(doc, tree).map(({ span, text, summary }) => ({
+    ...span,
+    text,
+    summary,
+    names: names.filter((name) => span.start <= name.start && name.end <= span.end).map((name) => name.key),
+  }));
+  return eventDateConflicts(sentences, dates, eventWordsOf(doc)).map(eventDateFinding(doc));
+};
+
 /** 冒頭や要約の値が、本文の同じ名前の値と違う。 */
-export const summaryFactMismatch: Detector = (doc): Finding[] =>
-  summaryConflicts([...factsOf(doc), ...countedFactsOf(doc)]).map(findingOf("summary-fact-mismatch", doc));
+export const summaryFactMismatch: Detector = (doc): Finding[] => [
+  ...summaryConflicts([...factsOf(doc), ...countedFactsOf(doc)]).map(findingOf("summary-fact-mismatch", doc)),
+  ...conditionPairFindings(doc),
+  ...eventDateFindings(doc),
+];

package/src/detectors/heading-echo.ts

@@ -3,6 +3,7 @@ import { newContentMorphemes } from "./content-morphemes.ts";
 import { echoedHeadingUnits, trigrams } from "./heading-overlap.ts";
 import { titleTokens } from "../heading-label.ts";
 import { handsOver } from "./lead-in.ts";
+import { holdsLink, namesLocation } from "./location-pointer.ts";
 import { withoutQuotedVariants } from "./quoted-variant.ts";
 import type { Detector, Finding, LengthUnit, ProseDocument, Section } from "../plugin.ts";
 
@@ -55,6 +56,15 @@ const leadsIn = (doc: ProseDocument, section: Section, phrases: readonly string[
   return first !== undefined && handsOver(first.text, doc.source.slice(first.span.end, section.span.end), phrases);
 };
 
+/**
+ * 最初の文が、中身の置き場所（ページの外へのリンク・URL・コードで書いたファイルのパス）へ読者を渡している。
+ * 置き場所はコードやリンク先として本文から外れるので、残った文（The full reference is in .）は見出しの語だけに見える。
+ */
+const pointsElsewhere = (doc: ProseDocument, section: Section): boolean => {
+  const first = section.firstSentence;
+  return first !== undefined && (holdsLink(doc.source, first.span, doc.links) || namesLocation(doc.source.slice(first.span.start, first.span.end)));
+};
+
 /** 見出しとの重なりを測る文。用語集や表記の手引きは見出しの語の別の書き方を引用する（Not “datacentre”）ので、それは数えない。 */
 const echoedText = (section: Section): string => withoutQuotedVariants(section.firstSentence?.text ?? "", measuredHeading(section));
 
@@ -62,7 +72,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))
+    .filter((section) => !leadsIn(doc, section, leadIns) && !pointsElsewhere(doc, section))
     .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/kana-function-word.ts

@@ -0,0 +1,71 @@
+import type { Detector, Finding, Lexicon, LexiconEntry, Token } from "../plugin.ts";
+
+// A helper verb or formal noun written in kanji where a style writes it in kana (見て下さい → 見てください). The word
+// list says which words and how each is told apart from its main use (資料を下さい, 本を置く, 事が起きる); this file
+// reads that off the tagger's marks. Pure: the tokens and the word list come in.
+
+export type KanaSpelling = { readonly written: string; readonly preferred: string; readonly offset: number };
+
+const TE_FORM = new Set(["て", "で"]);
+
+const followsTeForm = (previous: Token | undefined): boolean => previous?.pos === "SCONJ" && TE_FORM.has(previous.surface);
+
+const isBound = (token: Token): boolean => token.features?.["Bound"] === "Yes";
+
+const isFormalNoun = (token: Token): boolean => token.features?.["NounType"] === "Dependent";
+
+const TOPIC = "は";
+const CASE_NI = "に";
+
+/** 〜時は and 〜時には: a condition. 〜時から, 〜時に (a point in time) are not. */
+const beforeTopic = (tokens: readonly Token[], index: number): boolean =>
+  tokens[index + 1]?.surface === TOPIC || (tokens[index + 1]?.surface === CASE_NI && tokens[index + 2]?.surface === TOPIC);
+
+/** Whether the word at index is used as the list's group says: a helper after て, a formal noun, a condition (〜時は, 〜時には). */
+const usedAsFunctionWord = (group: string | undefined, tokens: readonly Token[], index: number): boolean => {
+  const token = tokens[index];
+  if (token === undefined) return false;
+  if (group === "auxiliary") return isBound(token) || followsTeForm(tokens[index - 1]);
+  if (group === "after-te") return followsTeForm(tokens[index - 1]);
+  if (group === "formal-noun") return isFormalNoun(token);
+  if (group === "conditional") return isFormalNoun(token) && beforeTopic(tokens, index);
+  return false;
+};
+
+const KANJI = /^\p{Script=Han}+/u;
+
+/** The written word with its kanji stem in kana: 下さい with 下さる → くださる gives ください. Undefined when the entry or the word does not fit. */
+export const inKana = (written: string, entry: LexiconEntry): string | undefined => {
+  const stem = KANJI.exec(entry.pattern)?.[0];
+  const rewrite = entry.rewrite;
+  if (stem === undefined || rewrite === undefined || !written.startsWith(stem)) return undefined;
+  const okurigana = entry.pattern.slice(stem.length);
+  if (!rewrite.endsWith(okurigana)) return undefined;
+  return `${rewrite.slice(0, rewrite.length - okurigana.length)}${written.slice(stem.length)}`;
+};
+
+const entryFor = (token: Token, lexicon: Lexicon): LexiconEntry | undefined =>
+  lexicon.find((entry) => entry.pattern === token.lemma && token.surface.startsWith(entry.pattern.charAt(0)));
+
+/** Each word in the tokens that the word list writes in kana, used as its group says. */
+export const kanaSpellingsIn = (tokens: readonly Token[], lexicon: Lexicon): KanaSpelling[] =>
+  tokens.flatMap((token, index) => {
+    const entry = entryFor(token, lexicon);
+    if (entry === undefined || !usedAsFunctionWord(entry.group, tokens, index)) return [];
+    const preferred = inKana(token.surface, entry);
+    return preferred === undefined ? [] : [{ written: token.surface, preferred, offset: token.span.start }];
+  });
+
+export const kanaFunctionWord: Detector = (doc, options): Finding[] => {
+  const lexicon = options.lexicon ?? [];
+  const found = doc.sentences.flatMap((sentence) => kanaSpellingsIn(sentence.tokens ?? [], lexicon).map((spelling) => ({ sentence, spelling })));
+  if (found.length < options.limit) return [];
+  return found.map(({ sentence, spelling }) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: sentence.text.trim(),
+    values: { matched: spelling.written, preferred: spelling.preferred, offset: spelling.offset },
+  }));
+};

package/src/detectors/line-amount.ts

@@ -0,0 +1,33 @@
+// line-amount-mismatch: the reading half. The column names come from the language's lexicons (quantity-column,
+// unit-price-column, line-amount-column), the units from rate-unit and per-unit-mark; the tables are read from the prose with its tables put back, so code is not.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { lineAmountMismatches, type LineAmountWords } from "../structure/line-amount.ts";
+import type { UnitWord } from "../structure/line-amount-unit.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+const unitWordsOf = (doc: ProseDocument, ...lexicons: string[]): UnitWord[] =>
+  lexicons.flatMap((lexicon) =>
+    (doc.lexicons[lexicon] ?? []).flatMap((entry) => (entry.group === undefined ? [] : [{ pattern: entry.pattern, unit: entry.group }])),
+  );
+
+const wordsOf = (doc: ProseDocument): LineAmountWords => ({
+  quantity: patternsOf(doc, "quantity-column"),
+  unitPrice: patternsOf(doc, "unit-price-column"),
+  amount: patternsOf(doc, "line-amount-column"),
+  units: unitWordsOf(doc, "rate-unit"),
+  perUnitMarks: unitWordsOf(doc, "per-unit-mark"),
+  headerUnits: unitWordsOf(doc, "quantity-column", "unit-price-column"),
+});
+
+export const lineAmount: Detector = (doc): Finding[] =>
+  lineAmountMismatches(proseAndTablesOf(doc), wordsOf(doc)).map((issue) => ({
+    rule: "line-amount-mismatch",
+    severity: "error",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));

package/src/detectors/location-pointer.ts

@@ -0,0 +1,30 @@
+// Whether a sentence names where its content lives: a link, a web address, or a file in code. Pure.
+import { bareUrls } from "../bare-url.ts";
+import type { Span } from "../plugin.ts";
+
+/** A code span: a run of backticks, then the same run closing it, neither run touching another backtick. */
+const CODE_SPAN = /(?<!`)(`+)(?!`)(.+?)(?<!`)\1(?!`)/gsu;
+
+/** A link to a place on the same page (`[text](#id)`): the reader is already on that page. */
+const IN_PAGE_LINK = /\]\(\s*<?#[^)]*\)$/u;
+
+/** A page a reader opens, as a file name: README.md, guide.html, spec.pdf. A source file (main.go) names code, not a page. */
+const PAGE_FILE = /\.(?:md|markdown|mdx|txt|rst|adoc|html?|pdf)$/iu;
+
+const SEPARATOR = /[/\\]/u;
+const LETTER = /\p{L}/u;
+
+/** Code that is a path (docs/api.md, ./config, src\index) or a page file, not an identifier or an expression. */
+const isLocationCode = (code: string): boolean => {
+  const written = code.trim();
+  if (written.length === 0 || /\s/u.test(written) || !LETTER.test(written)) return false;
+  return SEPARATOR.test(written) || PAGE_FILE.test(written);
+};
+
+/** The sentence as written names a web address or, in code, a path or a page file. */
+export const namesLocation = (written: string): boolean =>
+  bareUrls(written).length > 0 || [...written.matchAll(CODE_SPAN)].some((match) => isLocationCode(match[2] ?? ""));
+
+/** One of the links written in the sentence's span leads off the page. */
+export const holdsLink = (source: string, sentence: Span, links: readonly Span[]): boolean =>
+  links.some((link) => link.start < sentence.end && link.end > sentence.start && !IN_PAGE_LINK.test(source.slice(link.start, link.end)));