chaffjs 0.30.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

@@ -25,14 +25,14 @@ 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);
 
@@ -62,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"] ?? "");

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

package/src/detectors/layout-code.ts

@@ -0,0 +1,174 @@
+// layout-code-mismatch: a listing's layout code (2LDK, "3 bedrooms") against the rooms the same listing names
+// (structure/layout-codes.ts). The code letters and counted words are layout-code's, the room names layout-room's, and the
+// field names layout-label's.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import {
+  foldWidth,
+  layoutSlip,
+  pairByScope,
+  parseBreakdown,
+  parseLayoutCode,
+  type Breakdown,
+  type LayoutCode,
+  type LayoutSlip,
+  type LayoutWords,
+  type LetterGroup,
+  type RoomGroup,
+} from "../structure/layout-codes.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+type LabelGroup = "code" | "breakdown" | "room-column";
+type Labels = ReadonlyMap<string, LabelGroup>;
+
+const LETTER_GROUPS: readonly LetterGroup[] = ["living", "dining", "kitchen", "storage", "one-room"];
+const ROOM_GROUPS: readonly RoomGroup[] = ["living", "dining", "kitchen", "room", "storage", "unclear"];
+const LABEL_GROUPS: readonly LabelGroup[] = ["code", "breakdown", "room-column"];
+
+const letterGroupOf = (group: string | undefined): LetterGroup | undefined => LETTER_GROUPS.find((known) => known === group);
+
+export const layoutWordsOf = (lexicons: ProseDocument["lexicons"]): LayoutWords => {
+  const code = lexicons["layout-code"] ?? [];
+  return {
+    letters: new Map(
+      code.flatMap((entry): [string, LetterGroup][] => {
+        const group = letterGroupOf(entry.group);
+        return group === undefined ? [] : [[entry.pattern, group]];
+      }),
+    ),
+    joiners: code.filter((entry) => entry.group === "joiner").map((entry) => entry.pattern),
+    counted: code.filter((entry) => entry.group === "counted").map((entry) => entry.pattern),
+    counters: code.filter((entry) => entry.group === "counter").map((entry) => entry.pattern),
+    rooms: (lexicons["layout-room"] ?? []).flatMap((entry) => {
+      const group = ROOM_GROUPS.find((known) => known === entry.group);
+      return group === undefined ? [] : [{ pattern: entry.pattern, group }];
+    }),
+  };
+};
+
+const labelKey = (label: string): string => foldWidth(withoutEdgeMarks(label)).toLowerCase().replace(/\s+/gu, " ");
+
+const labelsOf = (lexicons: ProseDocument["lexicons"]): Labels =>
+  new Map(
+    (lexicons["layout-label"] ?? []).flatMap((entry): [string, LabelGroup][] => {
+      const group = LABEL_GROUPS.find((known) => known === entry.group);
+      return group === undefined ? [] : [[labelKey(entry.pattern), group]];
+    }),
+  );
+
+/** A code found in the page, with the breakdown written right with it when there is one (a row, or 2LDK（洋室6帖・…）). */
+type PlacedCode = { readonly code: LayoutCode; readonly scope: number; readonly breakdown?: Breakdown | undefined };
+type PlacedBreakdown = { readonly breakdown: Breakdown; readonly scope: number };
+type Found = { readonly codes: PlacedCode[]; readonly breakdowns: PlacedBreakdown[] };
+const NOTHING: Found = { codes: [], breakdowns: [] };
+
+type Context = { readonly words: LayoutWords; readonly labels: Labels; readonly scopeOf: (offset: number) => number };
+
+const INLINE_BREAKDOWN = /^[^(（]*[(（]([^)）]+)[)）]/u;
+
+/** The breakdown written in brackets after the code, when it names a room. */
+const inlineBreakdown = (rest: string, words: LayoutWords): Breakdown | undefined => {
+  const inside = INLINE_BREAKDOWN.exec(rest)?.[1];
+  if (inside === undefined) return undefined;
+  const breakdown = parseBreakdown([inside], words);
+  return breakdown.rooms > 0 || breakdown.unclear ? breakdown : undefined;
+};
+
+const codeIn = (text: string, start: number, context: Context, breakdown?: Breakdown): PlacedCode[] => {
+  const found = parseLayoutCode(text, context.words);
+  if (found === undefined) return [];
+  const code = { ...found, start: start + found.start, end: start + found.end };
+  const written = breakdown ?? inlineBreakdown(text.slice(found.end), context.words);
+  return [{ code, scope: context.scopeOf(code.start), breakdown: written }];
+};
+
+const field = (group: LabelGroup | undefined, value: string, start: number, context: Context): Found => {
+  if (group === "code") return { codes: codeIn(value, start, context), breakdowns: [] };
+  if (group === "breakdown") return { codes: [], breakdowns: [{ breakdown: parseBreakdown([value], context.words), scope: context.scopeOf(start) }] };
+  return NOTHING;
+};
+
+const merged = (found: readonly Found[]): Found => ({
+  codes: found.flatMap((each) => each.codes),
+  breakdowns: found.flatMap((each) => each.breakdowns),
+});
+
+const groupOfCell = (cell: Cell | undefined, labels: Labels): LabelGroup | undefined => (cell === undefined ? undefined : labels.get(labelKey(cell.text)));
+
+/** A table with a layout column: one listing a row, with its breakdown column when the table has one. */
+const wideRows = (rows: readonly Cell[][], codeColumn: number, breakdownColumn: number, context: Context): Found => ({
+  codes: rows.flatMap((cells) => {
+    const code = cells[codeColumn];
+    const listed = cells[breakdownColumn];
+    const breakdown = listed === undefined ? undefined : parseBreakdown([listed.text], context.words);
+    return code === undefined ? [] : codeIn(code.text, code.start, context, breakdown);
+  }),
+  breakdowns: [],
+});
+
+const tableFound = (header: Line, rows: readonly Cell[][], context: Context): Found => {
+  const groups = cellsOf(header).map((cell) => groupOfCell(cell, context.labels));
+  const codeColumn = groups.indexOf("code");
+  if (codeColumn !== -1) return wideRows(rows, codeColumn, groups.indexOf("breakdown"), context);
+  if (groups[0] === "room-column") {
+    const breakdown = parseBreakdown(
+      rows.map((cells) => cells[0]?.text ?? ""),
+      context.words,
+    );
+    return { codes: [], breakdowns: [{ breakdown, scope: context.scopeOf(header.start) }] };
+  }
+  return merged(rows.map(([label, value]) => (value === undefined ? NOTHING : field(groupOfCell(label, context.labels), value.text, value.start, context))));
+};
+
+const tablesFound = (source: string, context: Context): Found =>
+  merged(tablesOf(linesOf(source)).map((table) => tableFound(table.header, table.rows.map(cellsOf), context)));
+
+const LIST_LEAD = /^\s*(?:(?:[-*+]|\d+[.)])\s+)?/u;
+const MAX_LABEL_LENGTH = 24;
+
+/** "間取り：2LDK", "- Rooms: Bedroom 1, Bedroom 2" outside tables: the name before the first colon, and the value after it. */
+const labelledLine = (line: Line, context: Context): Found => {
+  const colon = line.text.search(/[:：]/u);
+  if (colon === -1 || line.text.includes("|")) return NOTHING;
+  const label = line.text.slice(0, colon).replace(LIST_LEAD, "");
+  const rest = line.text.slice(colon + 1);
+  const value = rest.trimStart();
+  if (label.length > MAX_LABEL_LENGTH || value === "") return NOTHING;
+  return field(context.labels.get(labelKey(label)), value, line.start + colon + 1 + rest.length - value.length, context);
+};
+
+/** Code and markup are masked in prose, so a colon in code is not read. */
+const linesFound = (prose: string, context: Context): Found => merged(linesOf(prose).map((line) => labelledLine(line, context)));
+
+const scopeFinder =
+  (doc: ProseDocument) =>
+  (offset: number): number =>
+    doc.sections.findLastIndex((section) => section.span.start <= offset);
+
+const slipsOf = (found: Found): LayoutSlip[] => {
+  const direct = found.codes.flatMap((placed): [LayoutCode, Breakdown][] => (placed.breakdown === undefined ? [] : [[placed.code, placed.breakdown]]));
+  const pooled = found.codes.filter((placed) => placed.breakdown === undefined);
+  const paired = pairByScope(pooled, found.breakdowns).map(([placed, listed]): [LayoutCode, Breakdown] => [placed.code, listed.breakdown]);
+  return [...direct, ...paired].flatMap(([code, breakdown]) => layoutSlip(code, breakdown) ?? []);
+};
+
+export const layoutCode: Detector = (doc): Finding[] => {
+  const context: Context = { words: layoutWordsOf(doc.lexicons), labels: labelsOf(doc.lexicons), scopeOf: scopeFinder(doc) };
+  const found = merged([tablesFound(doc.source, context), linesFound(doc.prose ?? doc.source, context)]);
+  return slipsOf(found).map((slip) => ({
+    rule: "layout-code-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.code.start),
+    ...(slip.kind === "part" ? { variant: "part" } : {}),
+    values: {
+      code: slip.code.text,
+      stated: slip.code.rooms,
+      ...(slip.kind === "count" ? { listed: slip.listed } : { part: slip.entry }),
+      offset: slip.code.start,
+    },
+  }));
+};

package/src/detectors/measured-facts.ts

@@ -0,0 +1,20 @@
+import type { ProseDocument, StructureNode } from "../plugin.ts";
+import { nameSpans } from "../compare/proper-nouns.ts";
+import { overlapsAny, spanIndex } from "../compare/spans.ts";
+import { factValues, type FactValue } from "../facts/fact-values.ts";
+import { codeFences } from "./code-fences.ts";
+import { measuredValues, type Measured } from "../facts/measures.ts";
+import { measureUnitsOf } from "../facts/measure-units.ts";
+
+/** 文書の中の、単位の語彙表の単位が付いた量。コードの塊の中の量は、項目の値ではない。 */
+export const measuredOf = (doc: ProseDocument): Measured[] => {
+  const fences = codeFences(doc.source);
+  return measuredValues(doc.source, measureUnitsOf(doc)).filter((value) => !fences.some((fence) => fence.start <= value.start && value.end <= fence.end));
+};
+
+/** fact-conflict の値に、単位の付いた量を足す。量と重なる値（量の数だけを読んだもの）は量に置き換える。 */
+export const valuesWith = (tree: StructureNode, doc: ProseDocument, measured: readonly Measured[]): FactValue[] => {
+  const taken = spanIndex(measured);
+  const others = factValues(tree, doc.source, nameSpans(doc)).filter((value) => !overlapsAny(taken, value));
+  return [...others, ...measured].toSorted((left, right) => left.start - right.start);
+};

package/src/detectors/name-variant-model-codes.ts

@@ -0,0 +1,27 @@
+import type { MarkupHeading, ProseDocument } from "../plugin.ts";
+import { codesAfterLabels, codesInTitle, modelCodeVariants } from "../model-codes.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { tableBodyCells } from "../facts/table-facts.ts";
+import { proseWithCells } from "../table-cells.ts";
+
+// 型番の欄の語（型番、Model No.）は語彙表 model-code-label が言う。
+
+type ModelCodeFinding = { readonly offset: number; readonly name: string; readonly usual: string; readonly kind: string };
+
+/** 文書の題: 一番浅い見出しのうち最初のもの。 */
+const titleOf = (doc: ProseDocument): MarkupHeading | undefined => {
+  const headings = doc.markup?.headings ?? [];
+  const top = Math.min(...headings.map((heading) => heading.depth));
+  return headings.find((heading) => heading.depth === top);
+};
+
+/** 題か型番の欄に書いた型番を、ほかの所（題・表の升も）で別の形に書いた所。prose は見出しと表を覆うので、題と升の字を書き戻して読む。 */
+export const modelCodeFindings = (doc: ProseDocument, prose: string): ModelCodeFinding[] => {
+  const title = titleOf(doc);
+  const titleSpans = title === undefined ? [] : [{ start: title.start, end: title.end, text: doc.source.slice(title.start, title.end) }];
+  const text = proseWithCells(prose, [...titleSpans, ...(doc.tableCells?.() ?? tableBodyCells(proseAndTablesOf(doc)))]);
+  const labels = (doc.lexicons["model-code-label"] ?? []).map((entry) => entry.pattern);
+  const titleCodes = title === undefined ? [] : codesInTitle(text, title.start, title.end);
+  const anchors = [...titleCodes, ...codesAfterLabels(text, labels)].toSorted((left, right) => left.offset - right.offset);
+  return modelCodeVariants(text, anchors).map(({ code, usual }) => ({ offset: code.offset, name: code.surface, usual, kind: "model-code" }));
+};