chaffjs 0.15.0 → 0.17.0

package/src/line-paragraphs.ts

@@ -0,0 +1,86 @@
+import type { Span } from "./plugin.ts";
+
+/**
+ * 1 行に 1 段落を書き、段落の間に空行を置かない文書（青空文庫、議事録、`<br>` で改行した HTML）。
+ * Markdown では全体が 1 つの段落になるが、書いた人にとっては行が段落。
+ *
+ * 割るのは文の終わる改行だけ。文の境目は解析器が改行をつないだ上で決めたもの（#248）なので、折り返した文は割れない。
+ * 形で見分けるのは 2 つ:
+ * - 固定幅の折り返しは、行の多くが文の途中で終わる。文で終わる行（段落の最後の行を含む）が半分に届かなければ割らない
+ *   （議事録は発言者の行と発言の行が交互に来るので、半分ちょうどは割る）。
+ * - 1 行 1 文の書き方（行を意味の切れ目で改める。英語の Markdown に多い）は、段落のつもりではない。
+ *   文の頭で始まり文の終わりで終わる行が 2 文以上を持つことが、段落を 1 行に書いた印。それがたまにしか無ければ割らない。
+ */
+
+/** 2 文以上を持つ行がこれより少なければ、1 行 1 文の書き方にたまに混じる 2 文の行と見分けられない。 */
+const MIN_MULTI_SENTENCE = 3;
+/** 2 文以上を持つ行が、割った段落の数のこの割合に届かなければ割らない。議事録は 1 文の発言が多い。 */
+const MULTI_SENTENCE_SHARE = 1 / 5;
+
+const NEWLINE = /\r?\n/gu;
+
+type Line = { readonly span: Span; readonly newline: number };
+
+/** 段落の中の行と、その行を終える改行の位置（最後の行は段落の終わり）。 */
+const linesOf = (source: string, paragraph: Span): Line[] => {
+  const text = source.slice(paragraph.start, paragraph.end);
+  const breaks = [...text.matchAll(NEWLINE)].map((match) => ({ at: paragraph.start + match.index, width: match[0].length }));
+  const starts = [paragraph.start, ...breaks.map((found) => found.at + found.width)];
+  return starts.map((start, index) => {
+    const end = breaks[index]?.at ?? paragraph.end;
+    return { span: { start, end }, newline: end };
+  });
+};
+
+/** 文の前後の空白を除いた範囲。改行が文の中にあるかを、空白でなく文字で決める。 */
+const coreOf = (source: string, sentence: Span): Span => {
+  const text = source.slice(sentence.start, sentence.end);
+  return { start: sentence.start + text.length - text.trimStart().length, end: sentence.end - (text.length - text.trimEnd().length) };
+};
+
+/** cores（並び順、重ならない）の中で、start が offset 以上の最初の添字。何万行の段落でも行ごとに全部をなめない。 */
+const firstStartingAt = (cores: readonly Span[], offset: number): number => {
+  const search = (low: number, high: number): number => {
+    if (low >= high) return low;
+    const middle = (low + high) >> 1;
+    return (cores[middle]?.start ?? Number.POSITIVE_INFINITY) >= offset ? search(low, middle) : search(middle + 1, high);
+  };
+  return search(0, cores.length);
+};
+
+/** 改行をまたぐ文が無い。またぐなら、改行の直前に始まった文がまだ続いている。 */
+const endsSentence = (line: Line, cores: readonly Span[]): boolean => (cores[firstStartingAt(cores, line.newline) - 1]?.end ?? 0) <= line.newline;
+
+/** 覆われて空白だけになった行（話し手の名前の行）は段落を終えない。終えると、文の無い段落ができる。 */
+const hasText = (source: string, line: Line): boolean => source.slice(line.span.start, line.span.end).trim().length > 0;
+
+/** 行の並びを、文の終わる改行で区切った段落。 */
+const groupAt = (lines: readonly Line[], closing: readonly boolean[]): Span[] => {
+  const firsts = lines.flatMap((_, index) => (index === 0 || closing[index - 1] === true ? [index] : []));
+  return firsts.map((first, index) => ({
+    start: lines[first]?.span.start ?? 0,
+    end: lines[(firsts[index + 1] ?? lines.length) - 1]?.span.end ?? 0,
+  }));
+};
+
+const sentencesIn = (group: Span, cores: readonly Span[]): number => firstStartingAt(cores, group.end) - firstStartingAt(cores, group.start);
+
+/** 文の頭で始まり文の終わりで終わる行のうち、2 文以上を持つもの。固定幅の折り返しでは、行の両端が偶然そろうことはまれ。 */
+const wholeMultiSentenceLines = (lines: readonly Line[], closing: readonly boolean[], cores: readonly Span[]): number =>
+  lines.filter((line, index) => (index === 0 || closing[index - 1] === true) && closing[index] === true && sentencesIn(line.span, cores) >= 2).length;
+
+/** 行ごとの段落として読む形か。 */
+const isLineShaped = (lines: readonly Line[], closing: readonly boolean[], groups: readonly Span[], cores: readonly Span[]): boolean => {
+  const closed = closing.filter(Boolean).length;
+  const multi = wholeMultiSentenceLines(lines, closing, cores);
+  return closed * 2 >= closing.length && multi >= MIN_MULTI_SENTENCE && multi >= groups.length * MULTI_SENTENCE_SHARE;
+};
+
+/** paragraph を、書いた人が段落のつもりで改めた行ごとに割る。そう読めなければ paragraph 1 つ。sentences は段落の中の文。 */
+export const lineParagraphs = (source: string, paragraph: Span, sentences: readonly Span[]): Span[] => {
+  const lines = linesOf(source, paragraph);
+  const cores = sentences.map((sentence) => coreOf(source, sentence)).filter((core) => core.end > core.start);
+  const closing = lines.map((line) => hasText(source, line) && endsSentence(line, cores));
+  const groups = groupAt(lines, closing);
+  return isLineShaped(lines, closing, groups, cores) ? groups : [paragraph];
+};

package/src/mask.ts

@@ -1,4 +1,5 @@
 import type { Span } from "./plugin.ts";
+import { mergeSpans } from "./span-merge.ts";
 
 /**
  * 非 prose（コードブロック・インラインコード・表・見出し・URL）を、
@@ -16,19 +17,8 @@ import type { Span } from "./plugin.ts";
  */
 const blankOut = (text: string): string => text.replace(/[^\n]/gu, (char) => " ".repeat(char.length));
 
-const merge = (spans: readonly Span[]): Span[] =>
-  [...spans]
-    .sort((left, right) => left.start - right.start)
-    .reduce<Span[]>((acc, span) => {
-      const last = acc.at(-1);
-      if (last !== undefined && span.start <= last.end) {
-        return [...acc.slice(0, -1), { start: last.start, end: Math.max(last.end, span.end) }];
-      }
-      return [...acc, span];
-    }, []);
-
 export const maskSpans = (source: string, spans: readonly Span[]): string => {
-  const merged = merge(spans);
+  const merged = mergeSpans(spans, true);
   const { parts, cursor } = merged.reduce<{ parts: string[]; cursor: number }>(
     (acc, span) => ({
       parts: [...acc.parts, source.slice(acc.cursor, span.start), blankOut(source.slice(span.start, span.end))],

package/src/number-name.ts

@@ -88,7 +88,7 @@ export const placeChainBefore = (tokens: readonly Token[], end: number): Token[]
  * ハイフンの無い数（千代田区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) &&
+  Array.from(text.slice(run.start, run.end)).some(isHyphen) &&
   placeChainBefore(tokens, base + run.start).some((token) => isGeoUnit(token) && !topUnits.has(token.surface));
 
 /** ハイフンでつないだ識別子か、番号の立つ位置の番号か、文頭の節番号か。 */

package/src/opening-line.ts

@@ -0,0 +1,17 @@
+import { plainSource } from "./plain-source.ts";
+
+const FRONT_MATTER_FENCE = "---";
+/** An ATX heading; four spaces of indent make it a code line instead. */
+const HEADING = /^ {0,3}#{1,6}(?:\s|$)/u;
+
+/** The lines after a leading front matter block. */
+const bodyLines = (lines: readonly string[]): readonly string[] => {
+  const close = lines[0] === FRONT_MATTER_FENCE ? lines.indexOf(FRONT_MATTER_FENCE, 1) : -1;
+  return close === -1 ? lines : lines.slice(close + 1);
+};
+
+/** The line a document's body opens with (a letter's salutation), past front matter, blank lines and Markdown headings. */
+export const openingLine = (source: string): string | undefined =>
+  bodyLines(plainSource(source).split("\n"))
+    .find((line) => line.trim() !== "" && !HEADING.test(line))
+    ?.trim();

package/src/orthography.ts

@@ -2,6 +2,14 @@
 
 export const escapeRegExp = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 
+/**
+ * 字に挟まれた ’ と、どこにあっても ʼ を ' にする（don’t → don't）。語彙表は ' で書くので、’ で書いた本文も同じ語に当てるため。
+ * 英語アダプタの解析器が同じ決めかたをする（chaff とアダプタは実行時の値を共有しないので、ここにも置く）。一字を一字に置き換えるので位置は変わらない。
+ */
+const APOSTROPHE = /(?<=[\p{L}\p{N}])’(?=\p{L})|ʼ/gu;
+
+export const straightApostrophes = (text: string): string => text.replace(APOSTROPHE, "'");
+
 /** text の中で word が現れる [始まり, 終わり) を、左から順に。大文字小文字を区別しないときは i で探す（位置は元の文字列のまま）。 */
 const spansOf = (text: string, word: string, ignoreCase: boolean): [number, number][] => {
   const pattern = new RegExp(escapeRegExp(word), ignoreCase ? "giu" : "gu");
@@ -55,7 +63,7 @@ const kindOf = (char: string | undefined, digitSide: "before-digit" | "after-dig
   return DIGIT.test(char) ? digitSide : undefined;
 };
 
-const isJapanese = (char: string | undefined): boolean => char !== undefined && JAPANESE.test(char);
+export const isJapanese = (char: string | undefined): boolean => char !== undefined && JAPANESE.test(char);
 
 /** japanese が日本語の字のとき、other の英字・数字の種類。 */
 const latinBeside = (japanese: string | undefined, other: string | undefined, digitSide: "before-digit" | "after-digit"): SpacingKind | undefined =>
@@ -189,7 +197,7 @@ export const latinBoundaries = (text: string, written: string = text): Boundary[
  * 混ざっているとき、そろえるべき少数派。種類（英字・数字の前・数字の後ろ）ごとに数える。
  * 同数なら、文書が先に使った書き方をその文書の書き方とみなし、後から出た書き方を少数派にする。
  */
-export const minorityStyle = (boundaries: readonly Boundary[]): boolean | undefined => {
+export const minorityStyle = (boundaries: readonly { readonly spaced: boolean }[]): boolean | undefined => {
   const spaced = boundaries.filter((boundary) => boundary.spaced).length;
   const touching = boundaries.length - spaced;
   if (spaced === 0 || touching === 0) return undefined;

package/src/paragraph-length.ts

@@ -0,0 +1,9 @@
+/**
+ * 段落が長すぎるか。文の数が上限を超え、しかも長さが「上限の数だけ普通の長さの文を並べた長さ」を超えるときだけ。
+ * 短い文をいくつ並べても、読み手が息をつけない壁にはならない。長さは adapter の単位（日本語は文字、英語は語）。
+ * fullSentence が無ければ、文の数だけで決める。
+ */
+export const isTooLongParagraph = (sentenceSizes: readonly number[], limit: number, fullSentence: number | undefined): boolean => {
+  const size = sentenceSizes.reduce((sum, sentence) => sum + sentence, 0);
+  return sentenceSizes.length > limit && (fullSentence === undefined || size > limit * fullSentence);
+};

package/src/plugin.ts

@@ -204,6 +204,8 @@ export type Section = {
   /** 見出しの深さ。見出しより前の導入部は 0。 */
   readonly depth: number;
   readonly heading: string;
+  /** 見出しを文と同じ解析器で語に分けたもの。文が tokens を持つときだけ入る。 */
+  readonly headingTokens?: readonly Token[];
   readonly span: Span;
   readonly sentences: readonly Sentence[];
   /** この節に含まれる強調（Markdown の ** **）の数。 */
@@ -314,6 +316,8 @@ export type ProseDocument = {
   readonly lexicons: Readonly<Record<string, Lexicon>>;
   /** この種類の文書に無いと困る見出し。チームが chaff.yaml で決める。 */
   readonly requiredSections: readonly string[];
+  /** チームが chaff.yaml の names に並べた固有名詞。1 つの名前として読み、書き手の落ち度に数えない。 */
+  readonly names?: readonly string[];
   /** 番地の付いた木（§27）。adapter が structure を持たない言語では無い。 */
   readonly structure: StructureNode | undefined;
   /** 文書の種類（法令など）。選ばれなければ無い。 */
@@ -333,6 +337,8 @@ export type Finding = {
   readonly quote: string;
   /** message のプレースホルダに入れる値。 */
   readonly values: Readonly<Record<string, string | number>>;
+  /** 1 つの rule が 2 通りの見つけ方を持つとき、どちらで見つけたか。rule の messages から文を選ぶ。無ければ message。 */
+  readonly variant?: string;
 };
 
 /** rule 定義が threshold を渡す。数値は 4 語から解決済み。 */
@@ -342,6 +348,8 @@ export type DetectorOptions = {
   readonly lexicon?: Lexicon | undefined;
   /** 見る範囲。opening は冒頭 2 段落、closing は最後の節、whole は全体。 */
   readonly where?: string | undefined;
+  /** 普通の長さの文 1 つの長さ（adapter の単位）。段落の長さを文の数と一緒に見る rule だけが持つ。 */
+  readonly fullSentence?: number | undefined;
 };
 
 export type Detector = (doc: ProseDocument, options: DetectorOptions) => Finding[];
@@ -360,6 +368,8 @@ export type RuleDefinition = {
   readonly why: Localized;
   readonly how_to_fix: Localized;
   readonly message: Localized;
+  /** 見つけ方ごとの message（Finding の variant で引く）。ほとんどの rule は持たない。 */
+  readonly messages: Readonly<Record<string, Localized>>;
   /** 4 語と数値の対応。2 つ以上。未定義の段は normal に落ちる。spec §18.1。
    *  言語別の閾値を持つ rule（max-sentence-length）は、読み込み時に言語で平坦化済み。 */
   readonly levels: LevelTable;
@@ -372,6 +382,8 @@ export type RuleDefinition = {
   /** L4 のみ。LLM に渡す決まり。言語別。 */
   readonly what_to_check: Localized | undefined;
   readonly where: string | undefined;
+  /** 普通の長さの文 1 つの長さ。言語で単位が違うので、levels と同じく読み込み時に言語で平坦化済み。 */
+  readonly full_sentence: number | undefined;
   /** adapter に要る capability。"pos" / "lemma"。満たさなければ動かさない。spec §16。 */
   readonly requires: readonly string[];
   /** 使えるなら用意してほしい capability（"pos"）。requires と違い、満たせなくても動かす（品詞が無ければ文字だけで見る）。 */

package/src/profile/check.ts

@@ -0,0 +1,34 @@
+import { NO_PROFILE } from "./select.ts";
+
+/** Where a profile was set: chaff.yaml's profile, or one of its by_path entries. */
+export type ProfileSetting = "config" | "by_path";
+
+type UnknownProfile = {
+  readonly where: ProfileSetting;
+  readonly profile: string;
+  /** The by_path entry's files, so the message can say which entry; empty for chaff.yaml's profile. */
+  readonly files: readonly string[];
+};
+
+type PathProfile = { readonly files: readonly string[]; readonly profile?: string | undefined };
+
+type WrittenProfiles = { readonly config: string | undefined; readonly byPath: readonly PathProfile[] };
+
+/** Commands that never read a document, so never choose a profile. A wrong one in chaff.yaml must not stop them. */
+const PROFILE_FREE: ReadonlySet<string> = new Set(["init", "genres", "skill", "relax", "strict", "off", "rules", "explain"]);
+
+/** The profiles a command would read from chaff.yaml: none for a command that reads no document. */
+export const writtenProfiles = (command: string, config: { readonly profile: string | undefined; readonly byPath: readonly PathProfile[] }): WrittenProfiles =>
+  PROFILE_FREE.has(command) ? { config: undefined, byPath: [] } : { config: config.profile, byPath: config.byPath };
+
+const setting = (where: ProfileSetting, profile: string | undefined, files: readonly string[] = []): UnknownProfile[] =>
+  profile === undefined ? [] : [{ where, profile, files }];
+
+/**
+ * Every profile a setting names that is neither a bundled one nor none. Such a name chooses nothing and also stops the choice from the content,
+ * so it silently acts as none. All of them, not only the one a file would use, because a wrong setting is wrong for every file.
+ */
+export const unknownProfiles = (written: WrittenProfiles, known: readonly string[]): UnknownProfile[] =>
+  [...setting("config", written.config), ...written.byPath.flatMap((entry) => setting("by_path", entry.profile, entry.files))].filter(
+    (entry) => entry.profile !== NO_PROFILE && !known.includes(entry.profile),
+  );

package/src/profile/for-file.ts

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

package/src/profile/load.ts

@@ -12,7 +12,7 @@ const loaded: { value: readonly ProfileDefinition[] | undefined } = { value: und
 export const loadProfiles = (): readonly ProfileDefinition[] => {
   loaded.value ??= readdirSync(PROFILES_DIR)
     .filter((file) => file.endsWith(".yaml"))
-    .sort((left, right) => left.localeCompare(right))
+    .toSorted((left, right) => left.localeCompare(right))
     .flatMap((file) => {
       const path = join(PROFILES_DIR, file);
       try {

package/src/profile/select.ts

@@ -4,13 +4,15 @@ import { detected, type ProfileDefinition } from "./parse.ts";
 /** 設定で書いた「使わない」。内容から選ぶのも止める。 */
 export const NO_PROFILE = "none";
 
-type ProfileSource = "by-path" | "config" | "content";
+type ProfileSource = "by-path" | "config" | "genre" | "content";
 
 export type ChosenProfile = { readonly profile: DocumentProfile; readonly from: ProfileSource };
 
 export type ProfileRequest = {
   readonly byPath: string | undefined;
   readonly config: string | undefined;
+  /** The profile the file's genre reads with (genres.yaml), when it names one. */
+  readonly genre?: string | undefined;
   readonly source: string;
   readonly language: string;
 };
@@ -18,16 +20,21 @@ export type ProfileRequest = {
 const named = (definitions: readonly ProfileDefinition[], id: string, language: string): DocumentProfile | undefined =>
   definitions.find((definition) => definition.id === id)?.languages[language];
 
+const writtenIn = (request: ProfileRequest): ProfileSource => {
+  if (request.byPath !== undefined) return "by-path";
+  return request.config === undefined ? "genre" : "config";
+};
+
 /**
- * 強いものから: by_path、chaff.yaml の profile、内容。どれかが none と書けばそこで止め、内容からも選ばない。
+ * 強いものから: by_path、chaff.yaml の profile、ジャンルの profile、内容。どれかが none と書けばそこで止め、内容からも選ばない。
  * 名前で選んだ種類にその言語の中身が無ければ選ばない。黙って別の種類にしない。
  */
 export const chooseProfile = (definitions: readonly ProfileDefinition[], request: ProfileRequest): ChosenProfile | undefined => {
-  const written = request.byPath ?? request.config;
+  const written = request.byPath ?? request.config ?? request.genre;
   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" };
+    return profile === undefined ? undefined : { profile, from: writtenIn(request) };
   }
   const found = definitions.find((definition) => detected(definition, request.source, request.language));
   const profile = found?.languages[request.language];

package/src/quoted-span.ts

@@ -1,25 +1,39 @@
-import type { Span } from "./plugin.ts";
+import type { Sentence, Span } from "./plugin.ts";
 
-/** 鉤括弧の開きと、それを閉じる字。 */
-const CLOSER: Readonly<Record<string, string>> = { "「": "」", "『": "』" };
+/** 開きの字と、それを閉じる字。 */
+type Marks = Readonly<Record<string, string>>;
+
+/** 鉤括弧。日本語の引用と題名。 */
+const KAGI_MARKS: Marks = { "「": "」", "『": "』" };
+
+/**
+ * 引用符も含めた、人の言葉を引く印。英語の "…" は開きと閉じが同じ字なので、開いている間に来たら閉じと読む。
+ * 一重の ’ は "don’t" の省略の印と見分けられないので入れない。
+ */
+export const QUOTATION_MARKS: Marks = { ...KAGI_MARKS, "“": "”", '"': '"' };
 
 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 }] };
-};
+const step =
+  (marks: Marks) =>
+  (scan: Scan, char: string, at: number): Scan => {
+    const last = scan.open.at(-1);
+    if (last !== undefined && last.closer === char) return { open: scan.open.slice(0, -1), spans: [...scan.spans, { start: last.at + 1, end: at }] };
+    const closer = marks[char];
+    return closer === undefined ? scan : { open: [...scan.open, { closer, at }], spans: scan.spans };
+  };
 
 /**
- * 鉤括弧（「」『』）の中身の位置。括弧そのものは含まない。入れ子はそれぞれを返す。
+ * 引いたものの中身の位置（既定は鉤括弧「」『』）。括弧そのものは含まない。入れ子はそれぞれを返す。
  * 閉じない括弧と、開きと組にならない閉じ括弧は中身を作らない。位置は 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];
+export const quotedSpans = (text: string, marks: Marks = KAGI_MARKS): Span[] => [...text.split("").reduce<Scan>(step(marks), { open: [], spans: [] }).spans];
+
+/** 文の中の、引いたものを括弧ごと、文書全体の座標で。 */
+export const quotedIn = (sentence: Sentence, marks: Marks = KAGI_MARKS): Span[] =>
+  quotedSpans(sentence.text, marks).map((span) => ({ start: sentence.span.start + span.start - 1, end: sentence.span.start + span.end + 1 }));
 
 /** inner が、spans のどれかにまるごと入っているか。 */
 export const isWithinAny = (spans: readonly Span[], inner: Span): boolean => spans.some((span) => inner.start >= span.start && inner.end <= span.end);

package/src/reasons.ts

@@ -1,4 +1,5 @@
 import type { Texts } from "./ui.ts";
+import { formFor } from "./render/plural.ts";
 
 /** Why a rule did not run, in the document's language. Listed under the findings so "0 findings" is never a silent pass. */
 export type Reasons = {
@@ -8,6 +9,7 @@ export type Reasons = {
   readonly semantic: string;
   readonly experimental: string;
   readonly turnedOff: string;
+  readonly presetOff: (genre: string) => string;
   readonly noStructure: (language: string) => string;
   readonly unreadStructure: (clauses: number, units: number) => string;
   readonly noDetector: (name: string) => string;
@@ -27,6 +29,7 @@ export const REASONS: Texts<Reasons> = {
     semantic: "意味を読む検査のため（npx chaff test で動きます）",
     experimental: "まだ試験中のため",
     turnedOff: "設定で止めているため",
+    presetOff: (genre) => `ジャンル ${genre} では見ないため`,
     noStructure: (language) => `${language} のパッケージは文書の構造を読めないため`,
     unreadStructure: (clauses, units) =>
       `条項の番号が本文に ${String(clauses)} 個あるのに、番号として読めたのは ${String(units)} 個のため（深い字下げや、行が本文につながった文書）`,
@@ -40,9 +43,10 @@ export const REASONS: Texts<Reasons> = {
     semantic: "it reads meaning; npx chaff test runs it",
     experimental: "still experimental",
     turnedOff: "turned off in the settings",
+    presetOff: (genre) => `the ${genre} genre does not check it`,
     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)`,
+      `the text has ${String(clauses)} clause numbers but only ${String(units)} ${formFor(units, "was read as a numbered line", "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

@@ -1,11 +1,9 @@
 import type { RuleDefinition } from "../plugin.ts";
 import type { RunResult } from "../run.ts";
 import { messageOf } from "./text.ts";
+import { counted } from "./plural.ts";
 import { uiLanguageOf, type Texts } from "../ui.ts";
 
-/** 「1 finding」「2 findings」。 */
-const counted = (count: number, noun: string): string => `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
-
 /**
  * 最後の集計の行は、画面のほかの部分と同じく文書の言語で出す。行ごとの重さ（warning / error）は、grep や別の道具が読むので英語のまま。
  */

package/src/render/eval.ts

@@ -1,5 +1,6 @@
 import { MIN_CORPUS, TARGET_HIT_RATE, type Point, type RuleReport } from "../eval.ts";
 import type { Texts, UiLanguage } from "../ui.ts";
+import { counted, formFor } from "./plural.ts";
 
 const pct = (part: number, whole: number): string => `${((part / Math.max(1, whole)) * 100).toFixed(1)}%`;
 
@@ -51,19 +52,19 @@ const TEXT: Texts<{
     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`,
+      `${String(point.documents).padStart(3)} ${formFor(point.documents, "doc ", "docs")} (${share.padStart(6)})   ${String(point.findings).padStart(3)} ${formFor(point.findings, "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.`,
+    measured: (paths, rules) => `  Measured ${counted(rules, "rule")} on ${counted(paths, "file")} 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}.`,
+      `  Note: the corpus has only ${counted(total, "document")}. 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.",

package/src/render/friendly.ts

@@ -2,6 +2,7 @@ import type { Finding, RuleDefinition } from "../plugin.ts";
 import type { RunResult } from "../run.ts";
 import { MARK, localized, messageOf } from "./text.ts";
 import { tally } from "./summary.ts";
+import { counted } from "./plural.ts";
 import { uiLanguageOf, type Texts } from "../ui.ts";
 
 const RULE = 60;
@@ -13,6 +14,7 @@ const TEXT: Texts<{
   readonly deterministic: string;
   readonly untouched: string;
   readonly forced: (n: number, ids: string) => string;
+  readonly presetOn: (n: number, ids: string) => string;
   readonly notRun: (n: number) => string;
   readonly because: (why: string) => string;
 }> = {
@@ -23,6 +25,7 @@ const TEXT: Texts<{
     deterministic: "              （同じ文章なら何度実行しても同じ結果になります）",
     untouched: "文章は書き換えていません。直すのは書いた人です。",
     forced: (n, ids) => `試験中の rule を ${n} 件、設定により有効にしています: ${ids}`,
+    presetOn: (n, ids) => `試験中の rule を ${n} 件、ジャンルの既定で有効にしています: ${ids}`,
     notRun: (n) => `${n} 件の rule は動いていません:`,
     because: (why) => `（${why}）`,
   },
@@ -32,8 +35,9 @@ const TEXT: Texts<{
     machine: "All judged by machine",
     deterministic: "              (the same text gives the same result every time)",
     untouched: "The text was not changed. Fixing it is the writer's job.",
-    forced: (n, ids) => `${n} experimental rule${n === 1 ? "" : "s"} turned on in the settings: ${ids}`,
-    notRun: (n) => `${n} rule${n === 1 ? "" : "s"} did not run:`,
+    forced: (n, ids) => `${counted(n, "experimental rule")} turned on in the settings: ${ids}`,
+    presetOn: (n, ids) => `${counted(n, "experimental rule")} turned on by the genre: ${ids}`,
+    notRun: (n) => `${counted(n, "rule")} did not run:`,
     because: (why) => ` (${why})`,
   },
 };
@@ -69,14 +73,21 @@ const block = (finding: Finding, rule: RuleDefinition, language: string): string
   "",
 ];
 
-export const renderFriendly = (header: string, result: RunResult, rules: readonly RuleDefinition[], language: string): string => {
+/** notes: lines after the not-run list (the genre chaff suggests when none is set). */
+export const renderFriendly = (
+  header: string,
+  result: RunResult,
+  rules: readonly RuleDefinition[],
+  language: string,
+  notes: readonly string[] = [],
+): string => {
   const byId = new Map(rules.map((rule) => [rule.id, rule]));
   const blocks = result.findings.flatMap((finding) => {
     const rule = byId.get(finding.rule);
     return rule === undefined ? [] : block(finding, rule, language);
   });
   const text = TEXT[uiLanguageOf(language)];
-  const notes = [
+  const closing = [
     "",
     "─".repeat(RULE),
     "",
@@ -85,10 +96,14 @@ export const renderFriendly = (header: string, result: RunResult, rules: readonl
     "",
     `  ${text.untouched}`,
   ];
-  const forced = result.forcedExperimental.length > 0 ? ["", `  ${text.forced(result.forcedExperimental.length, result.forcedExperimental.join(", "))}`] : [];
+  const forced = [
+    ...(result.forcedExperimental.length > 0 ? ["", `  ${text.forced(result.forcedExperimental.length, result.forcedExperimental.join(", "))}`] : []),
+    ...(result.presetExperimental.length > 0 ? ["", `  ${text.presetOn(result.presetExperimental.length, result.presetExperimental.join(", "))}`] : []),
+  ];
   const skipped =
     result.skipped.length > 0
       ? ["", `  ${text.notRun(result.skipped.length)}`, ...result.skipped.map((entry) => `      ${entry.rule}${text.because(entry.why)}`)]
       : [];
-  return ["", header, ...blocks, ...notes, ...forced, ...skipped, ""].join("\n");
+  const after = notes.flatMap((note) => ["", note]);
+  return ["", header, ...blocks, ...closing, ...forced, ...skipped, ...after, ""].join("\n");
 };

package/src/render/genres.ts

@@ -0,0 +1,31 @@
+import type { GenreData } from "../genre-parse.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+const TEXT: Texts<{ readonly heading: string; readonly usage: readonly string[] }> = {
+  ja: {
+    heading: "  ジャンル（文書の種類）を選ぶと、その種類の書き方に合わせて見ます:",
+    usage: [
+      "  この実行だけ:    npx chaffjs --genre legal/contract 契約書.md",
+      "  この場所に決める: npx chaffjs init --genre legal/contract   （chaff.yaml の genre に書きます）",
+    ],
+  },
+  en: {
+    heading: "  Pick the genre (the kind of document) and chaff checks it the way that kind is written:",
+    usage: [
+      "  For one run:       npx chaffjs --genre legal/contract contract.md",
+      "  For this folder:   npx chaffjs init --genre legal/contract   (writes genre in chaff.yaml)",
+    ],
+  },
+};
+
+/** `chaff genres`: every genre under its group, with what it is for, in the output language. */
+export const renderGenres = (data: GenreData, ui: UiLanguage): string => {
+  const width = Math.max(...data.genres.map((genre) => genre.id.length)) + 2;
+  const groups = data.groups.flatMap((group) => {
+    const members = data.genres.filter((genre) => genre.id.startsWith(`${group.id}/`));
+    return members.length === 0
+      ? []
+      : ["", `  ${group.name[ui] ?? group.id}`, ...members.map((genre) => `    ${genre.id.padEnd(width)}${genre.summary[ui] ?? ""}`)];
+  });
+  return ["", TEXT[ui].heading, ...groups, "", ...TEXT[ui].usage, ""].join("\n");
+};

package/src/render/plural.ts

@@ -0,0 +1,6 @@
+/** English agreement: only exactly one takes the singular ("0 findings", "1 finding", "1.5 findings"). */
+const isOne = (count: number | string): boolean => String(count) === "1";
+
+export const formFor = (count: number | string, singular: string, plural: string): string => (isOne(count) ? singular : plural);
+
+export const counted = (count: number, singular: string, plural = `${singular}s`): string => `${String(count)} ${formFor(count, singular, plural)}`;