chaffjs 0.13.0 → 0.15.0

package/src/number-name.ts

@@ -1,12 +1,13 @@
+import { hyphenGroups, isHyphen } from "./orthography.ts";
 import type { Span, Token } from "./plugin.ts";
 
 /**
  * 数量ではなく名前として書かれた数（番号・識別子）。鉤括弧で引いた「3.1 リサーチの原則」の節番号、※1 のような注の番号、
- * 「〒102-0094 東京都」の郵便番号は、後ろの空白が番号と題・項目の区切りで、「3回」「3 回」のような空け方の好みではない。
+ * 「〒100-8916 東京都」の郵便番号、「紀尾井町1-3 東京ガーデンテラス」の番地は、後ろの空白が番号と題・項目の区切りで、「3回」「3 回」のような空け方の好みではない。
  * 空け方を数える材料にしない。
  *
- * 形で名前と読むのは三つだけ。0 で始まる組を含むハイフンつなぎの番号、※ や鉤括弧のすぐ後ろの番号、文頭の階層つきの節番号（2.1、3.1.2）。
- * 文頭でも「223 言語」「1ターン」は数量なので、階層の無い数は文頭というだけでは名前と読まない。
+ * 形で名前と読むのは五つだけ。0 で始まる組を含むハイフンつなぎの番号、※・〒や鉤括弧のすぐ後ろの番号、市・区・町まで下りた地名のすぐ後ろのハイフンつなぎの番号、
+ * 文頭の階層つきの節番号（2.1、3.1.2）、続き番号になった行の頭の番号（白書の注）。文頭でも「223 言語」「1ターン」は数量なので、階層の無い数は文頭というだけでは名前と読まない。
  * そのうえで、すぐ後ろ（空白 1 つまで）の語が数につく語（助数詞・数・助詞・助動詞）なら数量として数え続ける（「3-5 日」「26.7 万行」）。
  * 品詞が無ければ判断せず、名前とは読まない。
  */
@@ -14,8 +15,8 @@ import type { Span, Token } from "./plugin.ts";
 /** 数と結びついて読まれる語。助数詞は NounType=Class、数は NumType=Card で渡る。 */
 const BOUND_TO_NUMBER = new Set(["ADP", "PART", "AUX", "SCONJ", "CCONJ"]);
 
-/** 番号が立つ位置の直前: 題を包む鉤括弧、注の印。 */
-const LABEL_LEAD = /[「『【※]$/u;
+/** 番号が立つ位置の直前: 題を包む鉤括弧、注の印、郵便番号の印。 */
+const LABEL_LEAD = /[「『【※〒]$/u;
 
 /** 文頭（前に空白と箇条書きの印だけ）。 */
 const LINE_HEAD = /^[\s\-*+・•]*$/u;
@@ -28,17 +29,18 @@ const SECTION_NUMBER = /^\d+(?:\.\d+)+$/u;
  * 数え続ける。三つ以上つないだもの（073-489-5909）は、orthography.ts が境目を作る前に外している。
  */
 const isHyphenIdentifier = (digits: string): boolean => {
-  const parts = digits.split("-").filter((part) => part !== "");
+  const parts = hyphenGroups(digits);
   return parts.length > 1 && parts.some((part) => part.startsWith("0"));
 };
 
-const RUN_CHAR = /[\d.-]/u;
+const DIGIT_OR_POINT = /[\d.]/u;
+const isRunChar = (char: string | undefined): boolean => DIGIT_OR_POINT.test(char ?? "") || isHyphen(char);
 
-/** at を含む、数字・小数点・ハイフンの並び。at が並びの中に無ければ undefined。 */
+/** at を含む、数字・小数点・ハイフン（全角の「－」なども）の並び。at が並びの中に無ければ undefined。 */
 export const digitRunAround = (text: string, at: number): Span | undefined => {
-  if (!RUN_CHAR.test(text[at] ?? "")) return undefined;
-  const startAt = (index: number): number => (index > 0 && RUN_CHAR.test(text[index - 1] ?? "") ? startAt(index - 1) : index);
-  const endAt = (index: number): number => (index < text.length && RUN_CHAR.test(text[index] ?? "") ? endAt(index + 1) : index);
+  if (!isRunChar(text[at])) return undefined;
+  const startAt = (index: number): number => (index > 0 && isRunChar(text[index - 1]) ? startAt(index - 1) : index);
+  const endAt = (index: number): number => (index < text.length && isRunChar(text[index]) ? endAt(index + 1) : index);
   return { start: startAt(at), end: endAt(at) };
 };
 
@@ -51,6 +53,44 @@ const wordAfter = (tokens: readonly Token[], text: string, run: Span, base: numb
 const isBoundToNumber = (token: Token): boolean =>
   token.features?.["NounType"] === "Class" || token.features?.["NumType"] === "Card" || BOUND_TO_NUMBER.has(token.pos);
 
+/** 「1 又は 2」の接続詞は数どうしをつなぐが、続き番号の注の本文は「31 ただし、…」のように接続詞でも始まる。 */
+const CONJUNCTIONS = new Set(["CCONJ", "SCONJ"]);
+
+/**
+ * 白書の注（「9 首相に…」「10 日本経済新聞…」）のように、行の頭に階層の無い番号を置き、次の行の頭の番号が 1 つ大きいもの。
+ * 一行だけ見ると「223 言語に対応」と区別がつかないので、前後の番号の行と続き番号になっているものだけを番号と読む。
+ * 後ろが英字（「15 Federal Bureau…」）の行も並びには数える。値は行の頭の位置（文書全体の座標）。
+ */
+const NUMBERED_LINE = /^[ \t]*(?:[-*+][ \t]+)?(?<number>\d{1,3})[ \t]+\S/gmu;
+
+export const sequenceLabelStarts = (text: string): ReadonlySet<number> => {
+  const lines = [...text.matchAll(NUMBERED_LINE)].map((match) => {
+    const number = match.groups?.["number"] ?? "";
+    return { start: match.index + match[0].indexOf(number), value: Number(number) };
+  });
+  const continues = (index: number): boolean =>
+    lines[index - 1]?.value === (lines[index]?.value ?? 0) - 1 || lines[index + 1]?.value === (lines[index]?.value ?? 0) + 1;
+  return new Set(lines.flatMap((line, index) => (continues(index) ? [line.start] : [])));
+};
+
+const isGeoUnit = (token: Token): boolean => token.features?.["NameType"] === "GeoUnit";
+const isPlaceWord = (token: Token): boolean => isGeoUnit(token) || token.features?.["NameType"] === "Geo";
+
+/** end で終わる、間を空けずに続く地名と地名の単位（東京都千代田区紀尾井町）。近いほうから。 */
+export const placeChainBefore = (tokens: readonly Token[], end: number): Token[] => {
+  const last = tokens.find((token) => token.span.end === end && isPlaceWord(token));
+  return last === undefined ? [] : [last, ...placeChainBefore(tokens, last.span.start)];
+};
+
+/**
+ * 住所の番地（千代田区紀尾井町1-3、霞が関2-1）。都道府県より下の単位（市・区・町）まで下りた地名のすぐ後ろの、ハイフンつなぎの番号。
+ * 地名だけ（北海道2-3 営業日）や都道府県まで（東京都2-3 営業日）の後ろは、地域ごとの範囲のことがあるので読まない。
+ * ハイフンの無い数（千代田区23 番）も読まない。topUnits は都道府県の単位（語彙表 prefecture-unit）。
+ */
+const isAddressNumber = (text: string, run: Span, tokens: readonly Token[], base: number, topUnits: ReadonlySet<string>): boolean =>
+  [...text.slice(run.start, run.end)].some(isHyphen) &&
+  placeChainBefore(tokens, base + run.start).some((token) => isGeoUnit(token) && !topUnits.has(token.surface));
+
 /** ハイフンでつないだ識別子か、番号の立つ位置の番号か、文頭の節番号か。 */
 const isNameShaped = (text: string, run: Span): boolean => {
   const [before, digits] = [text.slice(0, run.start), text.slice(run.start, run.end)];
@@ -58,11 +98,21 @@ const isNameShaped = (text: string, run: Span): boolean => {
 };
 
 /**
- * text の run が名前として書かれた数か。tokens は文書全体の座標で、base は text の先頭の位置。
+ * text の run が名前として書かれた数か。tokens は文書全体の座標で、base は text の先頭の位置。sequence は sequenceLabelStarts の結果、
+ * topUnits は都道府県の単位。
  * 後ろの語が読めない（品詞が無い、語の切れ目が合わない）ときは、数量として数え続ける。
  */
-export const isNumberName = (text: string, run: Span, tokens: readonly Token[] | undefined, base: number): boolean => {
-  if (tokens === undefined || !isNameShaped(text, run)) return false;
+export const isNumberName = (
+  text: string,
+  run: Span,
+  tokens: readonly Token[] | undefined,
+  base: number,
+  sequence: ReadonlySet<number> = new Set(),
+  topUnits: ReadonlySet<string> = new Set(),
+): boolean => {
+  const inSequence = sequence.has(base + run.start);
+  if (tokens === undefined || !(inSequence || isNameShaped(text, run) || isAddressNumber(text, run, tokens, base, topUnits))) return false;
   const next = wordAfter(tokens, text, run, base);
-  return next !== undefined && !isBoundToNumber(next);
+  if (next === undefined) return false;
+  return !isBoundToNumber(next) || (inSequence && CONJUNCTIONS.has(next.pos));
 };

package/src/orthography.ts

@@ -125,22 +125,28 @@ const isOrdinalRun = (chars: readonly string[], index: number): boolean => {
 };
 
 /**
- * 「073-489-5909」「2026-06-02」「Ⅰ-4-1-3」のように - でつないだ 3 組以上の数字は、電話番号・日付・図の番号で
+ * 「073-489-5909」「2026-06-02」「Ⅰ-4-1-3」「5－1－1」のように - でつないだ 3 組以上の数字は、電話番号・日付・図や項目の番号で
  * 数量ではない。後ろの空白は欄の区切りで、「3回」の空け方とは別のもの。両側とも数えない。
  * 2 組（「1-3ヶ月」「20-30分」）は幅のある数量なので数える。
  */
 const MIN_CODE_GROUPS = 3;
-const CODE_CHAR = /[\d-]/u;
+
+// 通達の「5－1－1」は全角の「－」でつなぐ。ハイフン「‐」やマイナス「−」も同じに読む。長音「ー」は仮名の一部なので入れない。
+const HYPHEN = /[-‐‑−－]/u;
+
+/** 数字をつなぐハイフンか。半角の - のほか、全角・和文のハイフンも。 */
+export const isHyphen = (char: string | undefined): boolean => char !== undefined && HYPHEN.test(char);
+
+/** ハイフンで区切った組（空の組は除く）。「5－1－1」は ["5", "1", "1"]。 */
+export const hyphenGroups = (text: string): string[] => text.split(HYPHEN).filter((group) => group !== "");
+
+const isCodeChar = (char: string | undefined): boolean => DIGIT.test(char ?? "") || isHyphen(char);
 
 const isCode = (chars: readonly string[], digit: number): boolean => {
   let [first, last] = [digit, digit];
-  while (first > 0 && CODE_CHAR.test(chars[first - 1] ?? "")) first -= 1;
-  while (last < chars.length - 1 && CODE_CHAR.test(chars[last + 1] ?? "")) last += 1;
-  const groups = chars
-    .slice(first, last + 1)
-    .join("")
-    .split("-");
-  return groups.filter((group) => group !== "").length >= MIN_CODE_GROUPS;
+  while (first > 0 && isCodeChar(chars[first - 1])) first -= 1;
+  while (last < chars.length - 1 && isCodeChar(chars[last + 1])) last += 1;
+  return hyphenGroups(chars.slice(first, last + 1).join("")).length >= MIN_CODE_GROUPS;
 };
 
 /** 日本語との境目にある数字が、数えない書き方（「第3条」の番地、「073-489-5909」の符号）か。 */

package/src/plain-source.ts

@@ -0,0 +1,5 @@
+/**
+ * The Markdown parser drops a leading BOM and reads a lone "\r" as a line break; the rest of chaff counts "\n" only.
+ * Reading the file this way keeps every offset, line and column on the text the writer sees.
+ */
+export const plainSource = (raw: string): string => raw.replace(/^\uFEFF/u, "").replace(/\r\n?/gu, "\n");

package/src/plugin.ts

@@ -8,7 +8,16 @@ export type Span = { readonly start: number; readonly end: number };
  * token の span は文の span と同じ座標系（segment に渡した文字列の先頭が 0）。
  * 2 つの基準を混ぜると、ずれたときに どちらが悪いか分からなくなる。
  */
-export type Sentence = { readonly span: Span; readonly text: string; readonly tokens?: readonly Token[] };
+export type Sentence = {
+  readonly span: Span;
+  readonly text: string;
+  readonly tokens?: readonly Token[];
+  /**
+   * 行の折り返しで語の途中に入った改行（前後の行頭・行末の空白ごと）。span と同じ座標系。chaff が入れる。
+   * tokens は全角どうしに挟まれた段落内の改行を除いた文字列から作るので、改行をまたぐ語の span は改行ごと覆い、surface より長い。
+   */
+  readonly wrapBreaks?: readonly Span[];
+};
 
 /**
  * 品詞は Universal Dependencies の UPOS に統一する。アダプタ独自の体系を露出させない。
@@ -20,6 +29,8 @@ export type Token = {
   readonly surface: string;
   readonly pos: string;
   readonly lemma?: string;
+  /** 書いた形の読み（日本語はカタカナ）。表記の違う同じ語（下さい・ください）を同じと見るため。読めない adapter は持たない。 */
+  readonly reading?: string;
   readonly features?: Readonly<Record<string, string>>;
 };
 
@@ -131,7 +142,10 @@ export type StructurePatterns = {
   readonly numbered: (line: string, context: NumberingContext) => NumberedLine | undefined;
   /** 定義。attrs.term に定義された語。 */
   readonly definitions: (text: string) => readonly Mention[];
-  /** 参照。attrs.target に正規化した番地（"12.1"）、attrs.label に書かれたまま。 */
+  /**
+   * 参照。attrs.target に正規化した番地（"12.1"）、attrs.label に書かれたまま。他の文書を指すなら attrs.document にその名。
+   * 書き方だけでは他の文書か決まらない角括弧の語は attrs.citedTag に入れ、文書がその語を一覧に載せていれば core が他の文書とみなす。
+   */
   readonly references: (text: string) => readonly Mention[];
   /** 義務・禁止・許可。attrs.marker に語、attrs.type に must / must-not / may。 */
   readonly obligations: (text: string) => readonly Mention[];
@@ -154,6 +168,11 @@ export type StructurePatterns = {
    * 数字と点だけの通し番号は core が言語を問わず読むので、それを数量と見分けられるのは言語パッケージだけ。
    */
   readonly countedAfter?: (number: string, rest: string) => boolean;
+  /**
+   * 本文の行頭の「3.11.0 を公開しました。」の 3.11.0 は、文の中の数で通し番号ではない。番号と後ろの文字列を渡し、文の続き
+   * （日本語なら助詞で始まる）なら true。小文字で始まる続きは core が言語を問わず読む。
+   */
+  readonly continuesSentence?: (number: string, rest: string) => boolean;
   /** 数の書き方（「二十二」「3」）を数にする。相対の参照の「前二項」「前条第二項」が使う。 */
   readonly number?: (text: string) => number | undefined;
 };
@@ -289,6 +308,8 @@ export type ProseDocument = {
   readonly paragraphs: readonly Paragraph[];
   /** 箇条書き 1 つ。項目の数と長さのばらつきを見る rule が使う。 */
   readonly lists: readonly BulletList[];
+  /** リンク（`[text](url)`、`<https://…>`、`[text][ref]`）の範囲。行き先が相対パスでもページ内でも、読み手が辿れる出典。 */
+  readonly links: readonly Span[];
   /** アダプタが持つ語彙表と、チームが chaff.yaml に足した語彙表。detector は出所を知らない。 */
   readonly lexicons: Readonly<Record<string, Lexicon>>;
   /** この種類の文書に無いと困る見出し。チームが chaff.yaml で決める。 */

package/src/preamble-paragraphs.ts

@@ -0,0 +1,9 @@
+import type { Paragraph } from "./plugin.ts";
+import { isClosed } from "./sentence-shape.ts";
+
+/**
+ * 本題の前にあって、読み手が読み通す段落。文が一つも終止符で閉じない段落は数えない。
+ * 分類の札（「エネルギー・環境」）、著者と所属の行、「印刷」、テンプレートの指示は文ではなく、読ませる前置きではない。
+ */
+export const preambleParagraphs = (paragraphs: readonly Paragraph[], bodyStart: number): Paragraph[] =>
+  paragraphs.filter((paragraph) => paragraph.span.start < bodyStart && paragraph.sentences.some(isClosed));

package/src/quoted-span.ts

@@ -0,0 +1,25 @@
+import type { Span } from "./plugin.ts";
+
+/** 鉤括弧の開きと、それを閉じる字。 */
+const CLOSER: Readonly<Record<string, string>> = { "「": "」", "『": "』" };
+
+type Open = { readonly closer: string; readonly at: number };
+type Scan = { readonly open: readonly Open[]; readonly spans: readonly Span[] };
+
+const step = (scan: Scan, char: string, at: number): Scan => {
+  const closer = CLOSER[char];
+  if (closer !== undefined) return { open: [...scan.open, { closer, at }], spans: scan.spans };
+  const last = scan.open.at(-1);
+  if (last === undefined || last.closer !== char) return scan;
+  return { open: scan.open.slice(0, -1), spans: [...scan.spans, { start: last.at + 1, end: at }] };
+};
+
+/**
+ * 鉤括弧（「」『』）の中身の位置。括弧そのものは含まない。入れ子はそれぞれを返す。
+ * 閉じない括弧と、開きと組にならない閉じ括弧は中身を作らない。位置は text の先頭を 0 とする。
+ * 括弧は BMP の字なので、UTF-16 の 1 単位ずつ見れば位置がそのまま使える。
+ */
+export const quotedSpans = (text: string): Span[] => [...text.split("").reduce<Scan>((scan, char, at) => step(scan, char, at), { open: [], spans: [] }).spans];
+
+/** inner が、spans のどれかにまるごと入っているか。 */
+export const isWithinAny = (spans: readonly Span[], inner: Span): boolean => spans.some((span) => inner.start >= span.start && inner.end <= span.end);

package/src/render/eval.ts

@@ -1,62 +1,125 @@
-import { MIN_CORPUS, TARGET_HIT_RATE, type RuleReport } from "../eval.ts";
+import { MIN_CORPUS, TARGET_HIT_RATE, type Point, type RuleReport } from "../eval.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
 
 const pct = (part: number, whole: number): string => `${((part / Math.max(1, whole)) * 100).toFixed(1)}%`;
 
-const mark = (report: RuleReport, limit: number): string => {
-  if (limit === report.current && limit === report.recommended) return "  ← 現在 / 推奨";
-  if (limit === report.current) return "  ← 現在";
-  if (limit === report.recommended) return "  ← 推奨";
+const TARGET = TARGET_HIT_RATE * 100;
+
+/** In the English hint, a rule's line sits one YAML level under `rules:`. */
+const EN_CONFIG_LEAD = "    In chaff.yaml:  ";
+const YAML_INDENT = 2;
+
+const TEXT: Texts<{
+  readonly current: string;
+  readonly recommended: string;
+  readonly both: string;
+  readonly point: (point: Point, share: string) => string;
+  readonly fits: string;
+  readonly nothingFits: string;
+  readonly over: (share: string) => string;
+  readonly recommend: (limit: number) => string;
+  readonly toConfig: (rule: string, limit: number) => string;
+  readonly measured: (paths: number, rules: number) => string;
+  readonly premise: readonly string[];
+  readonly smallCorpus: (total: number) => readonly string[];
+  readonly untouched: string;
+}> = {
+  ja: {
+    current: "  ← 現在",
+    recommended: "  ← 推奨",
+    both: "  ← 現在 / 推奨",
+    point: (point, share) =>
+      `${String(point.documents).padStart(3)} 文書 (${share.padStart(6)})   指摘 ${String(point.findings).padStart(3)} 件   1万字あたり ${point.per10k.toFixed(1)}`,
+    fits: `    いまの閾値で目標（${TARGET}% 未満）を満たしています。`,
+    nothingFits: `    どの閾値でも目標を満たしません。この corpus に対して rule 自体が合っていない可能性があります。`,
+    over: (share) => `    いまの閾値では ${share} の文書が該当し、目標（${TARGET}% 未満）を超えています。`,
+    recommend: (limit) => `    推奨: ${limit}`,
+    toConfig: (rule, limit) => `    chaff.yaml に書くなら:  rules:\n                              ${rule}: ${limit}`,
+    measured: (paths, rules) => `  ${paths} ファイルを corpus として ${rules} 本の rule を測りました。`,
+    premise: [
+      "  ここにある文書は「人間が書いて公開した良い文書」として扱っています。",
+      `  そこで多く発火する rule は、閾値が現実に合っていない疑いがあります（目標: ${TARGET}% 未満）。`,
+    ],
+    smallCorpus: (total) => [
+      `  ※ corpus が ${total} 文書しかありません。${TARGET}% を表すには ${MIN_CORPUS} 文書以上が要ります。`,
+      "     いまは割合が「0 か全部」に振れるので、右端の密度（1万字あたりの指摘数）のほうを見てください。",
+    ],
+    untouched: `  閾値は自動で書き換えていません。corpus が変われば答えも変わるためです。`,
+  },
+  en: {
+    current: "  ← current",
+    recommended: "  ← recommended",
+    both: "  ← current / recommended",
+    point: (point, share) =>
+      `${String(point.documents).padStart(3)} ${point.documents === 1 ? "doc " : "docs"} (${share.padStart(6)})   ${String(point.findings).padStart(3)} ${point.findings === 1 ? "finding " : "findings"}   ${point.per10k.toFixed(1)} per 10,000 characters`,
+    fits: `    The current limit meets the target (under ${TARGET}%).`,
+    nothingFits: "    No limit meets the target. The rule itself may not suit this corpus.",
+    over: (share) => `    At the current limit ${share} of the documents are hit, over the target (under ${TARGET}%).`,
+    recommend: (limit) => `    Recommended: ${limit}`,
+    toConfig: (rule, limit) => `${EN_CONFIG_LEAD}rules:\n${" ".repeat(EN_CONFIG_LEAD.length + YAML_INDENT)}${rule}: ${limit}`,
+    measured: (paths, rules) => `  Measured ${rules} rule${rules === 1 ? "" : "s"} on ${paths} file${paths === 1 ? "" : "s"} as a corpus.`,
+    premise: [
+      "  The documents here are taken as good documents that people wrote and published.",
+      `  A rule that fires often on them may have a limit that does not fit real writing (target: under ${TARGET}%).`,
+    ],
+    smallCorpus: (total) => [
+      `  Note: the corpus has only ${total} document${total === 1 ? "" : "s"}. Showing ${TARGET}% takes at least ${MIN_CORPUS}.`,
+      "     For now each share is either 0 or all, so read the density on the right (findings per 10,000 characters).",
+    ],
+    untouched: "  No limit was changed. A different corpus gives a different answer.",
+  },
+};
+
+type EvalText = (typeof TEXT)[UiLanguage];
+
+const mark = (report: RuleReport, limit: number, text: EvalText): string => {
+  if (limit === report.current && limit === report.recommended) return text.both;
+  if (limit === report.current) return text.current;
+  if (limit === report.recommended) return text.recommended;
   return "";
 };
 
-const sweepLines = (report: RuleReport): string[] =>
-  report.sweep.map((point) => {
-    const limit = String(point.limit).padStart(6);
-    const docs = `${String(point.documents).padStart(3)} 文書`;
-    const density = `1万字あたり ${point.per10k.toFixed(1)}`;
-    return `    ${limit}   ${docs} (${pct(point.documents, report.total).padStart(6)})   指摘 ${String(point.findings).padStart(3)} 件   ${density}${mark(report, point.limit)}`;
-  });
+const sweepLines = (report: RuleReport, text: EvalText): string[] =>
+  report.sweep.map(
+    (point) => `    ${String(point.limit).padStart(6)}   ${text.point(point, pct(point.documents, report.total))}${mark(report, point.limit, text)}`,
+  );
 
-const verdict = (report: RuleReport): string[] => {
+const verdict = (report: RuleReport, text: EvalText): string[] => {
   const now = report.sweep.find((point) => point.limit === report.current);
   const rate = now === undefined ? 0 : now.documents / Math.max(1, report.total);
-  if (rate <= TARGET_HIT_RATE) return [`    いまの閾値で目標（${TARGET_HIT_RATE * 100}% 未満）を満たしています。`];
-  if (report.recommended === undefined) {
-    return [`    どの閾値でも目標を満たしません。この corpus に対して rule 自体が合っていない可能性があります。`];
-  }
-  return [
-    `    いまの閾値では ${pct(now?.documents ?? 0, report.total)} の文書が該当し、目標（${TARGET_HIT_RATE * 100}% 未満）を超えています。`,
-    `    推奨: ${report.recommended}`,
-    "",
-    `    chaff.yaml に書くなら:  rules:\n                              ${report.rule}: ${report.recommended}`,
-  ];
+  if (rate <= TARGET_HIT_RATE) return [text.fits];
+  if (report.recommended === undefined) return [text.nothingFits];
+  return [text.over(pct(now?.documents ?? 0, report.total)), text.recommend(report.recommended), "", text.toConfig(report.rule, report.recommended)];
 };
 
-const block = (report: RuleReport): string[] => ["", `  ${report.name}   (${report.rule})`, "", ...sweepLines(report), "", ...verdict(report), ""];
+const block = (report: RuleReport, text: EvalText): string[] => [
+  "",
+  `  ${report.name}   (${report.rule})`,
+  "",
+  ...sweepLines(report, text),
+  "",
+  ...verdict(report, text),
+  "",
+];
 
 /**
  * 閾値は自動で書き換えない。提示して選ばせる。
  * 較正は corpus に対する答えであって、正解ではないため。
  */
-export const renderEval = (reports: readonly RuleReport[], total: number, paths: number): string =>
-  [
+export const renderEval = (reports: readonly RuleReport[], total: number, paths: number, ui: UiLanguage): string => {
+  const text = TEXT[ui];
+  return [
     "",
-    `  ${paths} ファイルを corpus として ${reports.length} 本の rule を測りました。`,
+    text.measured(paths, reports.length),
     "",
-    "  ここにある文書は「人間が書いて公開した良い文書」として扱っています。",
-    `  そこで多く発火する rule は、閾値が現実に合っていない疑いがあります（目標: ${TARGET_HIT_RATE * 100}% 未満）。`,
-    ...(total < MIN_CORPUS
-      ? [
-          "",
-          `  ※ corpus が ${total} 文書しかありません。${TARGET_HIT_RATE * 100}% を表すには ${MIN_CORPUS} 文書以上が要ります。`,
-          "     いまは割合が「0 か全部」に振れるので、右端の密度（1万字あたりの指摘数）のほうを見てください。",
-        ]
-      : []),
-    ...reports.flatMap(block),
+    ...text.premise,
+    ...(total < MIN_CORPUS ? ["", ...text.smallCorpus(total)] : []),
+    ...reports.flatMap((report) => block(report, text)),
     "  " + "─".repeat(58),
     "",
-    `  閾値は自動で書き換えていません。corpus が変われば答えも変わるためです。`,
+    text.untouched,
     "",
   ]
     .join("\n")
     .replace(/\{total\}/gu, String(total));
+};

package/src/resolve-genre.ts

@@ -0,0 +1,20 @@
+import { applyByPath } from "./config/by-path.ts";
+import type { Config } from "./config/load.ts";
+import type { GenreSource } from "./cli-text.ts";
+import { frontMatterGenre, GENRES, guessGenre } from "./genre.ts";
+import { unknownFrontMatterGenre } from "./genre-check.ts";
+
+/** unread: a genre the front matter wrote that chaff does not know, when the front matter was looked at. */
+type ResolvedGenre = { readonly genre: string; readonly from: GenreSource; readonly unread?: string | undefined };
+
+export const resolveGenre = (path: string, source: string, config: Config, cliGenre?: string): ResolvedGenre => {
+  // コマンドで指定したものが最優先。その実行だけの指定だから、設定より強い。
+  if (cliGenre !== undefined) return { genre: cliGenre, from: "--genre" };
+  // パスごとの上書きが次。「全体はこう、ここだけは違う」を書けるようにする。
+  const override = applyByPath(config.byPath, config.baseDir, path);
+  if (override.genre !== undefined) return { genre: override.genre, from: "by_path" };
+  if (config.genre !== undefined) return { genre: config.genre, from: "config" };
+  const guess = guessGenre(path, source, frontMatterGenre(source));
+  const unread = unknownFrontMatterGenre(source, GENRES);
+  return guess === undefined ? { genre: "blog/tech", from: "default", unread } : { genre: guess.genre, from: guess.from, unread };
+};

package/src/soft-break.ts

@@ -0,0 +1,94 @@
+import type { Span } from "./plugin.ts";
+
+/**
+ * 段落の中の改行のうち、読み手には見えないもの。
+ *
+ * Markdown は段落の中の改行を空白として表示するが、全角の文字に挟まれた改行は空白にもならずに消える
+ * （CSS Text 3 の segment break transformation。ブラウザがそう描く）。日本語は語の間に空白を置かないので、
+ * PDF から写した判決や、行の途中で折り返して書いた段落をそのまま解析器に渡すと、改行が語を割る（「関」「する」）。
+ * 英字・数字・ハングルに接する改行は、読み手にも空白に見えるので残す。
+ */
+const WIDE = /[\p{scx=Han}\p{scx=Hiragana}\p{scx=Katakana}、-〿！-｠￠-￦]/u;
+
+const NEWLINE = /\n/gu;
+const isHorizontalSpace = (unit: string | undefined): boolean => unit === " " || unit === "\t";
+
+/** 改行の前に空白が 2 つ以上あれば、Markdown の強制改行（hard line break）。読み手にも改行に見える。 */
+const HARD_BREAK_SPACES = 2;
+
+const isLowSurrogate = (unit: number): boolean => unit >= 0xdc00 && unit <= 0xdfff;
+
+/** index の直前の 1 文字（サロゲートペアは 2 単位で 1 文字）。 */
+const charBefore = (text: string, index: number): string => {
+  const width = index >= 2 && isLowSurrogate(text.charCodeAt(index - 1)) ? 2 : 1;
+  return text.slice(Math.max(0, index - width), index);
+};
+
+const charAt = (text: string, index: number): string => {
+  const point = text.codePointAt(index);
+  return point === undefined ? "" : String.fromCodePoint(point);
+};
+
+/** 改行を挟む 2 文字が、改行を消して読む組か。 */
+export const joinsAcrossBreak = (before: string, after: string): boolean => WIDE.test(before) && WIDE.test(after);
+
+/** from から back の向きに、空白（スペース・タブ）が続く先。 */
+const spacesUntil = (text: string, from: number, step: 1 | -1): number => {
+  let at = from;
+  while (isHorizontalSpace(text[step === 1 ? at : at - 1])) at += step;
+  return at;
+};
+
+/** 改行 1 つと、その前の行末・後ろの行頭の空白。正規表現で取ると、空白の長い並びで後戻りが増える。 */
+const lineBreakAt = (text: string, newline: number): { readonly span: Span; readonly trailingSpaces: number } => {
+  const lineEnd = text[newline - 1] === "\r" ? newline - 1 : newline;
+  const start = spacesUntil(text, lineEnd, -1);
+  return { span: { start, end: spacesUntil(text, newline + 1, 1) }, trailingSpaces: lineEnd - start };
+};
+
+const isSoft = (text: string, found: { readonly span: Span; readonly trailingSpaces: number }): boolean =>
+  found.trailingSpaces < HARD_BREAK_SPACES && joinsAcrossBreak(charBefore(text, found.span.start), charAt(text, found.span.end));
+
+/** text の中の、消える改行（前後の行頭・行末の空白ごと）。text の文字だけで決める。 */
+export const softBreaks = (text: string): Span[] =>
+  [...text.matchAll(NEWLINE)]
+    .map((match) => lineBreakAt(text, match.index))
+    .filter((found) => isSoft(text, found))
+    .map((found) => found.span);
+
+/**
+ * 覆った文字（コード・リンクの記号・URL）に触れない、消える改行。source と prose は同じ長さで、同じ位置に同じ文字がある。
+ *
+ * 覆った文字は空白になっているので、prose だけでは行頭のインデントとインラインコードの跡を見分けられない。
+ * 見分けずにつなぐと、行頭の `npm` の前後の語が 1 語になる。
+ */
+export const unmaskedSoftBreaks = (source: string, prose: string): Span[] =>
+  softBreaks(prose).filter((span) => source.slice(span.start, span.end) === prose.slice(span.start, span.end));
+
+/** breaks（text の中の範囲、昇順・重ならない）を取り除いた文字列。 */
+export const withoutSpans = (text: string, breaks: readonly Span[]): string => {
+  const parts: string[] = [];
+  const cursor = breaks.reduce((from, span) => {
+    parts.push(text.slice(from, span.start));
+    return span.end;
+  }, 0);
+  parts.push(text.slice(cursor));
+  return parts.join("");
+};
+
+/** sorted（昇順・重ならない）の中で、end が offset より後ろの最初の添字。無ければ sorted.length。 */
+export const firstEndingAfter = (sorted: readonly Span[], offset: number): number => {
+  const search = (low: number, high: number): number => {
+    if (low >= high) return low;
+    const middle = (low + high) >> 1;
+    return (sorted[middle]?.end ?? Number.POSITIVE_INFINITY) > offset ? search(low, middle) : search(middle + 1, high);
+  };
+  return search(0, sorted.length);
+};
+
+/** sorted（昇順・重ならない）のうち、outer に収まるもの。段落や文ごとに全部をなめない。 */
+export const spansWithin = <T extends Span>(sorted: readonly T[], outer: Span): T[] => {
+  const from = firstEndingAfter(sorted, outer.start);
+  const to = firstEndingAfter(sorted, outer.end);
+  return sorted.slice(from, to).filter((span) => span.start >= outer.start);
+};