chaffjs 0.8.0 → 0.10.0

package/src/feedback/excerpt.ts

@@ -0,0 +1,23 @@
+/** Lines around a line of a document, 1-based and inclusive. Only these lines go into a report. */
+export type Excerpt = { readonly from: number; readonly to: number; readonly lines: readonly string[] };
+
+export const EXCERPT_RADIUS = 2;
+
+/** Pure: the excerpts around each line, overlapping ones merged, in document order. Lines outside the document are dropped. */
+export const excerptsAround = (source: string, lines: readonly number[], radius: number = EXCERPT_RADIUS): Excerpt[] => {
+  const all = source.split("\n");
+  const ranges = [...new Set(lines)]
+    .filter((line) => line >= 1 && line <= all.length)
+    .sort((left, right) => left - right)
+    .map((line) => ({ from: Math.max(1, line - radius), to: Math.min(all.length, line + radius) }));
+  const merged = ranges.reduce<{ from: number; to: number }[]>((acc, range) => {
+    const last = acc.at(-1);
+    if (last !== undefined && range.from <= last.to + 1) {
+      last.to = Math.max(last.to, range.to);
+      return acc;
+    }
+    acc.push({ ...range });
+    return acc;
+  }, []);
+  return merged.map(({ from, to }) => ({ from, to, lines: all.slice(from - 1, to) }));
+};

package/src/orthography.ts

@@ -80,8 +80,23 @@ const leftRunBeside = (chars: readonly string[], last: number, japanese: string
   return kind === "letter" && DIGIT.test(runStart(chars, last) ?? "") ? "after-digit" : kind;
 };
 
+/**
+ * 「第3条」「第4条第2項」の数字は番地の書き方で、空けるか詰めるかの好みではない。数えると、条番号の多い文書では
+ * 「2 か所」のような普通の書き方のほうが少数に見えてしまう。「第」のすぐ後ろの数字の並びは、両側とも数えない。
+ */
+const ORDINAL_PREFIX = "第";
+
+const isOrdinalRun = (chars: readonly string[], index: number): boolean => {
+  let first = index;
+  while (first > 0 && /[\d.]/u.test(chars[first - 1] ?? "")) first -= 1;
+  const before = chars[first - 1] === " " ? first - 2 : first - 1;
+  return chars[before] === ORDINAL_PREFIX;
+};
+
 const boundaryAt = (chars: readonly string[], index: number): Omit<Boundary, "offset"> | undefined => {
   const [left, right, after] = [chars[index], chars[index + 1], chars[index + 2]];
+  const numberAfterPrefix = left === ORDINAL_PREFIX && DIGIT.test((right === " " ? after : right) ?? "");
+  if (numberAfterPrefix || (DIGIT.test(left ?? "") && isOrdinalRun(chars, index))) return undefined;
   const touching = latinBeside(left, right, "before-digit") ?? leftRunBeside(chars, index, right);
   if (touching !== undefined) return { kind: touching, spaced: false };
   if (right !== " ") return undefined;

package/src/plugin.ts

@@ -93,6 +93,11 @@ export type NumberedLine = {
   readonly label: string;
   /** 番号に続く見出し。「第3条（支払）」の「支払」。本文しか無ければ空。 */
   readonly heading: string;
+  /**
+   * 番号に付いた語（"section"、"article"）。英米の文書は Section と Article を別のものとして使うので、
+   * 参照の attrs.numbering と比べて、この文書に無い種類の番号への参照（Section で組んだ法令の中の "Article 6"）を見分ける。
+   */
+  readonly numbering?: string | undefined;
   /** 番号の後ろの文字列全部。定義や参照はここから探す。 */
   readonly rest: string;
   /**
@@ -124,6 +129,16 @@ export type StructurePatterns = {
   readonly obligations: (text: string) => readonly Mention[];
   /** 数量。attrs.value に数、attrs.unit に単位。 */
   readonly quantities: (text: string) => readonly Mention[];
+  /**
+   * 「In this section—」のように、この後の定義はいま開いている条の中でだけ通じると宣言する行なら true。
+   * その条の定義に scope: "local" が付く。定義の並びが次の行から始まるので、定義の行だけを見ても分からない。
+   */
+  readonly opensDefinitionScope?: (text: string) => boolean;
+  /**
+   * 範囲が条より広いまとまり（「In this Part—」）なら、そのまとまりの深さ（NumberedLine.depth）。
+   * そのまとまりの中の定義どうしだけを比べる。無ければ、opensDefinitionScope のとおり条の中。
+   */
+  readonly definitionScopeDepth?: (text: string) => number | undefined;
   /** 日付。attrs.value に "2024-04-01"・"2024-04"・"04-01"・"2024" のどれか。無い言語は日付を読まない。 */
   readonly dates?: (text: string) => readonly Mention[];
   /**
@@ -131,6 +146,8 @@ export type StructurePatterns = {
    * 数字と点だけの通し番号は core が言語を問わず読むので、それを数量と見分けられるのは言語パッケージだけ。
    */
   readonly countedAfter?: (number: string, rest: string) => boolean;
+  /** 数の書き方（「二十二」「3」）を数にする。相対の参照の「前二項」「前条第二項」が使う。 */
+  readonly number?: (text: string) => number | undefined;
 };
 
 export type StructureKind = "doc" | "section" | "chapter" | "article" | "item" | "definition" | "reference" | "obligation" | "quantity" | "date";
@@ -150,6 +167,8 @@ export type StructureNode = {
   readonly level?: number;
   /** 範囲をまとめた行の最後の位置（NumberedLine.ordinalTo）。S 式には出さない。 */
   readonly ordinalTo?: number;
+  /** 番号に付いた語（NumberedLine.numbering）。S 式には出さない。 */
+  readonly numbering?: string;
 };
 
 // ───────── 文書モデルと rule ─────────
@@ -175,6 +194,78 @@ export type BulletList = { readonly span: Span; readonly items: readonly number[
  * detector に渡る唯一の入り口。core が I/O を済ませてから呼ぶ。
  * detector は純関数で、fs / network / clock に触れない。spec §6。
  */
+/**
+ * 文書の種類の知識（法令の番地の書き方など）。コードは種類を知らず、profiles/*.yaml に書いたものを読む。
+ * 言語ごとに一つに絞ったもの。正規表現は文字列のまま持ち、使う側が組み立てる。
+ */
+export type DocumentProfile = {
+  readonly id: string;
+  /** 番地の書き方。漢字の連なりにも、数量にも数えない。 */
+  readonly addresses: readonly string[];
+  /** 番地と番地のあいだ、番地の後ろに付く語。 */
+  readonly connectives: readonly string[];
+  /** 番地の並びのすぐ後ろに来てよい文字（正規表現）。無ければどこで終わってもよい。 */
+  readonly addressEnd?: string | undefined;
+  /**
+   * 条の前の行に置く見出しの形（正規表現。最初の括弧の中が見出しの言葉）。法令の「（解雇の予告）」。
+   * すぐ次の行の条が見出しを持たなければ、その条の見出しになる。
+   */
+  readonly caption?: string | undefined;
+  /** 前条・同項のように、書いた場所から番地が決まる参照の読み方。無ければ読まない。 */
+  readonly relative?: RelativeVocabulary | undefined;
+  /**
+   * 番号を書かない単位（古い法令の第 2 項以降）。indent で始まる行を、inside の種類の単位の中の、depth の深さの次の単位にする。
+   * inside の単位の行に、番号の後ろの本文が続くときだけ。
+   */
+  readonly unnumbered?: { readonly indent: string; readonly inside: string; readonly depth: number } | undefined;
+};
+
+/**
+ * 相対の参照の語彙。語の意味（一つ前・一つ後・直前に引いたもの・今いるところ）はコードが知り、どの語がそれに当たるかは種類が決める。
+ * units は単位の語から木の深さ（NumberedLine.depth）への対応。
+ */
+export type RelativeVocabulary = {
+  readonly before: readonly string[];
+  readonly after: readonly string[];
+  readonly same: readonly string[];
+  readonly current: readonly string[];
+  /** 「前各項」の「各」。一つ前だけでなく、前の全部。 */
+  readonly every: readonly string[];
+  /** 「前二項」の「二」のような、いくつ分かの数の書き方（正規表現）。数は言語パッケージの number が読む。 */
+  readonly count: string;
+  readonly units: Readonly<Record<string, number>>;
+  /** 「前条第二項」の「第」。後ろに続く番地の書き出し。 */
+  readonly suffixPrefix: string;
+  /**
+   * 最初のものに番号を振らない深さ（法令の項）。あれば「第二条第一号」は 2.1.1、「第四条第一項」は第四条そのものでもある。
+   */
+  readonly implicitFirst: number | undefined;
+  /** すぐ前に来てはいけない文字（正規表現）。「事前条件」の「前条」を参照にしない。 */
+  readonly notAfter: string | undefined;
+  /**
+   * 読み替え（「『前条』とあるのは『…』」）の括弧。中の前条・同項は読み替える先の文の言葉で、ここからは決められないので読まない。
+   * 閉じの直後に after、開きの直前に before のどれかがあるものだけ。中の番地を名指しした参照は、document の名前の文書を指す。
+   */
+  readonly substitution:
+    | {
+        readonly open: string;
+        readonly close: string;
+        readonly after: readonly string[];
+        readonly before: readonly string[];
+        readonly document: string | undefined;
+      }
+    | undefined;
+  /** 条を書かずにこの単位で始まる番地（法令の「第一項」「第二号」）は、書いた場所を含むまとまりの中を指す。 */
+  readonly inside: readonly string[];
+  /**
+   * 並びをつなぐもの（正規表現。及び・若しくは・から・、・枝番号の「の二」）。すぐ前の参照とのあいだがこれとつなぎの語（connectives）と
+   * 閉じた括弧だけなら、条を書かない番地はその参照の続き。「第三十三条第七項若しくは第九項」の「第九項」は第三十三条の第九項。
+   */
+  readonly joiners: readonly string[];
+  /** 括弧書き（「（…）」）の開きと閉じ。並びの途中に挟まっても、並びを切らない。 */
+  readonly aside: { readonly open: string; readonly close: string } | undefined;
+};
+
 export type ProseDocument = {
   readonly path: string;
   readonly source: string;
@@ -196,6 +287,10 @@ export type ProseDocument = {
   readonly requiredSections: readonly string[];
   /** 番地の付いた木（§27）。adapter が structure を持たない言語では無い。 */
   readonly structure: StructureNode | undefined;
+  /** 文書の種類（法令など）。選ばれなければ無い。 */
+  readonly profile?: DocumentProfile | undefined;
+  /** 本文でないもの（コード・HTML・強調の印）を同じ長さの空白で覆った source。位置は source と同じ。 */
+  readonly prose?: string | undefined;
 };
 
 export type Severity = "error" | "warning" | "info";

package/src/profile/for-file.ts

@@ -0,0 +1,11 @@
+import { applyByPath } from "../config/by-path.ts";
+import type { Config } from "../config/load.ts";
+import type { DocumentProfile } from "../plugin.ts";
+import { loadProfiles } from "./load.ts";
+import { chooseProfile } from "./select.ts";
+
+type ProfileSettings = Pick<Config, "profile" | "byPath" | "baseDir">;
+
+/** 1 ファイルの文書の種類。by_path、chaff.yaml、内容の順に選ぶ。 */
+export const profileFor = (config: ProfileSettings, path: string, source: string, language: string): DocumentProfile | undefined =>
+  chooseProfile(loadProfiles(), { byPath: applyByPath(config.byPath, config.baseDir, path).profile, config: config.profile, source, language })?.profile;

package/src/profile/load.ts

@@ -0,0 +1,26 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "yaml";
+import { parseProfile, type ProfileDefinition } from "./parse.ts";
+
+const PROFILES_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "profiles");
+
+const loaded: { value: readonly ProfileDefinition[] | undefined } = { value: undefined };
+
+/** 同梱の profiles/*.yaml。一度だけ読む。 */
+export const loadProfiles = (): readonly ProfileDefinition[] => {
+  loaded.value ??= readdirSync(PROFILES_DIR)
+    .filter((file) => file.endsWith(".yaml"))
+    .sort((left, right) => left.localeCompare(right))
+    .flatMap((file) => {
+      const path = join(PROFILES_DIR, file);
+      try {
+        const definition = parseProfile(parse(readFileSync(path, "utf8")));
+        return definition === undefined ? [] : [definition];
+      } catch (error) {
+        throw new Error(`cannot read the profile ${path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+      }
+    });
+  return loaded.value;
+};

package/src/profile/parse.ts

@@ -0,0 +1,119 @@
+import type { DocumentProfile, RelativeVocabulary } from "../plugin.ts";
+
+/** profiles/*.yaml を一つ読んだもの。言語ごとの中身と、内容から選ぶための形を持つ。 */
+export type ProfileDefinition = {
+  readonly id: string;
+  readonly name: Readonly<Record<string, string>>;
+  readonly detect: Readonly<Record<string, ProfileDetect>>;
+  readonly languages: Readonly<Record<string, DocumentProfile>>;
+};
+
+/** この形の行が minLines 行以上あれば、その種類の文書として読む。 */
+type ProfileDetect = { readonly line: string; readonly minLines: number };
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
+
+const strings = (value: unknown): string[] => (Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === "string" && entry !== "") : []);
+
+const texts = (value: unknown): Record<string, string> =>
+  isRecord(value) ? Object.fromEntries(Object.entries(value).filter((entry): entry is [string, string] => typeof entry[1] === "string")) : {};
+
+/** 空でない文字列だけ。空の正規表現は何にでも当たる。 */
+const text = (value: unknown): string | undefined => (typeof value === "string" && value !== "" ? value : undefined);
+
+const detectOf = (value: unknown): ProfileDetect | undefined => {
+  if (!isRecord(value) || typeof value["line"] !== "string") return undefined;
+  const minLines = value["min_lines"];
+  return { line: value["line"], minLines: typeof minLines === "number" && minLines > 0 ? minLines : 1 };
+};
+
+const unitsOf = (value: unknown): Record<string, number> =>
+  isRecord(value) ? Object.fromEntries(Object.entries(value).filter((entry): entry is [string, number] => entry[0] !== "" && Number.isInteger(entry[1]))) : {};
+
+const asideOf = (value: unknown): RelativeVocabulary["aside"] => {
+  if (!isRecord(value)) return undefined;
+  const [open, close] = [text(value["open"]), text(value["close"])];
+  return open === undefined || close === undefined ? undefined : { open, close };
+};
+
+/** 括弧の開き・閉じと、目印が一つも無ければ読まない。 */
+const substitutionOf = (value: unknown): RelativeVocabulary["substitution"] => {
+  if (!isRecord(value)) return undefined;
+  const [open, close] = [text(value["open"]), text(value["close"])];
+  const [after, before] = [strings(value["after"]), strings(value["before"])];
+  return open === undefined || close === undefined || after.length + before.length === 0
+    ? undefined
+    : { open, close, after, before, document: text(value["document"]) };
+};
+
+/** 字下げと、どの種類の中か、どの深さかのどれかが無ければ読まない。 */
+const unnumberedOf = (value: unknown): DocumentProfile["unnumbered"] => {
+  if (!isRecord(value)) return undefined;
+  const [indent, inside, depth] = [text(value["indent"]), text(value["inside"]), value["depth"]];
+  return indent === undefined || inside === undefined || !Number.isInteger(depth) || typeof depth !== "number" ? undefined : { indent, inside, depth };
+};
+
+/** 単位が一つも無ければ読まない。何を指すのか決められない。 */
+const relativeOf = (value: unknown): RelativeVocabulary | undefined => {
+  if (!isRecord(value)) return undefined;
+  const units = unitsOf(value["units"]);
+  if (Object.keys(units).length === 0) return undefined;
+  return {
+    before: strings(value["before"]),
+    after: strings(value["after"]),
+    same: strings(value["same"]),
+    current: strings(value["current"]),
+    every: strings(value["every"]),
+    count: text(value["count"]) ?? "(?!)",
+    units,
+    suffixPrefix: text(value["suffix_prefix"]) ?? "",
+    implicitFirst: typeof value["implicit_first"] === "string" ? units[value["implicit_first"]] : undefined,
+    notAfter: text(value["not_after"]),
+    substitution: substitutionOf(value["substitution"]),
+    inside: strings(value["inside"]).filter((unit) => units[unit] !== undefined),
+    joiners: strings(value["joiners"]),
+    aside: asideOf(value["aside"]),
+  };
+};
+
+const LANGUAGE_KEYS = new Set(["id", "name", "why", "detect"]);
+
+const languagesOf = (id: string, raw: Record<string, unknown>): Record<string, DocumentProfile> =>
+  Object.fromEntries(
+    Object.entries(raw)
+      .filter(([key, value]) => !LANGUAGE_KEYS.has(key) && isRecord(value))
+      .map(([language, value]) => {
+        const section = isRecord(value) ? value : {};
+        const addressEnd = text(section["address_end"]);
+        const caption = text(section["caption"]);
+        const relative = relativeOf(section["relative"]);
+        const unnumbered = unnumberedOf(section["unnumbered"]);
+        return [
+          language,
+          { id, addresses: strings(section["addresses"]), connectives: strings(section["connectives"]), addressEnd, caption, relative, unnumbered },
+        ];
+      }),
+  );
+
+/** id の無いものは読まない。どの設定から選ばれたのか言えなくなるため。 */
+export const parseProfile = (raw: unknown): ProfileDefinition | undefined => {
+  if (!isRecord(raw) || typeof raw["id"] !== "string" || raw["id"] === "") return undefined;
+  const id = raw["id"];
+  const detect = isRecord(raw["detect"])
+    ? Object.fromEntries(
+        Object.entries(raw["detect"]).flatMap(([language, value]) => {
+          const found = detectOf(value);
+          return found === undefined ? [] : [[language, found] as const];
+        }),
+      )
+    : {};
+  return { id, name: texts(raw["name"]), detect, languages: languagesOf(id, raw) };
+};
+
+/** 行頭から数える。source 全体に m フラグで当てれば、行ごとに分けずに数えられる。 */
+export const detected = (definition: ProfileDefinition, source: string, language: string): boolean => {
+  const detect = definition.detect[language];
+  if (detect === undefined) return false;
+  const count = [...source.matchAll(new RegExp(detect.line, "gmu"))].length;
+  return count >= detect.minLines;
+};

package/src/profile/select.ts

@@ -0,0 +1,35 @@
+import type { DocumentProfile } from "../plugin.ts";
+import { detected, type ProfileDefinition } from "./parse.ts";
+
+/** 設定で書いた「使わない」。内容から選ぶのも止める。 */
+export const NO_PROFILE = "none";
+
+type ProfileSource = "by-path" | "config" | "content";
+
+export type ChosenProfile = { readonly profile: DocumentProfile; readonly from: ProfileSource };
+
+export type ProfileRequest = {
+  readonly byPath: string | undefined;
+  readonly config: string | undefined;
+  readonly source: string;
+  readonly language: string;
+};
+
+const named = (definitions: readonly ProfileDefinition[], id: string, language: string): DocumentProfile | undefined =>
+  definitions.find((definition) => definition.id === id)?.languages[language];
+
+/**
+ * 強いものから: by_path、chaff.yaml の profile、内容。どれかが none と書けばそこで止め、内容からも選ばない。
+ * 名前で選んだ種類にその言語の中身が無ければ選ばない。黙って別の種類にしない。
+ */
+export const chooseProfile = (definitions: readonly ProfileDefinition[], request: ProfileRequest): ChosenProfile | undefined => {
+  const written = request.byPath ?? request.config;
+  if (written === NO_PROFILE) return undefined;
+  if (written !== undefined) {
+    const profile = named(definitions, written, request.language);
+    return profile === undefined ? undefined : { profile, from: request.byPath === undefined ? "config" : "by-path" };
+  }
+  const found = definitions.find((definition) => detected(definition, request.source, request.language));
+  const profile = found?.languages[request.language];
+  return profile === undefined ? undefined : { profile, from: "content" };
+};

package/src/reasons.ts

@@ -9,6 +9,7 @@ export type Reasons = {
   readonly experimental: string;
   readonly turnedOff: string;
   readonly noStructure: (language: string) => string;
+  readonly unreadStructure: (clauses: number, units: number) => string;
   readonly noDetector: (name: string) => string;
   readonly noLexicon: (language: string, list: string) => string;
 };
@@ -27,6 +28,8 @@ export const REASONS: Texts<Reasons> = {
     experimental: "まだ試験中のため",
     turnedOff: "設定で止めているため",
     noStructure: (language) => `${language} のパッケージは文書の構造を読めないため`,
+    unreadStructure: (clauses, units) =>
+      `条項の番号が本文に ${String(clauses)} 個あるのに、番号として読めたのは ${String(units)} 個のため（深い字下げや、行が本文につながった文書）`,
     noDetector: (name) => `検出器 ${name} がないため`,
     noLexicon: (language, list) => `${language} の語彙表 ${list} が無いため`,
   },
@@ -38,6 +41,8 @@ export const REASONS: Texts<Reasons> = {
     experimental: "still experimental",
     turnedOff: "turned off in the settings",
     noStructure: (language) => `the ${language} package cannot read a document's structure`,
+    unreadStructure: (clauses, units) =>
+      `the text has ${String(clauses)} clause numbers but only ${String(units)} were read as numbered lines (deep indents, or lines run into the text)`,
     noDetector: (name) => `no detector named ${name}`,
     noLexicon: (language, list) => `the ${language} package has no word list ${list}`,
   },

package/src/render/compact.ts

@@ -2,6 +2,9 @@ import type { RuleDefinition } from "../plugin.ts";
 import type { RunResult } from "../run.ts";
 import { messageOf } from "./text.ts";
 
+/** 「1 finding」「2 findings」。 */
+const counted = (count: number, noun: string): string => `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
+
 /** エンジニア向け。1 件 2 行。 */
 export const renderCompact = (header: string, result: RunResult, rules: readonly RuleDefinition[], language: string): string => {
   const byId = new Map(rules.map((rule) => [rule.id, rule]));
@@ -11,7 +14,7 @@ export const renderCompact = (header: string, result: RunResult, rules: readonly
     const at = `${finding.line}:${finding.column}`.padEnd(8);
     return [`  ${at}${finding.severity.padEnd(8)}${messageOf(rule, finding, language)}`, `          ${" ".repeat(8)}${finding.rule}`];
   });
-  const tail = [`${result.findings.length} findings`, result.skipped.length > 0 ? `${result.skipped.length} rules not run` : undefined].filter(
+  const tail = [counted(result.findings.length, "finding"), result.skipped.length > 0 ? `${counted(result.skipped.length, "rule")} not run` : undefined].filter(
     (part) => part !== undefined,
   );
   return ["", header, "", ...lines, "", tail.join(", "), ""].join("\n");

package/src/run.ts

@@ -3,6 +3,9 @@ import { resolve } from "./levels.ts";
 import type { AdapterNeeds, Finding, Level, ProseDocument, RuleDefinition } from "./plugin.ts";
 import { lineStarts, placeOf } from "./position.ts";
 import { REASONS, type Reasons } from "./reasons.ts";
+import { joinWords } from "./detectors/word-list.ts";
+import { unreadStructure, type Unread } from "./structure/unread.ts";
+import { isMarkdownPath } from "./structure/markdown-path.ts";
 import { uiLanguageOf } from "./ui.ts";
 
 export type Skipped = { readonly rule: string; readonly why: string };
@@ -26,6 +29,39 @@ const levelFor = (rule: RuleDefinition, settings: Settings, experimental: boolea
 
 const reasonsFor = (doc: ProseDocument): Reasons => REASONS[uiLanguageOf(doc.language)];
 
+/**
+ * 構造の rule が動けない理由。木を作れない言語か、番号の行を読めなかった文書。
+ * 読めなかった文書で「参照先が無い」が 0 件なのは、確かめた結果ではないので、読めなかったと言う。
+ */
+/**
+ * 木を読む rule の要求。structure は番号の並びを読む（読めなかった文書では動かない）。dates と quantities は木の日付と数量だけを
+ * 読むので、番号を読めなかった文書でも動く。どちらも capability ではなく、adapter が木を作れるかで決まる。
+ */
+const TREE_NEEDS: ReadonlySet<string> = new Set(["structure", "dates", "quantities"]);
+const VALUE_NEEDS: readonly string[] = ["dates", "quantities"];
+
+const treeNeed = (rule: RuleDefinition, doc: ProseDocument): string | undefined => {
+  if (rule.requires.includes("structure")) return treeProblem(doc);
+  return rule.requires.some((need) => VALUE_NEEDS.includes(need)) && doc.structure === undefined ? reasonsFor(doc).noStructure(doc.language) : undefined;
+};
+
+const treeProblem = (doc: ProseDocument): string | undefined => {
+  if (doc.structure === undefined) return reasonsFor(doc).noStructure(doc.language);
+  const unread = unreadOf(doc);
+  return unread === undefined ? undefined : reasonsFor(doc).unreadStructure(unread.clauses, unread.units);
+};
+
+/** 木が読んだのと同じ本文。Markdown はコードを覆ったもの、.txt はそのまま（.txt の字下げはコードではない）。 */
+const textTheTreeRead = (doc: ProseDocument): string => (isMarkdownPath(doc.path) ? (doc.prose ?? doc.source) : doc.source);
+
+const unreadByDocument = new WeakMap<ProseDocument, Unread | undefined>();
+
+/** 文書ごとに一度だけ数える。構造の rule が三つあっても、本文を三度なめない。 */
+const unreadOf = (doc: ProseDocument): Unread | undefined => {
+  if (!unreadByDocument.has(doc)) unreadByDocument.set(doc, doc.structure === undefined ? undefined : unreadStructure(textTheTreeRead(doc), doc.structure));
+  return unreadByDocument.get(doc);
+};
+
 /** 知らない要求は満たされていないものとして扱う。黙って無視すると、要求なしで動いてしまう。 */
 const has = (capabilities: ProseDocument["capabilities"], need: string): boolean => {
   if (need === "pos") return capabilities.pos;
@@ -45,7 +81,7 @@ const hasTokens = (doc: ProseDocument): boolean => doc.sentences.length === 0 ||
 /** 要求を満たさない rule は動かせない。満たさないまま動かすと「指摘 0 件」が保証に見える。 */
 const unmet = (rule: RuleDefinition, doc: ProseDocument): string | undefined => {
   if (rule.languages !== undefined && !rule.languages.includes(doc.language)) return reasonsFor(doc).otherLanguage(doc.language);
-  const missing = rule.requires.filter((need) => need !== "structure").find((need) => !has(doc.capabilities, need));
+  const missing = rule.requires.filter((need) => !TREE_NEEDS.has(need)).find((need) => !has(doc.capabilities, need));
   if (missing !== undefined) return reasonsFor(doc).noCapability(missing);
   return undefined;
 };
@@ -84,7 +120,7 @@ const place = (starts: readonly number[], finding: Finding): Finding => {
  * 元の指摘は消さない。`padded-intro` のように単独でも正しい指摘が混ざっており、
  * まとめるために消すと本物の指摘が見えなくなる。
  */
-const compositeOf = (rule: RuleDefinition, found: readonly Finding[], limit: number, starts: readonly number[]): Finding[] => {
+const compositeOf = (rule: RuleDefinition, found: readonly Finding[], limit: number, starts: readonly number[], language: string): Finding[] => {
   const fired = rule.from.filter((id) => found.some((finding) => finding.rule === id));
   if (fired.length < limit) return [];
   const first = found.find((finding) => fired.includes(finding.rule));
@@ -95,7 +131,7 @@ const compositeOf = (rule: RuleDefinition, found: readonly Finding[], limit: num
       line: 0,
       column: 0,
       quote: first?.quote ?? "",
-      values: { word: fired.join("、"), count: fired.length, limit, offset: first === undefined ? 0 : Number(first.values["offset"] ?? 0) },
+      values: { word: joinWords(fired, language), count: fired.length, limit, offset: first === undefined ? 0 : Number(first.values["offset"] ?? 0) },
     }),
   ];
 };
@@ -135,9 +171,8 @@ export const runRules = (
       if (noTags !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: noTags }] };
       // 木は capability ではなく、adapter が structure を持つかで決まる。持たない言語で動かすと「参照先が無い」が 0 件に見える。
       // 段階を見た後で聞く。doc.structure は触れたときに木を作るので、止めている rule のために作らない。
-      if (rule.requires.includes("structure") && doc.structure === undefined) {
-        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: reasonsFor(doc).noStructure(doc.language) }] };
-      }
+      const noTree = treeNeed(rule, doc);
+      if (noTree !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: noTree }] };
       // 複合シグナルは二段目で扱う。一段目では「検出器が無い」と言わせない。
       if (rule.from.length > 0) return acc;
       const detector = DETECTORS[rule.how_to_find];
@@ -159,7 +194,7 @@ export const runRules = (
   );
   const composites = applicable
     .filter((rule) => rule.from.length > 0 && levelFor(rule, settings, experimental) !== "off")
-    .flatMap((rule) => compositeOf(rule, outcome.findings, limitFor(rule, levelFor(rule, settings, experimental), genre, limits), starts));
+    .flatMap((rule) => compositeOf(rule, outcome.findings, limitFor(rule, levelFor(rule, settings, experimental), genre, limits), starts, doc.language));
   const all = [...outcome.findings, ...composites];
   return { ...outcome, findings: [...all].sort((left, right) => left.line - right.line), forcedExperimental: forced };
 };