chaffjs 0.10.0 → 0.12.0

package/src/detectors/lead-in.ts

@@ -0,0 +1,14 @@
+/** 文末のコロン。後ろに強調の印（**・_）や空白が残っていても見る。 */
+const ENDS_WITH_COLON = /[:：][\s*_]*$/u;
+
+/**
+ * 後ろの箇条書きや表へ読者を渡す文（「次のとおりとする。」「The following expenses require receipts:」）。
+ * 見出しの語を繰り返していても、中身は後ろにある。言い回しは言語パッケージの語彙表 lead-in が持つ。
+ */
+export const isLeadIn = (sentence: string, phrases: readonly string[]): boolean => {
+  const text = sentence.trim().toLowerCase();
+  return ENDS_WITH_COLON.test(text) || phrases.some((phrase) => phrase !== "" && text.includes(phrase.toLowerCase()));
+};
+
+/** 渡す先（following: 同じ節の、その文より後ろ）が空なら、渡す文ではなくただの繰り返し。 */
+export const handsOver = (sentence: string, following: string, phrases: readonly string[]): boolean => following.trim() !== "" && isLeadIn(sentence, phrases);

package/src/detectors/lexicon-match.ts

@@ -0,0 +1,54 @@
+import type { LexiconEntry, Sentence, Token } from "../plugin.ts";
+import { proseText } from "../measure.ts";
+
+/** 活用する品詞。"best" を "good" と同じ語にはしない。 */
+const INFLECTING = new Set(["VERB", "AUX"]);
+
+/**
+ * 語彙表が原形で書いた語（いただく）だけが、活用した形（いただきます・いただいた）に当たる。
+ * 活用した形で書いた語（could・かもしれません）はその形だけ。"could" は "can" と言っていることが違う。
+ */
+const sameWord = (written: Token, entry: Token): boolean => {
+  const surface = entry.surface.toLowerCase();
+  if (written.surface.toLowerCase() === surface) return true;
+  const inflects = INFLECTING.has(written.pos) && INFLECTING.has(entry.pos);
+  return inflects && entry.lemma?.toLowerCase() === surface && written.lemma?.toLowerCase() === surface;
+};
+
+const runsAt = (tokens: readonly Token[], entry: readonly Token[], start: number): boolean =>
+  entry.every((word, offset) => {
+    const written = tokens[start + offset];
+    return written !== undefined && sameWord(written, word);
+  });
+
+/**
+ * 語彙の語が文の中にあるか。品詞が付いていれば語の並びで照らし、活用する語は原形で比べる（「させていただく」が「させていただきました」に当たる）。
+ * 語の途中には当たらない（「また」は「またいで」に当たらない）。品詞が無ければ、空白をまとめた文字列で照らす。
+ */
+export const entryIn = (sentence: Sentence, entry: LexiconEntry): boolean => {
+  const tokens = sentence.tokens;
+  const words = entry.tokens;
+  if (tokens === undefined || words === undefined || words.length === 0) return proseText(sentence).toLowerCase().includes(entry.pattern.toLowerCase());
+  return tokens.some((_token, start) => runsAt(tokens, words, start));
+};
+
+export type TokenRange = { readonly start: number; readonly end: number };
+
+/** 語彙の語が文のどの語の並びに当たったか（始まりと、終わった次の位置）。品詞が無ければ位置を言えないので空。 */
+export const entryRanges = (sentence: Sentence, entry: LexiconEntry): TokenRange[] => {
+  const tokens = sentence.tokens;
+  const words = entry.tokens;
+  if (tokens === undefined || words === undefined || words.length === 0) return [];
+  return tokens.flatMap((_token, start) => (runsAt(tokens, words, start) ? [{ start, end: start + words.length }] : []));
+};
+
+const LEADING_MARK = new Set(["PUNCT", "SYM"]);
+
+/** 語彙の語で文が始まるか。文頭の記号は飛ばす。品詞が無ければ文字列の前方一致。 */
+export const entryOpens = (sentence: Sentence, entry: LexiconEntry): boolean => {
+  const tokens = sentence.tokens;
+  const words = entry.tokens;
+  if (tokens === undefined || words === undefined || words.length === 0) return proseText(sentence).toLowerCase().startsWith(entry.pattern.toLowerCase());
+  const first = tokens.findIndex((token) => !LEADING_MARK.has(token.pos));
+  return runsAt(tokens, words, first);
+};

package/src/detectors/lexicon.ts

@@ -1,7 +1,8 @@
 import { joinWords } from "./word-list.ts";
-import { proseText } from "../measure.ts";
 import { wordsOf } from "./structure.ts";
-import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
+import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence } from "../plugin.ts";
+import { entryIn, entryOpens, entryRanges } from "./lexicon-match.ts";
+import { scoped, scopeMarkersOf, type ScopeMarkers } from "./superlative-scope.ts";
 
 const PER = 1000;
 
@@ -10,11 +11,8 @@ const FLOOR = { word: 200, char: 500 };
 
 type Hit = { readonly sentence: Sentence; readonly matched: string };
 
-const hitsFor = (doc: ProseDocument, patterns: readonly string[]): Hit[] =>
-  doc.sentences.flatMap((sentence) => {
-    const text = sentence.text.toLowerCase();
-    return patterns.filter((pattern) => text.includes(pattern.toLowerCase())).map((matched) => ({ sentence, matched }));
-  });
+const hitsFor = (doc: ProseDocument, lexicon: Lexicon): Hit[] =>
+  doc.sentences.flatMap((sentence) => lexicon.filter((entry) => entryIn(sentence, entry)).map((entry) => ({ sentence, matched: entry.pattern })));
 
 /**
  * 単位長あたりの出現率。件数で数えると長い文書ほど当たる（bold-density と同じ）。
@@ -23,8 +21,7 @@ const hitsFor = (doc: ProseDocument, patterns: readonly string[]): Hit[] =>
 const densityRule =
   (rule: string): Detector =>
   (doc, options): Finding[] => {
-    const patterns = (options.lexicon ?? []).map((entry) => entry.pattern);
-    const hits = hitsFor(doc, patterns);
+    const hits = hitsFor(doc, options.lexicon ?? []);
     const length = wordsOf(doc);
     const rate = length === 0 ? 0 : Math.round((hits.length / length) * PER);
     const first = hits[0];
@@ -42,15 +39,39 @@ const densityRule =
 export const hedgingDensity = densityRule("excessive-hedging");
 export const cushionDensity = densityRule("cushion-phrase-density");
 
+/** 数字は語ではないので言語を問わない。数があれば測った結果を言っている。品詞の数（NUM）は "the best one" の one まで含むので使わない。 */
+const DIGIT = /\d/u;
+
+type Qualifiers = { readonly comparison: Lexicon; readonly scope: ScopeMarkers };
+
+const qualifiersOf = (doc: ProseDocument): Qualifiers => ({
+  comparison: doc.lexicons["comparison-marker"] ?? [],
+  scope: scopeMarkersOf(doc.lexicons["superlative-scope"] ?? []),
+});
+
+/** どの出現も範囲を持つときだけ。1 つでも範囲の無い出現があれば、その文には限定の無い最上級がある。 */
+const everyScoped = (sentence: Sentence, entry: LexiconEntry, scope: ScopeMarkers): boolean => {
+  const ranges = entryRanges(sentence, entry);
+  return ranges.length > 0 && ranges.every((range) => scoped(sentence.tokens ?? [], range, scope));
+};
+
+const qualified = (sentence: Sentence, entry: LexiconEntry, qualifiers: Qualifiers): boolean =>
+  DIGIT.test(sentence.text) || qualifiers.comparison.some((marker) => entryIn(sentence, marker)) || everyScoped(sentence, entry, qualifiers.scope);
+
+const bareHits = (doc: ProseDocument, lexicon: Lexicon): Hit[] => {
+  const qualifiers = qualifiersOf(doc);
+  return doc.sentences.flatMap((sentence) =>
+    lexicon.filter((entry) => entryIn(sentence, entry) && !qualified(sentence, entry, qualifiers)).map((entry) => ({ sentence, matched: entry.pattern })),
+  );
+};
+
 /**
  * 限定のない最上級。「最も速い」だけでは、何と比べて最もなのかが無い。
- * 同じ文に比較対象や条件があれば、それは主張であって誇張ではない。
+ * 同じ文に比較対象・条件・範囲（日本で最も、the best in the world）があれば、それは主張であって誇張ではない。
+ * 比較と範囲を言う語は言語パッケージの語彙表が持つ。
  */
-const QUALIFIER = /\d|より|に比べ|のうち|among|than|compared|based on|according/iu;
-
 export const unqualifiedSuperlative: Detector = (doc, options): Finding[] => {
-  const patterns = (options.lexicon ?? []).map((entry) => entry.pattern);
-  const bare = hitsFor(doc, patterns).filter((hit) => !QUALIFIER.test(hit.sentence.text));
+  const bare = bareHits(doc, options.lexicon ?? []);
   if (bare.length < options.limit) return [];
   return bare.map((hit) => ({
     rule: "unqualified-superlative",
@@ -62,10 +83,10 @@ export const unqualifiedSuperlative: Detector = (doc, options): Finding[] => {
   }));
 };
 
-const openerOf = (doc: ProseDocument, patterns: readonly string[]): (string | undefined)[] =>
+const openerOf = (doc: ProseDocument, lexicon: Lexicon): (string | undefined)[] =>
   doc.paragraphs.map((paragraph) => {
-    const head = paragraph.sentences[0]?.text.trim().toLowerCase() ?? "";
-    return patterns.find((pattern) => head.startsWith(pattern.toLowerCase()));
+    const head = paragraph.sentences[0];
+    return head === undefined ? undefined : lexicon.find((entry) => entryOpens(head, entry))?.pattern;
   });
 
 /**
@@ -73,8 +94,7 @@ const openerOf = (doc: ProseDocument, patterns: readonly string[]): (string | un
  * 前の段落の付け足しに見えて、話がどこへ向かっているのか分からなくなる。
  */
 export const repeatedConjunction: Detector = (doc, options): Finding[] => {
-  const patterns = (options.lexicon ?? []).map((entry) => entry.pattern);
-  const openers = openerOf(doc, patterns);
+  const openers = openerOf(doc, options.lexicon ?? []);
   const runs = openers.reduce<{ runs: number[][]; current: number[] }>(
     (acc, opener, index) => {
       if (opener === undefined) return { runs: [...acc.runs, acc.current], current: [] };
@@ -106,11 +126,10 @@ export const repeatedConjunction: Detector = (doc, options): Finding[] => {
  * 単独で断じない。§20.2 の複合シグナルの入口で、これだけで「AI が書いた」とは言わない。
  */
 export const aiTell: Detector = (doc, options): Finding[] => {
-  const weights = new Map((options.lexicon ?? []).map((entry) => [entry.pattern.toLowerCase(), entry.weight ?? 1]));
-  const body = doc.sentences.map(proseText).join(" ").toLowerCase();
-  const found = [...weights.entries()].filter(([pattern]) => body.includes(pattern));
-  const score = Math.round(found.reduce((sum, [, weight]) => sum + weight, 0) * 10);
-  const first = doc.sentences.find((sentence) => found.some(([pattern]) => sentence.text.toLowerCase().includes(pattern)));
+  const entries = [...new Map((options.lexicon ?? []).map((entry) => [entry.pattern.toLowerCase(), entry])).values()];
+  const found = entries.filter((entry) => doc.sentences.some((sentence) => entryIn(sentence, entry)));
+  const score = Math.round(found.reduce((sum, entry) => sum + (entry.weight ?? 1), 0) * 10);
+  const first = doc.sentences.find((sentence) => found.some((entry) => entryIn(sentence, entry)));
   if (first === undefined || score <= options.limit) return [];
   return [
     {
@@ -121,7 +140,7 @@ export const aiTell: Detector = (doc, options): Finding[] => {
       quote: first.text.trim(),
       values: {
         word: joinWords(
-          found.map(([pattern]) => pattern),
+          found.map((entry) => entry.pattern.toLowerCase()),
           doc.language,
         ),
         count: found.length,

package/src/detectors/phrase-match.ts

@@ -1,4 +1,5 @@
-import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
+import type { Detector, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
+import { entryIn } from "./lexicon-match.ts";
 
 /** 冒頭は先頭 2 段落ぶん。「どの記事にも当てはまる書き出し」は冒頭にあるときだけ問題。 */
 const OPENING_SENTENCES = 4;
@@ -15,10 +16,10 @@ const inScope = (doc: ProseDocument, where: string | undefined): readonly Senten
 
 type Hit = { readonly sentence: Sentence; readonly matched: string };
 
-const hitsIn = (sentences: readonly Sentence[], patterns: readonly string[]): Hit[] =>
+const hitsIn = (sentences: readonly Sentence[], lexicon: Lexicon): Hit[] =>
   sentences.flatMap((sentence) => {
-    const matched = patterns.find((pattern) => sentence.text.toLowerCase().includes(pattern.toLowerCase()));
-    return matched === undefined ? [] : [{ sentence, matched }];
+    const matched = lexicon.find((entry) => entryIn(sentence, entry));
+    return matched === undefined ? [] : [{ sentence, matched: matched.pattern }];
   });
 
 /**
@@ -26,9 +27,9 @@ const hitsIn = (sentences: readonly Sentence[], patterns: readonly string[]): Hi
  * これが L2 の全体像で、新しい言語は語彙表を書くだけで動く。
  */
 export const phraseMatch: Detector = (doc, options): Finding[] => {
-  const patterns = (options.lexicon ?? []).map((entry) => entry.pattern);
-  if (patterns.length === 0) return [];
-  const hits = hitsIn(inScope(doc, options.where), patterns);
+  const lexicon = options.lexicon ?? [];
+  if (lexicon.length === 0) return [];
+  const hits = hitsIn(inScope(doc, options.where), lexicon);
   if (hits.length < options.limit) return [];
   return hits.map((hit) => ({
     rule: "",

package/src/detectors/repeated-head.ts

@@ -1,4 +1,4 @@
-import type { Detector, Finding, LengthUnit, Sentence } from "../plugin.ts";
+import type { Detector, Finding, LengthUnit, Sentence, Span } from "../plugin.ts";
 
 const HEAD_CHARS = 6;
 const HEAD_WORDS = 3;
@@ -13,22 +13,36 @@ const headOf = (sentence: Sentence, unit: LengthUnit): string => {
   return text.split(/\s+/u).slice(0, HEAD_WORDS).join(" ");
 };
 
-type Run = { readonly head: string; readonly members: readonly Sentence[] };
+/** 文の入れ物。文の始まりを含む、いちばん内側の箇条書きの項目の始まり。地の文なら -1。 */
+const containerOf = (sentence: Sentence, lists: readonly Span[]): number =>
+  lists.filter((item) => item.start <= sentence.span.start && sentence.span.start < item.end).reduce((innermost, item) => Math.max(innermost, item.start), -1);
 
-const runsOf = (sentences: readonly Sentence[], unit: LengthUnit): Run[] =>
+type Run = { readonly head: string; readonly container: number; readonly members: readonly Sentence[] };
+
+/** 前の文と今の文のあいだで、箇条書きの項目が始まっているか。文を持たない項目（画像だけの - ![図](a.png)）も連なりを切る。 */
+const listBetween = (previous: Sentence | undefined, sentence: Sentence, lists: readonly Span[]): boolean =>
+  previous !== undefined && lists.some((item) => item.start >= previous.span.end && item.start < sentence.span.start);
+
+/**
+ * 連なりは同じ入れ物の中でだけ続く。箇条書きの項目どうしは同じ形で並べるのが書き方そのもの（「1. SRE に関する…」「2. SRE に関する…」）で、
+ * 項目をまたぐと切る。一つの項目の中の段落や、地の文の中では、これまでどおり数える。箇条書きの前後の地の文も、箇条書きで切れる。
+ */
+const runsOf = (sentences: readonly Sentence[], unit: LengthUnit, lists: readonly Span[]): Run[] =>
   sentences.reduce<Run[]>((acc, sentence) => {
     const head = headOf(sentence, unit);
+    const container = containerOf(sentence, lists);
     const last = acc.at(-1);
     // 短すぎる書き出しは「同じ」と言えない。単位ぶん揃って初めて連なりと見る。
     const full = unit === "char" ? head.length === HEAD_CHARS : head.split(" ").length === HEAD_WORDS;
-    if (last !== undefined && last.head === head && full) {
-      return [...acc.slice(0, -1), { head, members: [...last.members, sentence] }];
+    const joins = last !== undefined && last.head === head && last.container === container && !listBetween(last.members.at(-1), sentence, lists);
+    if (last !== undefined && joins && full) {
+      return [...acc.slice(0, -1), { head, container, members: [...last.members, sentence] }];
     }
-    return [...acc, { head, members: [sentence] }];
+    return [...acc, { head, container, members: [sentence] }];
   }, []);
 
 export const repeatedHead: Detector = (doc, options): Finding[] =>
-  runsOf(doc.sentences, doc.lengthUnit)
+  runsOf(doc.sentences, doc.lengthUnit, doc.listSpans)
     .filter((run) => run.members.length > options.limit)
     .map((run) => ({
       rule: "repeated-sentence-head",

package/src/detectors/sentence-ending.ts

@@ -1,4 +1,4 @@
-import { hasPredicate, isClosed } from "../sentence-shape.ts";
+import { endingTokens, hasPredicate, isClosed } from "../sentence-shape.ts";
 import type { Detector, Finding, Sentence } from "../plugin.ts";
 
 /**
@@ -11,10 +11,14 @@ import type { Detector, Finding, Sentence } from "../plugin.ts";
  * 述語を持たないものは文として数えない。見出しの下の `MaaSサービス` のような
  * 名前だけの行がそのまま「である調」の少数派になり、実文書の誤検知はすべてこれだった。
  */
-const isSentence = (sentence: Sentence): boolean => isClosed(sentence) && hasPredicate(sentence);
+const isSentence = (sentence: Sentence): boolean => isClosed(sentence) && hasPredicate(sentence) && endingTokens(sentence).length > 0;
 
+/**
+ * 文末の語だけを見る。文の途中の引用（「ご覧ください」という表現を使う。）は文末の調子ではない。
+ * 書いた形でも原形でも当てる。「ください」の原形は「くださる」で、原形だけを見ると丁寧な文末を見落とす。
+ */
 const isPolite = (sentence: Sentence, polite: readonly string[]): boolean =>
-  (sentence.tokens ?? []).some((token) => polite.includes(token.lemma ?? token.surface));
+  endingTokens(sentence).some((token) => polite.includes(token.surface) || (token.lemma !== undefined && polite.includes(token.lemma)));
 
 export const sentenceEnding: Detector = (doc, options): Finding[] => {
   const polite = (options.lexicon ?? []).map((entry) => entry.pattern);

package/src/detectors/signals.ts

@@ -1,6 +1,9 @@
 import { proseText } from "../measure.ts";
 import { wordsOf } from "./structure.ts";
-import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
+import { compacted, placeOf } from "./gram-place.ts";
+import { notAcronymSpans } from "./acronym-context.ts";
+import { expansionAt, type ExpandedAt } from "./acronym-expansion.ts";
+import type { Detector, Finding, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
 
 const PER = 1000;
 
@@ -91,13 +94,44 @@ const gramsOf = (doc: ProseDocument): Map<string, number> => {
   return counts;
 };
 
+/** 数えたときと同じ形の文。char 単位では空白を詰めてから数えている。 */
+const gramText = (sentence: Sentence, unit: ProseDocument["lengthUnit"]): string => compacted(sentence.text, unit).text;
+
+/** 動詞と助動詞。言い回し（ることができます、it is important to）にはこれが入り、主題の名前（state and local tax）には入らない。 */
+const PREDICATE_POS = new Set(["VERB", "AUX"]);
+
+const NOUNS = new Set(["NOUN", "PROPN", "ADJ"]);
+
+/**
+ * 英語で名詞のすぐ前の動詞は、名詞を飾る語（形容詞を挟んでも同じ）（the upcoming fiscal year、the Disclosing Party、the borrow checker）で、
+ * 述語ではない。日本語の名詞の前の動詞（〜にあるコンポーネント）は言い回しの一部になるので、word 単位だけで見る。
+ */
+const modifiesNoun = (tokens: readonly Token[], index: number, unit: ProseDocument["lengthUnit"]): boolean =>
+  unit === "word" && tokens[index]?.pos === "VERB" && NOUNS.has(tokens[index + 1]?.pos ?? "");
+
+/**
+ * 語句が文の中で占める範囲に、動詞か助動詞があるか。範囲で見る。文字で探すと、同じ文の別の所の動詞「use」が、語句の中の名詞「use」に当たる。
+ * 品詞が無ければ見分けられないので、これまでどおり言い回しとして数える。
+ */
+const hasPredicate = (gram: string, sentence: Sentence, unit: ProseDocument["lengthUnit"]): boolean => {
+  if (sentence.tokens === undefined) return true;
+  const place = placeOf(compacted(sentence.text, unit), gram);
+  if (place === undefined) return true;
+  const [start, end] = [sentence.span.start + place.start, sentence.span.start + place.end];
+  const tokens = sentence.tokens;
+  return tokens.some((token, index) => PREDICATE_POS.has(token.pos) && token.span.start < end && start < token.span.end && !modifiesNoun(tokens, index, unit));
+};
+
 export const ngramRepetition: Detector = (doc, options): Finding[] => {
   if (wordsOf(doc) < FLOOR[doc.lengthUnit]) return [];
+  const sentenceWith = (gram: string): Sentence | undefined => doc.sentences.find((sentence) => gramText(sentence, doc.lengthUnit).includes(gram));
   const worst = [...gramsOf(doc).entries()]
-    .filter(([gram]) => isPhrasing(gram, doc.lengthUnit))
-    .reduce<{ gram: string; count: number }>((best, [gram, count]) => (count > best.count ? { gram, count } : best), { gram: "", count: 0 });
-  if (worst.count <= options.limit) return [];
-  const at = doc.sentences.find((sentence) => sentence.text.includes(worst.gram));
+    .filter(([gram, count]) => count > options.limit && isPhrasing(gram, doc.lengthUnit))
+    .sort(([, left], [, right]) => right - left)
+    .map(([gram, count]) => ({ gram, count, at: sentenceWith(gram) }))
+    .find(({ gram, at }) => at === undefined || hasPredicate(gram, at, doc.lengthUnit));
+  if (worst === undefined) return [];
+  const at = worst.at;
   return [
     {
       rule: "ngram-repetition",
@@ -113,69 +147,77 @@ export const ngramRepetition: Detector = (doc, options): Finding[] => {
 /**
  * 略語が初出で展開されているか。「CI」だけでは、読む人によって指すものが違う。
  * 展開は「略語の直前か直後の括弧」か「括弧の中の略語」で書かれる。
+ *
+ * & で繋いだ大文字は 1 語として読む（ATT&CK、M&IE）。割ると CK や IE が別の略語に見える。
  */
-const ACRONYM = /\b[A-Z]{2,6}\b/gu;
-
-/** 読み手が説明なしで通じると見なしてよい語。展開すると逆に読みにくい。 */
-const COMMON = new Set([
-  "OK",
-  "NG",
-  "URL",
-  "API",
-  "CSS",
-  "HTML",
-  "JSON",
-  "YAML",
-  "HTTP",
-  "HTTPS",
-  "PDF",
-  "CPU",
-  "GPU",
-  "RAM",
-  "USB",
-  "AI",
-  "ID",
-  "FAQ",
-  "PR",
-  "OS",
-  "CLI",
-  "UI",
-  "UX",
-  "SQL",
-  "CSV",
-  "XML",
-  "TODO",
-  "NOTE",
-]);
+const EDGE_BEFORE = String.raw`(?<![A-Za-z0-9_&])`;
+const EDGE_AFTER = String.raw`(?![A-Za-z0-9_&])`;
+const ACRONYM = new RegExp(String.raw`${EDGE_BEFORE}(?:[A-Z]+(?:&[A-Z]+)+|[A-Z]{2,6})${EDGE_AFTER}`, "gu");
 
 /**
- * 展開は略語の**すぐ隣**にあるときだけ認める。
- * 60 文字も見ると、同じ文のどこかに括弧があるだけで「説明済み」になり、1 件も出なくなる。
+ * 大文字で書かれていても略語ではないもの。
  *
- * 認めるのは 2 つの形。どちらも実際によく書かれる。
- *   CI（継続的インテグレーション）   略語のあとに括弧
- *   Continuous Integration (CI)      括弧の中が略語
+ * 大文字だけの語が 3 つ以上、空白と引用符だけを挟んで続くのは強調（免責の定型文など）。
+ * 強調は読点や括弧をまたいで続くので（THE AUTHOR, THE COMPANY (IF ANY)）、そういう続きを含む
+ * 「大文字以外の文字を含まない一続き」を丸ごと強調と見なす。小文字の語が挟まれば切れるので、
+ * 「SRE, SLO, MTTR」のような略語の並びは残る。引用符に包まれた大文字の句（“AS IS”）も強調。
  */
-const OPENS = /^\s*[(（]/u;
-const CLOSES = /^\s*[)）]/u;
-const OPENED = /[(（]\s*$/u;
-
-const isExpanded = (body: string, acronym: string): boolean => {
-  const at = body.indexOf(acronym);
-  if (at === -1) return false;
-  const after = body.slice(at + acronym.length, at + acronym.length + 3);
-  const before = body.slice(Math.max(0, at - 3), at);
-  return OPENS.test(after) || (OPENED.test(before) && CLOSES.test(after));
-};
+const CAPS_WORD = String.raw`[A-Z]+(?:&[A-Z]+)*`;
+const SHOUTED_RUN = new RegExp(String.raw`${EDGE_BEFORE}${CAPS_WORD}(?:[\s"“”'‘’]+${CAPS_WORD}){2,}${EDGE_AFTER}`, "u");
+const UNCASED_STRETCH = /(?:[A-Z]|\P{L})+/gu;
+const QUOTED_CAPS = new RegExp(String.raw`["“'‘]${CAPS_WORD}(?:\s+${CAPS_WORD})+["”'’]`, "gu");
+
+/** RFC 2119 の要件語。定義された普通の語で、1 語でも強調でも現れる。 */
+const REQUIREMENT_WORD = new RegExp(
+  String.raw`${EDGE_BEFORE}(?:(?:MUST|SHALL|SHOULD)(?:\s+NOT)?|NOT\s+RECOMMENDED|REQUIRED|RECOMMENDED|MAY|OPTIONAL)${EDGE_AFTER}`,
+  "gu",
+);
+
+/** - か . で繋がり、数字を含む識別子（AC-2、MS.TEAMS.1.1v1）。大文字の部品は略語ではない。 */
+const IDENTIFIER = /(?<![A-Za-z0-9_&.-])[A-Z0-9][A-Za-z0-9]*(?:[.-][A-Z0-9][A-Za-z0-9]*)+/gu;
+
+/** Creative Commons のライセンス名。CC と BY は 1 つの名前の部品。 */
+const LICENCE = new RegExp(String.raw`${EDGE_BEFORE}CC BY(?:-(?:SA|NC|ND))*${EDGE_AFTER}`, "gu");
+
+type Span = { readonly start: number; readonly end: number };
+
+const spanOf = (match: RegExpExecArray): Span => ({ start: match.index, end: match.index + match[0].length });
+
+const spansOf = (text: string): Span[] => [
+  ...[...text.matchAll(UNCASED_STRETCH)].filter((match) => SHOUTED_RUN.test(match[0])).map(spanOf),
+  ...[...text.matchAll(IDENTIFIER)].filter((match) => /\d/u.test(match[0])).map(spanOf),
+  ...[QUOTED_CAPS, REQUIREMENT_WORD, LICENCE].flatMap((pattern) => [...text.matchAll(pattern)].map(spanOf)),
+  ...notAcronymSpans(text),
+];
+
+type AcronymHit = { readonly word: string; readonly hit: Hit };
+
+const acronymsOf = (doc: ProseDocument): AcronymHit[] =>
+  doc.sentences.flatMap((sentence) => {
+    const excluded = spansOf(sentence.text);
+    return [...sentence.text.matchAll(ACRONYM)]
+      .filter((match) => !excluded.some((span) => span.start <= match.index && match.index + match[0].length <= span.end))
+      .map((match) => ({ word: match[0], hit: { sentence, offset: sentence.span.start + match.index } }));
+  });
+
+/**
+ * どこか 1 か所で展開してあればよい。初出が節の見出し代わりの語（「5.3. DPA.」）で、
+ * 展開がその直後の文にあることが契約書では普通にある。見るのは語として現れた所だけ（CISA の中の CI は見ない）。
+ */
+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));
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
 export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const body = bodyOf(doc);
+  const common = new Set((options.lexicon ?? []).map((entry) => entry.pattern));
   const seen = new Map<string, Hit>();
-  findIn(doc, ACRONYM).forEach((hit) => {
-    const text = /^[A-Z]{2,6}/u.exec(doc.source.slice(hit.offset, hit.offset + 6))?.[0] ?? "";
-    if (text.length > 0 && !COMMON.has(text) && !seen.has(text)) seen.set(text, hit);
+  acronymsOf(doc).forEach(({ word, hit }) => {
+    if (!common.has(word) && !seen.has(word)) seen.set(word, hit);
   });
-  const bare = [...seen.entries()].filter(([acronym]) => !isExpanded(body, acronym));
+  const expandedAt = expansionAt({ markers: patternsOf(doc, "definition-marker"), verbs: patternsOf(doc, "definition-verb") });
+  const bare = [...seen.entries()].filter(([acronym]) => !isExpanded(body, acronym, expandedAt));
   if (bare.length < options.limit) return [];
   return bare.map(([acronym, hit]) => ({
     rule: "undefined-acronym",
@@ -193,9 +235,29 @@ export const undefinedAcronym: Detector = (doc, options): Finding[] => {
  */
 const CONCRETE = /\d|`|https?:\/\//u;
 
+/**
+ * 見出しのない導入部は、書き出しで呼ぶ。文書の言葉なので、message がどの言語でも混ざらない。
+ * 決まった呼び名（「この節」）を置くと、英語の文書の message に日本語が入る。
+ */
+const OPENING = { word: 4, char: 12 };
+
+const openingOf = (sentence: Sentence | undefined, unit: ProseDocument["lengthUnit"]): string => {
+  const text = sentence === undefined ? "" : proseText(sentence);
+  const pieces = unit === "word" ? text.split(" ") : Array.from(text);
+  const joiner = unit === "word" ? " " : "";
+  return pieces.length <= OPENING[unit] ? pieces.join(joiner) : `${pieces.slice(0, OPENING[unit]).join(joiner)}…`;
+};
+
+/**
+ * 形態素解析が数と読んだ語（UD の NumType=Card）。漢数字の「二割」「十五分」も、算用数字と同じ具体的な数。
+ * 言い回しの「二人三脚」「一人ひとり」は、辞書が一語として持つので数にならない。品詞が無ければ、数字だけを見る。
+ */
+const hasNumeral = (section: Section): boolean =>
+  section.sentences.some((sentence) => (sentence.tokens ?? []).some((token) => token.features?.["NumType"] === "Card"));
+
 export const concreteEvidence: Detector = (doc, options): Finding[] => {
   const sections = doc.sections.filter((section) => section.sentences.length >= 3);
-  const empty = sections.filter((section) => !CONCRETE.test(doc.source.slice(section.span.start, section.span.end)));
+  const empty = sections.filter((section) => !CONCRETE.test(doc.source.slice(section.span.start, section.span.end)) && !hasNumeral(section));
   if (empty.length < options.limit) return [];
   return empty.map((section) => ({
     rule: "concrete-evidence-density",
@@ -204,7 +266,7 @@ export const concreteEvidence: Detector = (doc, options): Finding[] => {
     column: 0,
     quote: section.heading.length > 0 ? section.heading : (section.sentences[0]?.text.trim() ?? ""),
     values: {
-      word: section.heading.length > 0 ? section.heading : "この節",
+      word: section.heading.length > 0 ? section.heading : openingOf(section.sentences[0], doc.lengthUnit),
       count: empty.length,
       total: sections.length,
       limit: options.limit,

package/src/detectors/structure.ts

@@ -1,5 +1,7 @@
 import { charLength, lengthOf } from "../measure.ts";
-import type { BulletList, Detector, Finding, Paragraph, ProseDocument, Section } from "../plugin.ts";
+import type { BulletList, Detector, Finding, Paragraph, ProseDocument, Section, Span } from "../plugin.ts";
+import { dateStampIndexes, stampCandidates } from "../date-stamp.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
 
 /**
  * ばらつきは変動係数（標準偏差 ÷ 平均）で測る。
@@ -90,6 +92,21 @@ export const ruleOfThree: Detector = (doc, options): Finding[] => {
   ];
 };
 
+const dateSpans = (doc: ProseDocument): Span[] =>
+  doc.structure === undefined ? [] : inDocumentOrder(doc.structure).flatMap((node) => (node.kind === "date" ? [node.span] : []));
+
+/** 更新日の刻印（「最終更新日:」「2025年6月20日」）は前置きに数えない。木を作るのは、数えて上限を超えたときだけ。 */
+const withoutDateStamps = (doc: ProseDocument, paragraphs: readonly Paragraph[]): Paragraph[] => {
+  const labels = (doc.lexicons["date-stamp-label"] ?? []).map((entry) => entry.pattern);
+  const candidates = stampCandidates(
+    doc.source,
+    paragraphs.map((paragraph) => paragraph.span),
+    dateSpans(doc),
+  );
+  const stamps = dateStampIndexes(candidates, labels);
+  return paragraphs.filter((_, index) => !stamps.has(index));
+};
+
 /**
  * 本題に入るまでが長い。業務文書では、読み手は結論を探しに来ている。
  *
@@ -99,7 +116,9 @@ export const ruleOfThree: Detector = (doc, options): Finding[] => {
 export const preambleLength: Detector = (doc, options): Finding[] => {
   const body = doc.sections.find((section) => section.depth >= 2);
   if (body === undefined) return [];
-  const before = doc.paragraphs.filter((paragraph) => paragraph.span.start < body.span.start);
+  const all = doc.paragraphs.filter((paragraph) => paragraph.span.start < body.span.start);
+  if (all.length <= options.limit) return [];
+  const before = withoutDateStamps(doc, all);
   if (before.length <= options.limit) return [];
   const first = before[0];
   return first === undefined