chaffjs 0.34.0 → 0.36.0

package/src/detectors/sentence-counts.ts

@@ -1,4 +1,5 @@
-import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence, Token } from "../plugin.ts";
+import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
 import { isWithinAny, quotedIn } from "../quoted-span.ts";
 import { entryOpens } from "./lexicon-match.ts";
 
@@ -6,10 +7,25 @@ type TokenTest = (token: Token, at: number, tokens: readonly Token[]) => boolean
 
 const wordsOf = (lexicon: Lexicon | undefined): ReadonlySet<string> => new Set((lexicon ?? []).map((entry) => entry.pattern));
 
-/** The tokens of a sentence that pass the test, outside anything quoted in 「」『』: a quotation is not the writer's to rephrase. */
-const countedTokens = (sentence: Sentence, test: TokenTest): Token[] => {
-  const quoted = quotedIn(sentence);
-  return (sentence.tokens ?? []).filter((token, at, tokens) => test(token, at, tokens) && !isWithinAny(quoted, token.span));
+/** The terms whose counted word belongs to the term itself (電磁的方法), not to the writer's style. */
+export const FIXED_TERM_LEXICON = "teki-fixed-term";
+
+/** Where the sentence holds one of the terms, in the document's coordinates. */
+const termSpans = (sentence: Sentence, terms: Lexicon): Span[] =>
+  terms.flatMap((entry) =>
+    [...sentence.text.matchAll(new RegExp(escapeRegExp(entry.pattern), "gu"))].map((match) => ({
+      start: sentence.span.start + match.index,
+      end: sentence.span.start + match.index + entry.pattern.length,
+    })),
+  );
+
+/**
+ * The tokens of a sentence that pass the test, outside anything quoted in 「」『』 and outside the fixed terms: neither a
+ * quotation nor a term the law defines (電磁的方法) is the writer's to rephrase.
+ */
+const countedTokens = (sentence: Sentence, test: TokenTest, fixedTerms: Lexicon): Token[] => {
+  const kept = [...quotedIn(sentence), ...termSpans(sentence, fixedTerms)];
+  return (sentence.tokens ?? []).filter((token, at, tokens) => test(token, at, tokens) && !isWithinAny(kept, token.span));
 };
 
 const findingOf = (sentence: Sentence, counted: readonly Token[], limit: number): Finding => ({
@@ -21,16 +37,16 @@ const findingOf = (sentence: Sentence, counted: readonly Token[], limit: number)
   values: { word: counted[0]?.surface ?? "", count: counted.length, limit, offset: sentence.span.start },
 });
 
-const sentencesOver = (doc: ProseDocument, limit: number, test: TokenTest): Finding[] =>
+const sentencesOver = (doc: ProseDocument, limit: number, test: TokenTest, fixedTerms: Lexicon = []): Finding[] =>
   doc.sentences.flatMap((sentence) => {
-    const counted = countedTokens(sentence, test);
+    const counted = countedTokens(sentence, test, fixedTerms);
     return counted.length > limit ? [findingOf(sentence, counted, limit)] : [];
   });
 
 /** A sentence holding more than limit tokens written as one of the lexicon's words (the suffix 的). */
 export const sentenceWordCount: Detector = (doc, options): Finding[] => {
   const words = wordsOf(options.lexicon);
-  return sentencesOver(doc, options.limit, (token) => words.has(token.surface));
+  return sentencesOver(doc, options.limit, (token) => words.has(token.surface), doc.lexicons[FIXED_TERM_LEXICON] ?? []);
 };
 
 const NOMINAL: ReadonlySet<string> = new Set(["NOUN", "PROPN", "NUM"]);

package/src/detectors/sentence-ending.ts

@@ -1,7 +1,9 @@
 import { endingTokens, isClosed } from "../sentence-shape.ts";
 import { enumeratedRuns, enumeratorStarts, numberedStarts } from "./enumerated-runs.ts";
-import { continuesInto, groupOf, registerOf, slipsOf, type Register } from "./register.ts";
+import { continuesInto, groupOf, majorityOf, registerOf, slipsOf, type Register } from "./register.ts";
 import { isRunInLabel } from "./run-in-label.ts";
+import { noticeSentences } from "./notice-paragraph.ts";
+import { chronologyRows } from "../chronology-rows.ts";
 import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } from "../plugin.ts";
 
 /**
@@ -10,6 +12,8 @@ import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } f
  * どちらが正しいかは決めない。決めると、方針の違う書き手にそのまま無視される。
  * 見るのは文書の中での一貫性だけで、少数派のほうを指摘する。spec §12.3 の方針を日本語にも。
  * 終止符で終わらないもの（見出しの下の `MaaSサービス` のような名前だけの行）と、項目や段落の頭の太字の札（**速く書ける。**）は文として数えない。
+ * 年表の行（1921年信号装置の製作を開始する。）も、文書の文体と揃えない書き方なので数えない。
+ * 断り書きの段落（…ご了承ください。）も、本文とは別の声で書く決まり文句なので数えない（notice-paragraph.ts）。
  */
 type Entry = { readonly sentence: Sentence; readonly register: Register; readonly group: number | undefined };
 
@@ -35,11 +39,16 @@ const runsOf = (doc: ProseDocument, registers: readonly Register[]): Span[] => {
 export const judgedSentences = (doc: ProseDocument, polite: readonly LexiconEntry[]): Entry[] => {
   const neutral = doc.lexicons["neutral-ending"] ?? [];
   const lists = doc.lists.map((list) => list.span);
-  const found = doc.sentences.flatMap((sentence, index): { sentence: Sentence; register: Register }[] => {
-    if (!isClosed(sentence) || continuesInto(sentence, doc.sentences[index + 1]) || isRunInLabel(doc.source, sentence.span)) return [];
+  const rows = chronologyRows(doc);
+  const all = doc.sentences.flatMap((sentence, index): { sentence: Sentence; register: Register }[] => {
+    if (!isClosed(sentence) || rows.has(sentence) || continuesInto(sentence, doc.sentences[index + 1]) || isRunInLabel(doc.source, sentence.span)) return [];
     const register = registerOfSentence(sentence, polite, neutral);
     return register === undefined ? [] : [{ sentence, register }];
   });
+  const registers = new Map(all.map((entry) => [entry.sentence, entry.register]));
+  const majority = majorityOf(all.map((entry) => ({ register: entry.register, group: undefined })));
+  const notices = noticeSentences(doc.paragraphs, doc.lexicons["notice-phrase"] ?? [], (sentence) => registers.get(sentence), majority);
+  const found = all.filter((entry) => !notices.has(entry.sentence));
   const runs = runsOf(
     doc,
     found.map((entry) => entry.register),

package/src/detectors/sentence-length.ts

@@ -1,19 +1,26 @@
 import { lengthOf, proseText } from "../measure.ts";
 import type { Detector, DetectorOptions, Finding, LengthUnit, Sentence } from "../plugin.ts";
+import { pageMarkerPattern, pageMarkerSize } from "./page-marker.ts";
 
 type Measure = { readonly size: number; readonly limit: number; readonly variant?: string };
 
-/** 文書と違う言語の文（和文の中の英文）は、その言語の単位と上限で測る。rule がその言語の段を持たなければ文書のもので。 */
-const measureOf = (sentence: Sentence, unit: LengthUnit, options: DetectorOptions): Measure => {
+/**
+ * 文書と違う言語の文（和文の中の英文）は、その言語の単位と上限で測る。rule がその言語の段を持たなければ文書のもので。
+ * 印刷版のページの印（( printed page 52044)）は文の言葉ではないので数えない。
+ */
+const measureOf = (sentence: Sentence, unit: LengthUnit, options: DetectorOptions, markers: RegExp | undefined): Measure => {
   const embedded = sentence.embeddedLanguage;
   const limit = embedded === undefined ? undefined : options.embeddedLimits?.[embedded.id];
-  if (embedded === undefined || limit === undefined) return { size: lengthOf(sentence, unit), limit: options.limit };
+  if (embedded === undefined || limit === undefined) {
+    return { size: lengthOf(sentence, unit) - pageMarkerSize(proseText(sentence), markers, unit), limit: options.limit };
+  }
   return { size: lengthOf(sentence, embedded.lengthUnit), limit, variant: `embedded-${embedded.id}` };
 };
 
-export const sentenceLength: Detector = (doc, options): Finding[] =>
-  doc.sentences
-    .map((sentence) => ({ sentence, measure: measureOf(sentence, doc.lengthUnit, options) }))
+export const sentenceLength: Detector = (doc, options): Finding[] => {
+  const markers = pageMarkerPattern((options.lexicon ?? []).map((entry) => entry.pattern));
+  return doc.sentences
+    .map((sentence) => ({ sentence, measure: measureOf(sentence, doc.lengthUnit, options, markers) }))
     .filter(({ measure }) => measure.size > measure.limit)
     .map(({ sentence, measure }) => ({
       rule: "max-sentence-length",
@@ -24,3 +31,4 @@ export const sentenceLength: Detector = (doc, options): Finding[] =>
       values: { count: measure.size, limit: measure.limit, offset: sentence.span.start },
       ...(measure.variant === undefined ? {} : { variant: measure.variant }),
     }));
+};

package/src/detectors/sentence-load.ts

@@ -1,6 +1,7 @@
 import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
 import { proseText } from "../measure.ts";
 import { quotedSpans } from "../quoted-span.ts";
+import { literalCues, withoutLiteralQuotes } from "../literal-quote.ts";
 import { bracketDepth, clauseCount, topicDistance } from "../sentence-load.ts";
 
 const findingOf = (sentence: Sentence, count: number, limit: number): Finding => ({
@@ -35,8 +36,14 @@ const ownTokens = (sentence: Sentence): Token[] => {
   return (sentence.tokens ?? []).filter((token) => !inQuote(token));
 };
 
-/** Brackets inside brackets: 「（注（a）参照）」. The depth is read from the text, so it works in every language. */
-export const bracketNesting: Detector = overLimit((sentence) => bracketDepth(sentence.text));
+/**
+ * Brackets inside brackets: 「（注（a）参照）」. The depth is read from the text, so it works in every language. A quotation of a
+ * string to type as it stands (件名に「応募（総務課）」と記載) counts as one bracket: its own brackets cannot be taken out.
+ */
+export const bracketNesting: Detector = (doc, options) => {
+  const cues = literalCues(doc.lexicons["literal-quote-cue"] ?? []);
+  return overLimit((sentence) => bracketDepth(withoutLiteralQuotes(sentence.text, cues)))(doc, options);
+};
 
 /** Clauses chained in one sentence (調べて、まとめ、報告したが、返事がないので、…). Needs the language's tokens. */
 export const clauseChain: Detector = overLimit((sentence) => (sentence.tokens === undefined ? undefined : clauseCount(ownTokens(sentence))));

package/src/detectors/sentence-rhythm.ts

@@ -1,5 +1,5 @@
 import { charLength, proseText } from "../measure.ts";
-import type { Detector, Finding } from "../plugin.ts";
+import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
 
 /** 文が少ないと変動係数は当てにならない。ここを下回る文書は見ない。 */
 const MIN_SENTENCES = 8;
@@ -11,8 +11,12 @@ const coefficientOfVariation = (sizes: readonly number[]): number => {
   return Math.sqrt(variance) / mean;
 };
 
+/** 箇条書きの項目は揃えて書くのが正しい形なので、地の文の文だけを測る。 */
+const proseSentences = (doc: ProseDocument): readonly Sentence[] => doc.paragraphs.flatMap((paragraph) => paragraph.sentences);
+
 export const sentenceRhythm: Detector = (doc, options): Finding[] => {
-  const sizes = doc.sentences.map((sentence) => charLength(sentence));
+  const sentences = proseSentences(doc);
+  const sizes = sentences.map((sentence) => charLength(sentence));
   if (sizes.length < MIN_SENTENCES) return [];
   const spread = Math.round(coefficientOfVariation(sizes) * 100);
   if (spread >= options.limit) return [];
@@ -22,8 +26,8 @@ export const sentenceRhythm: Detector = (doc, options): Finding[] => {
       severity: "warning",
       line: 0,
       column: 0,
-      quote: doc.sentences[0] === undefined ? "" : proseText(doc.sentences[0]),
-      values: { count: spread, limit: options.limit, offset: doc.sentences[0]?.span.start ?? 0 },
+      quote: sentences[0] === undefined ? "" : proseText(sentences[0]),
+      values: { count: spread, limit: options.limit, offset: sentences[0]?.span.start ?? 0 },
     },
   ];
 };

package/src/detectors/series-label.ts

@@ -1,13 +1,22 @@
 /**
- * - で区切った文書番号のすぐ前の大文字の語（NIST SP 800-61 の SP、NSF 19-582、IEC 19757-2）。番号の一部で、略語ではない。
+ * - で区切った文書番号のすぐ前の大文字の語（NIST SP 800-61 の SP、NSF 19-582、IEC 19757-2、XRIN 0693-XC139、
+ * FR Doc. 2026-16371 の FR）。番号の一部で、略語ではない。
  * 空白で離して書くほかは、- で繋いだ識別子（AC-2）と同じ。番号の直前の 1 語だけで、その前の語（NIST）は略語のまま数える。
  * 区切りの無い番号（RFC 9110）、. で区切る版（SDK 3.1）、年の範囲（FY 2024-25）の前の語も略語のまま数える。
  */
 
 type Span = { readonly start: number; readonly end: number };
 
-const YEAR_RANGE = String.raw`(?:19|20)\d\d-\d`;
-const SERIES_LABEL = new RegExp(String.raw`(?<![A-Za-z0-9_&.-])[A-Z]+ (?!${YEAR_RANGE})(?<number>\d+(?:-\d+)+)[A-Za-z0-9]*(?![A-Za-z0-9_&-])`, "gu");
+/** 年の範囲（2024-25、1999-2000）。後ろが 3 桁や 5 桁の番号（FR Doc. 2026-16371）は年ではない。 */
+const YEAR_RANGE = String.raw`(?:19|20)\d\d-(?:(?:19|20)\d\d|\d\d)(?![A-Za-z0-9_&-])`;
+/** 語と番号の間に置く、点で終わる 2〜3 文字の略し（FR Doc. 2026-16371、EO No. 14028-1）。 */
+const NUMBER_WORD = String.raw`(?:[A-Z][a-z]{1,2}\. )?`;
+/** 2 つめからの区切りは、2 文字までの英字の頭を持てる（RIN の 0693-XC139）。英字の後ろは 3 桁以上の通し番号。 */
+const LATER_GROUP = String.raw`-(?:[A-Z]{1,2}\d{3,}|\d+)`;
+const SERIES_LABEL = new RegExp(
+  String.raw`(?<![A-Za-z0-9_&.-])[A-Z]+ ${NUMBER_WORD}(?!${YEAR_RANGE})(?<number>\d+(?:${LATER_GROUP})+)[A-Za-z0-9]*(?![A-Za-z0-9_&-])`,
+  "gu",
+);
 
 /**
  * 文書番号は長い通し番号を持つ（800-61、19757-2）。2 桁ずつの番号（BOD 25-01）は範囲・得点・日付（SRE 1-2、NFL 3-1、
@@ -23,7 +32,7 @@ const isRange = (groups: readonly string[]): boolean => {
 
 const isDocumentNumber = (number: string): boolean => {
   const groups = number.split("-");
-  return groups.some((group) => group.length >= SERIAL_DIGITS) && !isRange(groups);
+  return groups.some((group) => group.replace(/\D/gu, "").length >= SERIAL_DIGITS) && !isRange(groups);
 };
 
 /** 文の中の、番号と、その前の大文字の語の範囲。 */

package/src/detectors/signals.ts

@@ -1,15 +1,22 @@
 import { proseText } from "../measure.ts";
 import { dateSpans, wordsOf } from "./structure.ts";
-import { compacted, placeAt, type Compacted } from "./gram-place.ts";
+import { compacted, linkedIn, placeAt } from "./gram-place.ts";
 import { charWindows, wordWindows } from "./gram-windows.ts";
 import { furnitureMask, isFurniture } from "./gram-furniture.ts";
-import { notAcronymSpansOf, type NotAcronymSpans } from "./acronym-context.ts";
-import { abbreviates, expansionAt, termEntryAcronyms, type ExpandedAt } from "./acronym-expansion.ts";
+import { lexiconNotationOf, type NotAcronymSpans } from "./acronym-context.ts";
+import { abbreviates, expansionAt, termEntryAcronyms, type DefinitionWords, type ExpandedAt } from "./acronym-expansion.ts";
 import { isExplained } from "./acronym-compound.ts";
+import { statedAcronyms } from "./acronym-definition.ts";
+import { isBracketed, isInHeading, isNamePart } from "./acronym-lone.ts";
+import { linkTitleSpans } from "./acronym-link.ts";
 import { conjugatedForms } from "./conjugated-form.ts";
-import { evidenceSpans, hasNumeral, startsWithin } from "./concrete-evidence.ts";
+import { evidenceSpans, hasNumeral, isClaim, isLabelOnly, startsWithin, type AdviceWords } from "./concrete-evidence.ts";
 import { letteredIndexEntries } from "./lettered-index.ts";
+import { knownByDocument } from "./acronym-known.ts";
+import { outlineLabelSpans } from "./outline-label.ts";
 import { hasPredicateIn } from "./gram-predicate.ts";
+import { gramPassagesOf } from "./gram-passages.ts";
+import { sectionOpeners } from "./gram-openers.ts";
 import { nameSpans, touchesAny } from "../team-names.ts";
 import { referenceListSpans } from "../reference-lists.ts";
 import type { Detector, Finding, ProseDocument, Section, Sentence } from "../plugin.ts";
@@ -92,15 +99,6 @@ type FirstSeen = { readonly gram: string; readonly sentence: Sentence; readonly
 
 type Tally = { readonly counts: Map<string, number>; readonly first: Map<string, FirstSeen> };
 
-/** 詰めた文の index 番目の文字が、リンクの文字か。 */
-const linkedIn = (doc: ProseDocument, sentence: Sentence, source: Compacted): ((index: number) => boolean) => {
-  const links = doc.links.filter((link) => link.start < sentence.span.end && sentence.span.start < link.end);
-  return (index) => {
-    const at = sentence.span.start + (source.offsets[index] ?? -1);
-    return links.some((link) => link.start <= at && at < link.end);
-  };
-};
-
 /** 英語は大文字と小文字を区別せずに数える。文頭の "Proposals submitted via" も文中の "proposals submitted via" も同じ言い回し。 */
 const keyOf = (gram: string, unit: ProseDocument["lengthUnit"]): string => (unit === "word" ? gram.toLowerCase() : gram);
 
@@ -127,12 +125,27 @@ const tallySentence = (doc: ProseDocument, sentence: Sentence, tally: Tally): vo
     });
 };
 
-const gramsOf = (doc: ProseDocument): Tally => {
+const gramsOf = (doc: ProseDocument, sentences: readonly Sentence[]): Tally => {
   const tally: Tally = { counts: new Map(), first: new Map() };
-  doc.sentences.forEach((sentence) => tallySentence(doc, sentence, tally));
+  sentences.forEach((sentence) => tallySentence(doc, sentence, tally));
   return tally;
 };
 
+type Repeat = { readonly key: string; readonly count: number; readonly at: FirstSeen | undefined };
+
+/** 範囲（gram-passages.ts）ごとに数える。よくある質問の別々の答えは別の範囲。節の最初の文にだけ出るものは節のひな形（gram-openers.ts）。 */
+const repeatsOf = (doc: ProseDocument, limit: number, openers = sectionOpeners(doc.sections, doc.source)): Repeat[] =>
+  gramPassagesOf(doc.sections).flatMap((sentences) => {
+    const tally = gramsOf(doc, sentences);
+    const opening = gramsOf(
+      doc,
+      sentences.filter((sentence) => openers.has(sentence)),
+    ).counts;
+    return [...tally.counts.entries()]
+      .filter(([key, count]) => count > limit && isPhrasing(key, doc.lengthUnit) && (opening.get(key) ?? 0) < count)
+      .map(([key, count]) => ({ key, count, at: tally.first.get(key) }));
+  });
+
 /**
  * 語句が文の中で占める範囲に、述語になる動詞か助動詞があるか（gram-predicate.ts）。
  * 品詞が無ければ見分けられないので、これまでどおり言い回しとして数える。
@@ -145,11 +158,8 @@ const hasPredicate = (at: FirstSeen | undefined, unit: ProseDocument["lengthUnit
 
 export const ngramRepetition: Detector = (doc, options): Finding[] => {
   if (wordsOf(doc) < MIN_DOCUMENT_LENGTH[doc.lengthUnit]) return [];
-  const tally = gramsOf(doc);
-  const worst = [...tally.counts.entries()]
-    .filter(([key, count]) => count > options.limit && isPhrasing(key, doc.lengthUnit))
-    .toSorted(([, left], [, right]) => right - left)
-    .map(([key, count]) => ({ key, count, at: tally.first.get(key) }))
+  const worst = repeatsOf(doc, options.limit)
+    .toSorted((left, right) => right.count - left.count)
     .find(({ at }) => hasPredicate(at, doc.lengthUnit));
   if (worst === undefined) return [];
   const at = worst.at?.sentence;
@@ -171,9 +181,10 @@ export const ngramRepetition: Detector = (doc, options): Finding[] => {
  *
  * & で繋いだ大文字は 1 語として読む（ATT&CK、M&IE）。割ると CK や IE が別の略語に見える。
  * - で繋いだ略語どうしも 1 語（RT-PCR）。割ると RT が別の略語に見える。数字を含むもの（COVID-19）は識別子として外す。
+ * 下付きの数字が続く大文字は化学式（CO₂、SO₄）で、説明を待つ略語ではない。数字や小文字が続くもの（CO2、NOx）と同じく語の途中と読む。
  */
 const EDGE_BEFORE = String.raw`(?<![A-Za-z0-9_&])`;
-const EDGE_AFTER = String.raw`(?![A-Za-z0-9_&])`;
+const EDGE_AFTER = String.raw`(?![A-Za-z0-9_&\u2080-\u2089])`;
 /** 略語として読む大文字の長さの上限。これより長い大文字の語（BILLING）は、普通の語を大文字で書いたもの。 */
 const ACRONYM_MAX = 6;
 const ACRONYM_PART = String.raw`(?:[A-Z]+(?:&[A-Z]+)+|[A-Z]{2,${ACRONYM_MAX}})`;
@@ -261,9 +272,10 @@ const outsideSpans = (hits: readonly AcronymHit[], spans: readonly Span[]): Acro
 /**
  * どこか 1 か所で展開してあればよい。初出が節の見出し代わりの語（「5.3. DPA.」）で、
  * 展開がその直後の文にあることが契約書では普通にある。見るのは語として現れた所だけ（CISA の中の CI は見ない）。
+ * 複数形（Special Interest Groups (SIGs)）の展開は、s の無い略語（SIG）の展開でもある。
  */
 const isExpanded = (body: string, acronym: string, expandedAt: ExpandedAt): boolean =>
-  [...body.matchAll(new RegExp(`${EDGE_BEFORE}${acronym}${EDGE_AFTER}`, "gu"))].some((match) => expandedAt(body, acronym, match.index));
+  [...body.matchAll(new RegExp(`${EDGE_BEFORE}${acronym}s?${EDGE_AFTER}`, "gu"))].some((match) => expandedAt(body, match[0], match.index));
 
 /**
  * 見出しは文にならないので、見出しの中の展開（Maximum Envelope of Water (MEOW) runs）は見出しの文字列で探す。
@@ -274,50 +286,71 @@ const expandsInHeading = (heading: string, acronym: string, expandedAt: Expanded
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
-const notationOf = (doc: ProseDocument): NotAcronymSpans =>
-  notAcronymSpansOf({
-    meridiem: patternsOf(doc, "meridiem"),
-    timeZones: patternsOf(doc, "time-zone"),
-    currencies: patternsOf(doc, "currency-code"),
-    usStates: patternsOf(doc, "us-state-code"),
-    emphasis: patternsOf(doc, "emphasis-word"),
-    divisions: patternsOf(doc, "numbered-division"),
-    abbreviatedLabels: patternsOf(doc, "abbreviated-label"),
-    honorifics: patternsOf(doc, "honorific"),
-    titles: patternsOf(doc, "name-title"),
-    dateTimeUnits: patternsOf(doc, "date-time-unit"),
-  });
+const notationOf = (doc: ProseDocument): NotAcronymSpans => lexiconNotationOf((id) => patternsOf(doc, id));
 
-/** 定義の語は、語彙表の形（という）と、この文書で活用して書かれた形（といいます）の両方で照らす。 */
-const definitionVerbsOf = (doc: ProseDocument): string[] => {
+/** 定義の語。定義の動詞は、語彙表の形（という）と、この文書で活用して書かれた形（といいます）の両方で照らす。 */
+const definitionWordsOf = (doc: ProseDocument): DefinitionWords => {
   const verbs = patternsOf(doc, "definition-verb");
-  return [...verbs, ...conjugatedForms(doc.sentences, verbs)];
+  const alternatives = patternsOf(doc, "definition-alternative");
+  return { markers: patternsOf(doc, "definition-marker"), verbs: [...verbs, ...conjugatedForms(doc.sentences, verbs)], alternatives };
 };
 
+const acronymFinding = (acronym: string, hit: Hit, count: number, limit: number): Finding => ({
+  rule: "undefined-acronym",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: hit.sentence.text.trim(),
+  values: { word: acronym, count, limit, offset: hit.offset },
+});
+
+const isNamePartAt = (acronym: string, hit: Hit): boolean => {
+  const start = hit.offset - hit.sentence.span.start;
+  return isNamePart(hit.sentence.text, start, start + acronym.length);
+};
+
+/**
+ * 説明のない略語が上限に届かなくても、この文書が自分で上限の数だけ略語を展開しているなら、展開しなかった 1 つも指す。
+ * 書き手が展開する文書では、展開の抜けは抜けとして読める。名前の一部の略語（SRI International）は、そのときも指さない。
+ */
 export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const body = bodyOf(doc);
-  // HTTP のメソッド名（GET）は略語ではないので、通じる略語と同じく展開を求めない。
+  // HTTP のメソッド名（GET）は略語ではなく、税の名前（VAT、GST）は読み手が名前として知るので、通じる略語と同じく展開を求めない。
   // 並べた名前（JAXA）も、繋いだ略語（JAXA-ISAS）の片割れとして説明済みに数える。
-  const common = new Set([...(options.lexicon ?? []).map((entry) => entry.pattern), ...patternsOf(doc, "http-method"), ...(doc.names ?? [])]);
-  const expandedAt = expansionAt({ markers: patternsOf(doc, "definition-marker"), verbs: definitionVerbsOf(doc) });
-  const entries = termEntryAcronyms(doc.source);
+  // 文書が自分で知らせた語（select を書いた文書の SELECT、リンクで引いた講演の場 [Jane Roe, FOSDEM 2024](…)）も同じ。
+  const common = new Set([
+    ...(options.lexicon ?? []).map((entry) => entry.pattern),
+    ...knownByDocument(doc.source, doc.links).concat(patternsOf(doc, "http-method"), patternsOf(doc, "tax-code")),
+    ...(doc.names ?? []),
+  ]);
+  const expandedAt = expansionAt(definitionWordsOf(doc));
+  const stated = statedAcronyms(doc.source, { statements: patternsOf(doc, "definition-statement"), markers: patternsOf(doc, "definition-marker") });
+  const entries = new Set([...termEntryAcronyms(doc.source), ...stated]);
   const headings = doc.sections.map((section) => section.heading);
   const explainedAlone = (word: string): boolean =>
     common.has(word) || entries.has(word) || isExpanded(body, word, expandedAt) || headings.some((heading) => expandsInHeading(heading, word, expandedAt));
-  const hits = outsideSpans(acronymsOf(doc, notationOf(doc)), referenceListSpans(doc.source, patternsOf(doc, "reference-list-heading")));
-  const unexplained = new Set([...firstHits(hits).keys()].filter((acronym) => !isExplained(acronym, explainedAlone)));
+  const counted = outsideSpans(acronymsOf(doc, notationOf(doc)), [
+    ...referenceListSpans(doc.source, patternsOf(doc, "reference-list-heading")),
+    ...outlineLabelSpans(doc.source, patternsOf(doc, "numbered-division")),
+  ]);
+  // リンク先のページの題名の略語（[NASA Fprime AI Policy](https://…)）は、読み手が出会う説明の無い略語として数に入れるが、
+  // 書き手が直せないので指さない。
+  const hits = outsideSpans(counted, linkTitleSpans(doc.source, doc.links));
+  const acronyms = [...firstHits(hits).keys()];
+  const unexplained = new Set(acronyms.filter((acronym) => !isExplained(acronym, explainedAlone)));
+  const quoted = [...firstHits(counted).keys()].filter((acronym) => !acronyms.includes(acronym) && !isExplained(acronym, explainedAlone)).length;
+  const bracketed = (acronym: string): boolean => [body, ...headings].some((text) => isBracketed(text, acronym));
+  // 定義の一覧（"SOW" means …）で定義する書き手も、略語を展開する書き手と数える。
+  const definedByWriter = (acronym: string): boolean => bracketed(acronym) || stated.has(acronym);
+  const writerSpellsOut = acronyms.filter((acronym) => !common.has(acronym) && explainedAlone(acronym) && definedByWriter(acronym)).length >= options.limit;
   // 日付を読むには文書の木を作る。上限に届かない文書では作らない。
-  if (unexplained.size < options.limit) return [];
+  if (unexplained.size + quoted < options.limit && !writerSpellsOut) return [];
   const bare = [...firstHits(outsideSpans(hits, dateSpans(doc)))].filter(([acronym]) => unexplained.has(acronym));
-  if (bare.length < options.limit) return [];
-  return bare.map(([acronym, hit]) => ({
-    rule: "undefined-acronym",
-    severity: "info",
-    line: 0,
-    column: 0,
-    quote: hit.sentence.text.trim(),
-    values: { word: acronym, count: bare.length, limit: options.limit, offset: hit.offset },
-  }));
+  const met = bare.length + quoted;
+  if (met >= options.limit) return bare.map(([acronym, hit]) => acronymFinding(acronym, hit, met, options.limit));
+  if (!writerSpellsOut) return [];
+  const alone = bare.filter(([acronym, hit]) => !isNamePartAt(acronym, hit) && !isInHeading(headings, acronym));
+  return alone.map(([acronym, hit]) => acronymFinding(acronym, hit, alone.length, options.limit));
 };
 
 /**
@@ -341,9 +374,26 @@ const openingOf = (sentence: Sentence | undefined, unit: ProseDocument["lengthUn
 
 const hasNumeralIn = (section: Section): boolean => section.sentences.some((sentence) => hasNumeral(sentence.tokens ?? []));
 
+/** これより短い節は、具体物があるべきか判断できない。 */
+const MIN_SENTENCES = 3;
+
+const adviceWordsOf = (doc: ProseDocument): AdviceWords => ({
+  openers: (doc.lexicons["advice-opener"] ?? []).map((entry) => entry.pattern),
+  endings: (doc.lexicons["advice-ending"] ?? []).map((entry) => entry.pattern),
+});
+
+/** 文の半分以上が問いか指示の節（質問の一覧、手引き）は、数字で裏づける主張をしていない。番号だけの文（a.）は数えない。 */
+const mostlyClaims = (section: Section, language: string, advice: AdviceWords): boolean => {
+  const said = section.sentences.filter((sentence) => !isLabelOnly(sentence));
+  return said.filter((sentence) => isClaim(sentence, language, advice)).length * 2 > said.length;
+};
+
 export const concreteEvidence: Detector = (doc, options): Finding[] => {
   const entries = letteredIndexEntries(doc.sections);
-  const sections = doc.sections.filter((section) => section.sentences.length >= 3 && !entries.has(section));
+  const advice = adviceWordsOf(doc);
+  const sections = doc.sections.filter(
+    (section) => section.sentences.length >= MIN_SENTENCES && !entries.has(section) && mostlyClaims(section, doc.language, advice),
+  );
   const bare = sections.filter(
     (section) => !CONCRETE.test(doc.source.slice(section.span.start, section.span.end)) && !hasNumeralIn(section) && !startsWithin(section.span, doc.links),
   );

package/src/detectors/structure-tree.ts

@@ -1,13 +1,17 @@
 import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.ts";
 import { danglingReferences, duplicateDefinitions, inDocumentOrder, type StructureIssue } from "../structure/issues.ts";
 import { numberingBreaks } from "../structure/numbering.ts";
-import { listNumberBreaks, writtenNumbers } from "../structure/list-numbering.ts";
+import { attachedPartStarts } from "../structure/attached-parts.ts";
+import { sideStepReader } from "../structure/side-step.ts";
+import { htmlTextBlocks } from "../structure/html-text-blocks.ts";
+import { listsNumberBreaks } from "../structure/list-numbering.ts";
 import { weekdayMismatches } from "../structure/weekday.ts";
 import { documentDateOf } from "./document-date.ts";
 import { dateOrderBreaks } from "../structure/date-order.ts";
 import { totalMismatches, type Amount } from "../structure/total.ts";
 import { isListedTotal, isPeriodTotalLine, isTotalLikeLine, isTotalLine } from "../structure/total-line.ts";
 import { proseTotalMismatches } from "../structure/prose-total.ts";
+import { proseTotalWordsOf } from "./prose-total-words.ts";
 import { countedAmounts, type SummedCounter } from "../structure/counted-amounts.ts";
 import { measuredAmounts, type MeasureMarks, type SummedMeasure } from "../structure/measured-amounts.ts";
 import { withCompoundHours } from "../structure/compound-hours.ts";
@@ -40,7 +44,7 @@ const findingsOf =
     doc.structure === undefined
       ? []
       : issuesOf(doc.structure, doc.source).map((issue) => ({
-          rule,
+          ...(issue.variant === undefined ? { rule } : { rule, variant: issue.variant }),
           severity: "error",
           line: 0,
           column: 0,
@@ -48,19 +52,23 @@ const findingsOf =
           values: { ...issue.values, offset: issue.offset },
         }));
 
-export const danglingReference: Detector = findingsOf("dangling-reference", danglingReferences);
-const structureNumberingGap: Detector = findingsOf("numbering-gap", numberingBreaks);
+export const danglingReference: Detector = (doc, options) =>
+  findingsOf("dangling-reference", (tree, source) => danglingReferences(tree, source, patternsOf(doc, "section-name-noun")))(doc, options);
+/** Markdown の HTML ブロックの中の条は木に入らない。そこを挟んだ抜けは、見えなかった番号かもしれない。 */
+const structureNumberingGap: Detector = (doc, options) => {
+  const isSideStep = sideStepReader(patternsOf(doc, "side-step-label"));
+  const hiddenBlocks = (source: string) => (doc.markup?.markdown === true ? htmlTextBlocks(source) : []);
+  return findingsOf("numbering-gap", (tree, source) => numberingBreaks(tree, hiddenBlocks(source), isSideStep))(doc, options);
+};
 
 const lineStartAt = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
 
-/** The written numbers of the document's Markdown ordered lists that skip or repeat (structure/list-numbering.ts). */
-const QUOTED_LINE = /^[ \t]*>/u;
-
 /** 引用の中の箇条書きは、ほかの文書の例で、この文書の番号ではない。 */
-const isQuotedList = (source: string, start: number): boolean => QUOTED_LINE.test(source.slice(lineStartAt(source, start), start));
+const isQuotedList = (source: string, start: number): boolean => /^[ \t]*>/u.test(source.slice(lineStartAt(source, start), start));
 
+/** The written numbers of the document's Markdown ordered lists that skip or repeat (structure/list-numbering.ts). */
 const listNumberingGaps = (doc: ProseDocument): StructureIssue[] =>
-  doc.lists.filter((list) => !isQuotedList(doc.source, list.span.start)).flatMap((list) => listNumberBreaks(writtenNumbers(doc.source, list.itemSpans) ?? []));
+  listsNumberBreaks(doc.source, doc.lists, (list) => !isQuotedList(doc.source, list.span.start));
 
 const lineFindingOf = (doc: ProseDocument, issue: StructureIssue): Finding => ({
   rule: "numbering-gap",
@@ -88,7 +96,10 @@ export const numberingGap: Detector = (doc, options): Finding[] => {
     (left, right) => Number(left.values["offset"]) - Number(right.values["offset"]),
   );
 };
-export const duplicateDefinition: Detector = findingsOf("duplicate-definition", duplicateDefinitions);
+export const duplicateDefinition: Detector = (doc, options) => {
+  const labels = patternsOf(doc, "attached-instrument-label");
+  return findingsOf("duplicate-definition", (tree, source) => duplicateDefinitions(tree, attachedPartStarts(source, labels)))(doc, options);
+};
 
 /** 曜日の名前は言語パッケージの語彙表（weekday、日曜日から順）から取る。無ければ番号のまま。 */
 const dayName = (doc: ProseDocument, day: unknown): string => {
@@ -260,20 +271,11 @@ const totalIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["struct
     (text) => isPeriodTotalLine(text, words),
     { isListed: (text) => isListedTotal(text, words), isTotalLike: (text, header) => isTotalLikeLine(text, words, header) },
   );
-  const phrases = {
-    totals: patternsOf(doc, "total-phrase"),
-    breakdowns: patternsOf(doc, "breakdown-phrase"),
-    discounts: patternsOf(doc, "discount-word"),
-    joiners: patternsOf(doc, "breakdown-gap-joiner"),
-    leads: patternsOf(doc, "total-breakdown-lead"),
-    partials: patternsOf(doc, "breakdown-partial-word"),
-    backReferences: patternsOf(doc, "total-back-reference"),
-  };
   const prose = proseTotalMismatches(
     doc.source,
     doc.sentences.map((sentence) => sentence.span),
     amounts,
-    phrases,
+    proseTotalWordsOf(doc),
   );
   return [...lines, ...prose.filter((issue) => !lines.some((line) => line.offset === issue.offset))];
 };

package/src/detectors/structure.ts

@@ -138,7 +138,8 @@ const withoutDateStamps = (doc: ProseDocument, paragraphs: readonly Paragraph[])
 export const preambleLength: Detector = (doc, options): Finding[] => {
   const body = bodySectionOf(doc.sections);
   if (body === undefined) return [];
-  const all = preambleParagraphs(doc.paragraphs, body.span.start, doc.source);
+  const noteMarks = (doc.lexicons["note-mark"] ?? []).map((entry) => entry.pattern);
+  const all = preambleParagraphs(doc.paragraphs, body.span.start, doc.source, noteMarks);
   if (all.length <= options.limit) return [];
   const before = withoutDateStamps(doc, all);
   if (before.length <= options.limit) return [];