chaffjs 0.28.0 → 0.29.0

package/src/detectors/defined-term-form.ts

@@ -5,6 +5,8 @@ import { definedTerms, usesOf, type BodyText, type DefinedTerm } from "../struct
 import { escapeRegExp } from "../orthography.ts";
 import { prefixGroupsOf, prefixVariants, variantUses } from "../structure/term-prefix.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { isPartOfAddress } from "./address-word.ts";
+import { exactOffsets, extendedAfter, extendedBefore } from "./term-extension.ts";
 import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 
 const bodyOf = (doc: ProseDocument): BodyText[] => doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text }));
@@ -50,17 +52,32 @@ export const quotedUses = (source: string, term: string, uses: readonly number[]
   });
 
 const UPPER_START = /^\p{Lu}/u;
+/** The capital that starts each later word of a term (the O of Records Officer). */
+const INNER_CAPITAL = /(?<=\s)\p{Lu}/gu;
+
+const innerCapitals = (term: string): number[] => [...term.matchAll(INNER_CAPITAL)].map((match) => match.index);
+
+/** Whether the letter at position at of the term is written in lower case at this use. */
+const isLowered = (source: string, term: string, offset: number, at: number): boolean => source.charAt(offset + at) === term.charAt(at).toLowerCase();
+
+/** The term with the capitals of its later words in lower case (Records officer), whose uses the term's own form does not find. */
+export const innerLowered = (term: string): string => term.replace(INNER_CAPITAL, (capital) => capital.toLowerCase());
 
 /**
- * The uses of a capitalised term written in lower case ("services" where "Services" is defined), when they are the fewer
- * and at most limit: a document that mostly writes it in lower case uses the word in its ordinary sense on purpose.
+ * The uses of a capitalised term written in lower case ("services" where "Services" is defined, "records officer" where
+ * "Records Officer" is), when they are no more than the capitalised uses and at most limit: a document that writes it in
+ * lower case more often uses the word in its ordinary sense on purpose. One of each is a slip to point at (the Software,
+ * then the software).
  */
 export const lowerCaseUses = (source: string, term: string, uses: readonly number[], definedAt: number, limit: number): number[] => {
   if (!UPPER_START.test(term) || term.toLowerCase() === term) return [];
-  const later = uses.filter((offset) => offset > definedAt);
-  const lower = later.filter((offset) => source.charAt(offset) === term.charAt(0).toLowerCase() && !isSentenceStart(source, offset));
-  const capital = later.filter((offset) => source.charAt(offset) === term.charAt(0));
-  return lower.length > 0 && lower.length < capital.length && lower.length <= limit ? lower : [];
+  const inner = innerCapitals(term);
+  // An address (support@pinecone.example) spells the name as the address must be, in either case; it is not a use.
+  const later = uses.filter((offset) => offset > definedAt && !isPartOfAddress(source, offset, offset + term.length));
+  const innerLower = (offset: number): boolean => inner.some((at) => isLowered(source, term, offset, at));
+  const lower = later.filter((offset) => (isLowered(source, term, offset, 0) && !isSentenceStart(source, offset)) || innerLower(offset));
+  const capital = later.filter((offset) => source.charAt(offset) === term.charAt(0) && !innerLower(offset));
+  return lower.length > 0 && lower.length <= capital.length && lower.length <= limit ? lower : [];
 };
 
 /** How far back a sentence's start is looked for: past a few spaces to the mark before them. */
@@ -74,16 +91,22 @@ const isSentenceStart = (source: string, offset: number): boolean => {
   return (offset < LOOK_BACK && text === "") || before.slice(text.length).includes("\n") || SENTENCE_END.has(text.at(-1) ?? "");
 };
 
+const definingSentence = (doc: ProseDocument, definition: Span): Sentence | undefined =>
+  doc.sentences.find((sentence) => sentence.span.start <= definition.start && definition.start < sentence.span.end);
+
 /** Where the sentence holding the definition ends: a use inside it ("Customer" means the party named "Customer") belongs to the definition. */
-const definingSentenceEnd = (doc: ProseDocument, definition: Span): number =>
-  doc.sentences.find((sentence) => sentence.span.start <= definition.start && definition.start < sentence.span.end)?.span.end ?? definition.end;
+const definingSentenceEnd = (doc: ProseDocument, definition: Span): number => definingSentence(doc, definition)?.span.end ?? definition.end;
 
 const VERBAL = new Set(["VERB", "AUX"]);
 
+const tokensAt = (doc: ProseDocument, offset: number): { readonly tokens: readonly Token[]; readonly at: number } => {
+  const tokens = doc.sentences.find((candidate) => candidate.span.start <= offset && offset < candidate.span.end)?.tokens ?? [];
+  return { tokens, at: tokens.findIndex((candidate) => candidate.span.start <= offset && offset < candidate.span.end) };
+};
+
 /** A word used as a verb ("you input"), not the defined thing ("the Input"): a different word that shares the spelling. */
 const isVerbAt = (doc: ProseDocument, offset: number): boolean => {
-  const tokens = doc.sentences.find((candidate) => candidate.span.start <= offset && offset < candidate.span.end)?.tokens ?? [];
-  const at = tokens.findIndex((candidate) => candidate.span.start <= offset && offset < candidate.span.end);
+  const { tokens, at } = tokensAt(doc, offset);
   const token = tokens[at];
   if (token === undefined) return false;
   // After a subject pronoun the word is its verb (you input), whatever the tagger says; after a possessive (your input) it is a noun.
@@ -92,6 +115,26 @@ const isVerbAt = (doc: ProseDocument, offset: number): boolean => {
   return VERBAL.has(token.pos) || afterSubject;
 };
 
+const NAMING = new Set(["NOUN", "PROPN"]);
+
+/**
+ * A lower-case phrase that starts with a noun and has no adjective before it (the records officer) names the defined thing.
+ * One that starts with an adjective or a possessive (its own confidential information, your content), or that an
+ * adjective narrows (additional terms of service), is the ordinary phrase.
+ */
+const isNamingAt = (doc: ProseDocument, offset: number): boolean => {
+  const { tokens, at } = tokensAt(doc, offset);
+  return NAMING.has(tokens[at]?.pos ?? "") && tokens[at - 1]?.pos !== "ADJ";
+};
+
+/** The uses of the term, with those that write its later words in lower case (records officer for Records Officer), in order. */
+const withLoweredWords = (doc: ProseDocument, term: string, texts: readonly BodyText[], spans: readonly Span[], uses: readonly number[]): number[] => {
+  const lowered = innerLowered(term);
+  if (lowered === term) return [...uses];
+  const more = usesOf(lowered, texts, spans, "loose").filter((offset) => !uses.includes(offset) && isNamingAt(doc, offset));
+  return [...uses, ...more].toSorted((left, right) => left - right);
+};
+
 /** The term written with another prefix of its group (本件業務 where 本業務 is defined), after the sentence that defines it. */
 const prefixFindings = (doc: ProseDocument, texts: readonly BodyText[], term: DefinedTerm, definingEnd: number, defined: readonly string[]): Finding[] =>
   prefixVariants(term.term, prefixGroupsOf(doc.lexicons["defined-term-prefix"] ?? [])).flatMap((variant) =>
@@ -102,6 +145,33 @@ const prefixFindings = (doc: ProseDocument, texts: readonly BodyText[], term: De
         ),
   );
 
+/** The term set in quotes again, unless the document's profile says a quoted term is the term mentioned (「株主」とあるのは). */
+const quotedFindings = (doc: ProseDocument, term: DefinedTerm, uses: readonly number[], definingEnd: number): Finding[] =>
+  doc.profile?.quoteMentionsTerm === true
+    ? []
+    : quotedUses(doc.source, term.term, uses, definingEnd).map((offset) =>
+        finding(doc, "defined-term-form", offset, "quoted", { term: term.term, line: term.line }),
+      );
+
+/** The term written longer with a word of its definition (文書管理責任者, the Application), after the sentence that defines it. */
+const extendedFindings = (doc: ProseDocument, texts: readonly BodyText[], term: DefinedTerm, spans: readonly Span[], defined: readonly string[]): Finding[] => {
+  const definition = definingSentence(doc, term.span)?.text ?? "";
+  const pointers = (doc.lexicons["defined-term-pointer"] ?? []).map((entry) => entry.pattern);
+  // Every sentence that defines the term (a second definition too) holds the long words it is defined from.
+  const defining = spans.map((span) => definingSentence(doc, span)?.span ?? span);
+  const definingEnd = definingSentenceEnd(doc, term.span);
+  return texts
+    .flatMap((text) => exactOffsets(text.text, text.start, term.term))
+    .filter((offset) => offset > definingEnd && !defining.some((span) => span.start <= offset && offset < span.end))
+    .flatMap((offset) => {
+      const before = extendedBefore(doc.source, offset, term.term, definition, pointers);
+      const written = before ?? (isSentenceStart(doc.source, offset) ? undefined : extendedAfter(doc.source, offset, term.term, definition));
+      if (written === undefined || defined.includes(written)) return [];
+      const start = before === undefined ? offset : offset + term.term.length - written.length;
+      return [finding(doc, "defined-term-form", start, "extended", { term: term.term, written, line: term.line })];
+    });
+};
+
 export const definedTermForm: Detector = (doc, options): Finding[] => {
   if (doc.structure === undefined) return [];
   const texts = bodyOf(doc);
@@ -110,14 +180,13 @@ export const definedTermForm: Detector = (doc, options): Finding[] => {
   return firstDefinitions(terms).flatMap(({ term, spans }) => {
     const uses = usesOf(term.term, texts, spans, "loose");
     const definingEnd = definingSentenceEnd(doc, term.span);
-    const quoted = quotedUses(doc.source, term.term, uses, definingEnd).map((offset) =>
-      finding(doc, "defined-term-form", offset, "quoted", { term: term.term, line: term.line }),
-    );
-    const nounUses = uses.filter((offset) => !isVerbAt(doc, offset));
+    const quoted = quotedFindings(doc, term, uses, definingEnd);
+    const caseUses = withLoweredWords(doc, term.term, texts, spans, uses);
+    const nounUses = caseUses.filter((offset) => !isVerbAt(doc, offset));
     const lower = lowerCaseUses(doc.source, term.term, nounUses, definingEnd, options.limit).map((offset) =>
       finding(doc, "defined-term-form", offset, "case", { term: term.term, line: term.line }),
     );
-    return [...quoted, ...lower, ...prefixFindings(doc, texts, term, definingEnd, defined)];
+    return [...quoted, ...lower, ...prefixFindings(doc, texts, term, definingEnd, defined), ...extendedFindings(doc, texts, term, spans, defined)];
   });
 };
 

package/src/detectors/definition-use.ts

@@ -1,5 +1,6 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
-import { definedTerms, unusedDefinitions, usesBeforeDefinition, type BodyText, type Mentioned } from "../structure/definition-use.ts";
+import { definedTerms, unusedDefinitions, usesBeforeDefinition, type BodyText, type IsTitle, type Mentioned } from "../structure/definition-use.ts";
+import { titleLineNumbers } from "../structure/title-lines.ts";
 import { expansionConflicts, expansionsIn } from "../acronym-expansions.ts";
 import { linesOf, lineNumberAt } from "../structure/lines.ts";
 import { isQuotedAlone } from "../quoted-span.ts";
@@ -29,11 +30,18 @@ export const unusedDefinition: Detector = (doc): Finding[] =>
         findingAt(doc, defined.span.start, { term: defined.term }),
       );
 
+/** 題・見出し（Markdown の見出し、章・節の行、条の前の見出しの行）の上の位置か。 */
+const titleIn = (doc: ProseDocument): IsTitle => {
+  const lines = linesOf(doc.source);
+  const numbers = titleLineNumbers(doc.structure, lines, doc.markup?.headings ?? []);
+  return (offset) => numbers.has(lineNumberAt(lines, offset) ?? 0);
+};
+
 /** 文の途中で括弧に入れて定義した語を、定義より前で使っている所。 */
 export const useBeforeDefinition: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc)).map((use) =>
+    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc), titleIn(doc)).map((use) =>
         findingAt(doc, use.offset, { term: use.term.term, defined: use.term.line }),
       );
 

package/src/detectors/deprecated-use.ts

@@ -0,0 +1,17 @@
+// deprecated-option-used: a name the document calls deprecated, still used in one of its code examples
+// (deprecated-use.ts). The words come from the deprecation-word and deprecation-negated lexicons.
+import { quoteAt } from "./structure-tree.ts";
+import { deprecatedUses } from "../deprecated-use.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+const lowercase = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern.toLowerCase());
+
+export const deprecatedUse: Detector = (doc): Finding[] =>
+  deprecatedUses(doc.source, { words: lowercase(doc, "deprecation-word"), negated: lowercase(doc, "deprecation-negated") }).map((use) => ({
+    rule: "deprecated-option-used",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, use.offset),
+    values: { name: use.name, offset: use.offset },
+  }));

package/src/detectors/derived-numbers.ts

@@ -6,6 +6,17 @@ 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 { escapeRegExp } from "../orthography.ts";
+import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAt } from "./structure-tree.ts";
 
 /** 期間の単位の語彙表。木の数量の単位がどれかに入れば、その単位の期間。 */
@@ -29,11 +40,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,24 +93,87 @@ const durationsOf = (doc: ProseDocument, quantities: readonly Quantity[]): Durat
 
 const sentencesOf = (doc: ProseDocument): Span[] => doc.sentences.map((sentence) => sentence.span);
 
-/** 始まり + 期間 ≠ 終わり。 */
+const LATIN_UNIT = /^[a-z]+$/iu;
+
+/** 数字と泊数の単位（3泊、3 nights）。英字の単位は語の切れ目まで。 */
+const digitNights = (text: string, units: readonly string[]): Count[] =>
+  units.flatMap((unit) => {
+    const tail = LATIN_UNIT.test(unit) ? "(?![\\p{L}\\p{N}])" : "";
+    const pattern = new RegExp(`(?<![\\p{N}.,])(\\p{Nd}+)\\s?${escapeRegExp(unit)}${tail}`, "giu");
+    return [...text.matchAll(pattern)].map((match) => ({
+      start: match.index,
+      end: match.index + match[0].length,
+      amount: Number((match[1] ?? "").normalize("NFKC")),
+    }));
+  });
+
+/** 泊数（3泊、3 nights、three nights）。text は地の文と表（リンク先や code は読まない）。目安の泊数（最大3泊）は除く。 */
+const nightsOf = (doc: ProseDocument, text: string): Count[] => {
+  const units = patternsOf(doc, "stay-night");
+  const digits = digitNights(text, units);
+  const taken = spanIndex(digits);
+  const worded = numberWordCounts(text, patternsOf(doc, "count-number"), units).filter((count) => !overlapsAny(taken, count));
+  return [...digits, ...worded].filter((count) => !isApproximate(doc, count)).toSorted((left, right) => left.start - right.start);
+};
+
+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"),
+});
+
+/** 始まり + 期間 ≠ 終わり。泊数が二つの日付の差と合わない。「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",
-    severity: "warning",
-    line: 0,
-    column: 0,
-    quote: quoteAt(doc.source, mismatch.end.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),
+  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,
-      offset: mismatch.end.start,
-    },
-  }));
+    }),
+  );
+  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];
 };
 
 /** 四桁の年。木が日付と読まなかった英語の年（founded in 2015、born 1980）もここで読む。 */

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 }) => ({