chaffjs 0.29.0 → 0.31.0

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

@@ -23,8 +23,8 @@ const finding = (doc: ProseDocument, rule: string, offset: number, variant: stri
 
 const OPENING_QUOTES = new Set(["「", "『", '"', "“"]);
 const CLOSING_QUOTES = new Set(["」", "』", '"', "”"]);
-/** A quoted term right before these is defined again (「X」とは, "X" means), which duplicate-definition reads. */
-const DEFINING_AFTER = /^(?:とは|という|\s+(?:means|shall mean|refers to|has the meaning))/u;
+/** A quoted term right before these is defined again (「X」とは, 「X」といいます, "X" means), which duplicate-definition reads. */
+const DEFINING_AFTER = /^(?:とは|という|といい(?:ます)?(?=[。、，）)\s]|$)|\s+(?:means|shall mean|refers to|has the meaning))/u;
 /** The ending a use may carry past the term: a plural or a possessive (Services, Service's). */
 const WORD_ENDING = /^(?:e?s|['’]s?)/u;
 
@@ -238,14 +238,69 @@ const bracketBefore = (source: string, definition: Span): number => {
 
 export type RepeatedName = { readonly offset: number; readonly name: string; readonly term: string; readonly line: number };
 
-/** A line that holds the short name too (甲 株式会社みなと) or little else than the long name: a signature block names both. */
-const isNameLine = (source: string, offset: number, name: string, term: string): boolean => {
+/** How many characters a line may add to the long name and still be a line that only names the party. */
+const SLACK = 12;
+
+/** A field label on its own line, after a list marker (Attention:, 宛先：): short, and not a sentence. */
+const FIELD_LABEL = /^(?:[-*+]\s+)?[^:：。.]{1,20}[:：]\s*/u;
+/**
+ * What may follow the name in an address field: nothing, a comma and the next part (, Member Support), or a space and a part
+ * that does not go on in lower case (株式会社みなと 総務部). A particle or a verb (は支払う, shall pay) makes the line a sentence.
+ */
+const NEXT_PART = /^\.?(?:$|\s*[,、，]|\s+(?!\p{Ll}))/u;
+const CLOSES_SENTENCE = /[.。!?！？]$/u;
+
+/** A field whose value is the name and a little more, not a sentence (Attention: Hibari Lab Inc., Member Support). */
+const isNameField = (line: string, name: string): boolean => {
+  const label = FIELD_LABEL.exec(line);
+  const value = label === null ? "" : line.slice(label[0].length);
+  const rest = value.slice(name.length);
+  return value.startsWith(name) && NEXT_PART.test(rest) && [...rest].length <= SLACK * 2 && !CLOSES_SENTENCE.test(rest.slice(1));
+};
+
+/** A contact field's label: after a bullet or a number (1. 連絡先：), and as long as a label in English runs (Privacy Contact:). */
+const CONTACT_LABEL = /^(?:(?:[-*+]|\d+[.)])\s+)?([^:：。.]{1,40})[:：]\s*/u;
+const LABEL_MARKS = /[*_\s]+/gu;
+/** After the name in a contact field, the next part after a space or a comma (, Tokyo), or the bracket that holds it (お問い合わせ窓口（株式会社みなと）). */
+const NEXT_CONTACT_PART = /^\.?(?:$|[）)]|\s*,?\s+(?!\p{Ll}))/u;
+/** A comma that goes on in lower case or 、 may also start a clause (, which may; 株式会社みなと、平日に受け付ける): the address field's bound. */
+const COMMA_PART = /^\.?\s*[,、，]/u;
+
+const endsWithContactLabel = (label: string, contactLabels: readonly string[]): boolean => {
+  const bare = label.replaceAll(LABEL_MARKS, "").toLowerCase();
+  return contactLabels.some((contact) => contact !== "" && bare.endsWith(contact.toLowerCase()));
+};
+
+/**
+ * A field whose label ends with a contact label (窓口：, Attention:): the value names the party in full however long it is and
+ * wherever the name sits in it, unless the name goes on as a sentence (連絡先：株式会社みなとは、…).
+ */
+const isContactField = (line: string, name: string, contactLabels: readonly string[]): boolean => {
+  const label = CONTACT_LABEL.exec(line);
+  if (label === null || !endsWithContactLabel(label[1] ?? "", contactLabels)) return false;
+  const value = line.slice(label[0].length);
+  const at = value.indexOf(name);
+  if (at === -1) return false;
+  const rest = value.slice(at + name.length);
+  const continues = NEXT_CONTACT_PART.test(rest) || (COMMA_PART.test(rest) && [...rest].length <= SLACK * 2);
+  return continues && !CLOSES_SENTENCE.test(rest.slice(1));
+};
+
+/**
+ * A line that holds the short name too (甲 株式会社みなと), little else than the long name (a signature block names both),
+ * or a field whose value is the name (Attention: …, 宛先：…): an address gives the name in full.
+ */
+const isNameLine = (source: string, offset: number, name: string, term: string, contactLabels: readonly string[]): boolean => {
   const start = source.lastIndexOf("\n", offset - 1) + 1;
   const end = source.indexOf("\n", offset);
   const line = source.slice(start, end === -1 ? source.length : end).trim();
-  const SLACK = 12;
   // The short name inside the long one ("Pinecone" in "Pinecone Software Ltd") is not the short name written beside it.
-  return line.replaceAll(name, "").includes(term) || [...line].length <= [...name].length + SLACK;
+  return (
+    line.replaceAll(name, "").includes(term) ||
+    [...line].length <= [...name].length + SLACK ||
+    isNameField(line, name) ||
+    isContactField(line, name, contactLabels)
+  );
 };
 
 /** A name inside a longer word (東京大学 in 東京大学大学院, Acme in Acmeware) is part of another name. */
@@ -267,6 +322,7 @@ export const standsAlone = (source: string, offset: number, name: string, joiner
 export const repeatedNames = (doc: ProseDocument, terms: readonly DefinedTerm[]): RepeatedName[] => {
   const defined = new Set(terms.map((term) => term.term));
   const joiners = (doc.lexicons["enumeration-joiner"] ?? []).map((entry) => entry.pattern);
+  const contactLabels = (doc.lexicons["contact-label"] ?? []).map((entry) => entry.pattern);
   return terms
     .filter((term) => term.inline)
     .flatMap((term) => {
@@ -278,7 +334,7 @@ export const repeatedNames = (doc: ProseDocument, terms: readonly DefinedTerm[])
       return doc.sentences
         .filter((later) => later.span.start > term.span.end)
         .flatMap((later) => [...later.text.matchAll(pattern)].map((match) => later.span.start + match.index))
-        .filter((offset) => standsAlone(doc.source, offset, name, joiners) && !isNameLine(doc.source, offset, name, term.term))
+        .filter((offset) => standsAlone(doc.source, offset, name, joiners) && !isNameLine(doc.source, offset, name, term.term, contactLabels))
         .map((offset) => ({ offset, name, term: term.term, line: term.line }));
     });
 };

package/src/detectors/definition-use.ts

@@ -22,11 +22,15 @@ const findingAt = (doc: ProseDocument, offset: number, values: Readonly<Record<s
   values: { ...values, offset },
 });
 
-/** 定義したのに、定義の外で一度も使っていない語。 */
+/** Markdown の見出し。文には入らないが、見出しで語を使っても、その語は文書で使われている。 */
+const headingsOf = (doc: ProseDocument): BodyText[] =>
+  (doc.markup?.headings ?? []).map((heading) => ({ start: heading.start, text: doc.source.slice(heading.start, heading.end) }));
+
+/** 定義したのに、定義の外（文と見出し）で一度も使っていない語。 */
 export const unusedDefinition: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : unusedDefinitions(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc)).map((defined) =>
+    : unusedDefinitions(definedTerms(doc.structure), [...bodyOf(doc), ...headingsOf(doc)], mentionedIn(doc)).map((defined) =>
         findingAt(doc, defined.span.start, { term: defined.term }),
       );
 

package/src/detectors/derived-numbers.ts

@@ -15,19 +15,24 @@ import {
   type NightsMismatch,
   type StayColumnWords,
 } from "../derived/stays.ts";
-import { escapeRegExp } from "../orthography.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";
 
 /** 期間の単位の語彙表。木の数量の単位がどれかに入れば、その単位の期間。 */
-const DURATION_LEXICONS: readonly (readonly [string, DurationUnit])[] = [
+export const DURATION_LEXICONS: readonly (readonly [string, DurationUnit])[] = [
   ["duration-day", "day"],
   ["duration-week", "week"],
   ["duration-month", "month"],
   ["duration-year", "year"],
 ];
 
-type Quantity = Span & { readonly amount: number; readonly unit: string };
+export type Quantity = Span & { readonly amount: number; readonly unit: string };
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
@@ -57,7 +62,7 @@ const withWordsAround = (source: string, start: number, end: number, unit: strin
   return wordStart === undefined ? { start, end: endWithUnit(source, end, unit) } : { start: wordStart, end: endWithUnit(source, end + 1, unit) };
 };
 
-const quantitiesOf = (tree: StructureNode, source: string): Quantity[] =>
+export const quantitiesOf = (tree: StructureNode, source: string): Quantity[] =>
   inDocumentOrder(tree).flatMap((node): Quantity[] => {
     if (node.kind !== "quantity") return [];
     const unit = String(node.attrs["unit"] ?? "");
@@ -93,29 +98,18 @@ 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);
+/** 数と単位（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 [...digits, ...worded].filter((count) => !isApproximate(doc, count)).toSorted((left, right) => left.start - right.start);
+  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",
@@ -143,6 +137,57 @@ const stayColumnWords = (doc: ProseDocument): StayColumnWords => ({
   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 [];
@@ -173,7 +218,35 @@ export const durationMismatch: Detector = (doc): Finding[] => {
   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];
+  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.total.start),
+    values: {
+      count: written(doc, mismatch.count),
+      length: written(doc, mismatch.length),
+      total: written(doc, mismatch.total),
+      expected: hoursOf(mismatch.expected),
+      offset: mismatch.total.start,
+    },
+  }));
 };
 
 /** 四桁の年。木が日付と読まなかった英語の年（founded in 2015、born 1980）もここで読む。 */

package/src/detectors/due-date.ts

@@ -1,14 +1,18 @@
 // 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.
+// action-section-heading, earlier-section-word, action-due-label, item-done-word) and the other pairs of dates that must come in
+// order (dated-pair-label, date-now-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 { pairedDatesOutOfOrder } from "../structure/labelled-date-order.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";
 
+/** A record's facts table can sit well below its header date (a listing date above the table holding the move-in date). */
+const MAX_RECORD_LINE_GAP = 40;
+
 const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
 
 const wordsOf = (doc: ProseDocument): DueWords => ({
@@ -26,6 +30,8 @@ const actionWordsOf = (doc: ProseDocument): ActionWords => ({
   minutes: patternsOf(doc, "minutes-title-word"),
 });
 
+const orderAsidesOf = (doc: ProseDocument): string[] => [...patternsOf(doc, "deadline-passed-word"), ...patternsOf(doc, "date-now-word")];
+
 const findingOf = (doc: ProseDocument, issue: StructureIssue, variant?: string): Finding => ({
   rule: "due-before-issue",
   severity: "error",
@@ -40,8 +46,10 @@ export const dueDate: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
   const text = proseAndTablesOf(doc);
   const dates = datedPoints(doc.structure);
+  const pairs = doc.lexicons["dated-pair-label"] ?? [];
   return [
     ...dueBeforeIssue(text, dates, wordsOf(doc)).map((issue) => findingOf(doc, issue)),
+    ...pairedDatesOutOfOrder(text, dates, pairs, orderAsidesOf(doc), MAX_RECORD_LINE_GAP).map((issue) => findingOf(doc, issue, "order")),
     ...actionDueBeforeMeeting(text, dates, doc.markup?.headings ?? [], actionWordsOf(doc)).map((issue) => findingOf(doc, issue, "meeting")),
   ];
 };

package/src/detectors/en-shape.ts

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

package/src/detectors/event-deadline.ts

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

package/src/detectors/fact-consistency.ts

@@ -8,7 +8,11 @@ import { partsAt, scopedFacts, type ScopedFact } from "../facts/fact-scope.ts";
 import { conditionPairConflicts, type ChangeSentence, type ChangeWords, type ConditionWord, type PairConflict, type WordAt } from "../facts/condition-pairs.ts";
 import { scopeConflicts, summaryConflicts, type FactConflict } from "../facts/fact-conflicts.ts";
 import { eventDateConflicts, type EventDateConflict, type EventWord } from "../facts/event-dates.ts";
+import { retentionConflicts, type LengthMark, type RetentionLength, type RetentionVerb, type RetentionWords } from "../facts/retention-periods.ts";
+import type { DurationUnit } from "../derived/date-arithmetic.ts";
+import { DURATION_LEXICONS, quantitiesOf, type Quantity } from "./derived-numbers.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { measuredOf, valuesWith } from "./measured-facts.ts";
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
@@ -23,8 +27,9 @@ export const factWordsOf = (doc: ProseDocument): FactWords => ({
 
 const factsByDocument = new WeakMap<ProseDocument, readonly ScopedFact[]>();
 
+/** 単位の語彙表の量（410 g、1.2 kg）も値として読む。木が単位を読まない量は、数だけでは升や文の値にならない。 */
 const readFacts = (doc: ProseDocument, tree: StructureNode): ScopedFact[] => {
-  const values = factValues(tree, doc.source, nameSpans(doc));
+  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"));
 };
@@ -51,8 +56,64 @@ const findingOf =
     values: { label: conflict.fact.label, value: shown(doc, conflict.fact.value), other: shown(doc, conflict.other), offset: conflict.fact.value.start },
   });
 
-/** 同じ節で、同じ名前に二通りの値（締切：10月5日 と 締切：10月7日）。 */
-export const factConflict: Detector = (doc): Finding[] => scopeConflicts(factsOf(doc)).map(findingOf("fact-conflict", doc));
+const UNITS: readonly DurationUnit[] = ["day", "week", "month", "year"];
+
+const isDurationUnit = (group: string | undefined): group is DurationUnit => UNITS.some((unit) => unit === group);
+
+const retentionUnitOf = (doc: ProseDocument, unit: string): DurationUnit | undefined => {
+  const listed = DURATION_LEXICONS.find(([id]) => patternsOf(doc, id).some((pattern) => pattern.normalize("NFKC") === unit))?.[1];
+  const extra = (doc.lexicons["retention-unit"] ?? []).find((entry) => entry.pattern.normalize("NFKC") === unit)?.group;
+  return listed ?? (isDurationUnit(extra) ? extra : undefined);
+};
+
+/** 単位の語彙表に、書いた単位より長い形（か月 に対する か月間）があれば、そこまで。木の数量は か月 で終わる。 */
+const endWithLongerUnit = (doc: ProseDocument, quantity: Quantity): number => {
+  const unitStart = quantity.end - quantity.unit.length;
+  const longer = DURATION_LEXICONS.flatMap(([id]) => patternsOf(doc, id))
+    .filter((pattern) => pattern.length > quantity.unit.length && pattern.startsWith(quantity.unit) && doc.source.startsWith(pattern, unitStart))
+    .reduce((longest, pattern) => Math.max(longest, pattern.length), quantity.unit.length);
+  return unitStart + longer;
+};
+
+const retentionLengthsOf = (doc: ProseDocument, tree: StructureNode): RetentionLength[] =>
+  quantitiesOf(tree, doc.source).flatMap((quantity) => {
+    const unit = retentionUnitOf(doc, quantity.unit);
+    return unit === undefined ? [] : [{ start: quantity.start, end: endWithLongerUnit(doc, quantity), amount: quantity.amount, unit }];
+  });
+
+const retentionVerbsOf = (doc: ProseDocument): RetentionVerb[] =>
+  (doc.lexicons["retention-verb"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? "", position: entry.position ?? "before" }));
+
+const lengthMarksOf = (doc: ProseDocument): LengthMark[] =>
+  (doc.lexicons["retention-length-mark"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? "", position: entry.position ?? "before" }));
+
+const retentionWordsOf = (doc: ProseDocument): RetentionWords => ({
+  verbs: retentionVerbsOf(doc),
+  marks: lengthMarksOf(doc),
+  modifiers: patternsOf(doc, "retention-length-modifier"),
+  bounds: [...wordsAt(doc, "approximate-marker"), ...wordsAt(doc, "retention-bound")],
+  joiners: patternsOf(doc, "fact-name-joiner"),
+  objectMarks: patternsOf(doc, "retention-object-mark"),
+});
+
+/** 文書のどこかで、同じものの保存期間が二通り（1年間保存 と 3年間を経過したら削除）。 */
+const retentionFindings = (doc: ProseDocument): Finding[] => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const sentences = doc.sentences.map((sentence) => ({ ...sentence.span, tokens: sentence.tokens ?? [] }));
+  return retentionConflicts(doc.source, sentences, retentionLengthsOf(doc, tree), retentionWordsOf(doc)).map(({ object, value, other }): Finding => ({
+    rule: "fact-conflict",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, value.start),
+    variant: "retention",
+    values: { label: object, value: doc.source.slice(value.start, value.end), other: doc.source.slice(other.start, other.end), offset: value.start },
+  }));
+};
+
+/** 同じ節で、同じ名前に二通りの値（締切：10月5日 と 締切：10月7日）。文書のどこでも、同じものに二通りの保存期間。 */
+export const factConflict: Detector = (doc): Finding[] => [...scopeConflicts(factsOf(doc)).map(findingOf("fact-conflict", doc)), ...retentionFindings(doc)];
 
 const countedPhrasesOf = (doc: ProseDocument): CountedPhrase[] =>
   doc.sentences.flatMap((sentence) => {

package/src/detectors/heading-case.ts

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

package/src/detectors/heading-echo.ts

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