chaffjs 0.14.0 → 0.16.0

package/src/detectors/superlative-amount.ts

@@ -0,0 +1,24 @@
+import type { Lexicon, Token } from "../plugin.ts";
+import type { TokenRange } from "./lexicon-match.ts";
+
+/** 名詞の後ろにこれが続けば、その名詞は句の頭ではない。解析器は形容詞を名詞と読むことがある（the most frigid weather・the most cost-effective）。 */
+const JOINED = new Set(["NOUN", "PROPN", "ADJ", "X"]);
+
+const listed = (tokens: readonly Token[], range: TokenRange, amounts: Lexicon): boolean => {
+  const words = tokens
+    .slice(range.start, range.end)
+    .map((token) => token.surface.toLowerCase())
+    .join(" ");
+  return amounts.some((entry) => entry.pattern.toLowerCase() === words);
+};
+
+/**
+ * 量も言う最上級に、句の頭になる名詞がそのまま続くか（the most work・the most students・for the most part）。
+ * それは一番多いものを言っていて、何かが一番良いという主張ではない。形容詞を挟めば（the most powerful tool）主張のまま。
+ * どの最上級が量を言うかは言語パッケージの語彙表 superlative-amount が持つ。
+ */
+export const namesAmount = (tokens: readonly Token[], range: TokenRange, amounts: Lexicon): boolean => {
+  const noun = tokens[range.end];
+  const after = tokens[range.end + 1];
+  return listed(tokens, range, amounts) && noun?.pos === "NOUN" && (after === undefined || !JOINED.has(after.pos));
+};

package/src/detectors/superlative-clause.ts

@@ -0,0 +1,82 @@
+import type { Lexicon, Token } from "../plugin.ts";
+import type { TokenRange } from "./lexicon-match.ts";
+import { PHRASE_END, PHRASE_START, phraseEnd } from "./superlative-scope.ts";
+
+/** 最上級の名詞句を後ろから限る語。どちらも言語パッケージの語彙表が持つ。 */
+export type Restrictors = {
+  /** 名詞の後ろで関係節を始める語（that・which）。空の言語は、名詞の後ろに節を置かない。 */
+  readonly relatives: Lexicon;
+  /** 最上級を手に入る範囲に限る形容詞（possible・available）。 */
+  readonly bounds: Lexicon;
+  /** 節の主語になる代名詞（we・they）。themselves のような再帰の代名詞は主語にならない。 */
+  readonly subjects: Lexicon;
+};
+
+const VERBAL = new Set(["VERB", "AUX"]);
+
+const isWord = (token: Token | undefined, words: Lexicon): boolean =>
+  token !== undefined && words.some((entry) => entry.pattern.toLowerCase() === token.surface.toLowerCase());
+
+const isVerbal = (token: Token | undefined): boolean => token !== undefined && VERBAL.has(token.pos);
+
+/** 節の主語（we・managers・the team・this）を読み飛ばした先に動詞があるか。主語の無い節（that has defined）は動詞で始まる。 */
+const verbAfterSubject = (tokens: readonly Token[], at: number, subjects: Lexicon): boolean => {
+  if (isVerbal(tokens[at])) return true;
+  if (isWord(tokens[at], subjects)) return isVerbal(tokens[at + 1]);
+  if (tokens[at]?.pos === "DET") return isVerbal(tokens[at + 1]) || isVerbal(tokens[phraseEnd(tokens, at + 1)]);
+  return isVerbal(tokens[phraseEnd(tokens, at)]);
+};
+
+const isArticle = (token: Token | undefined): boolean => token?.features?.["PronType"] === "Art";
+
+/**
+ * 関係詞を省いた節の主語は、代名詞（the best we have measured）か冠詞で始まる名詞句（the best option the team selected）。
+ * each・all のような限定詞（The best teams all adapt）や、冠詞の無い名詞（The best teams adapt）は節の始まりと読まない。
+ */
+const contactClause = (tokens: readonly Token[], at: number, subjects: Lexicon): boolean => {
+  if (isWord(tokens[at], subjects)) return isVerbal(tokens[at + 1]);
+  return isArticle(tokens[at]) && isVerbal(tokens[phraseEnd(tokens, at + 1)]);
+};
+
+/** 関係節（the threats that we have seen・the option which we chose）と、関係詞を省いた節。 */
+const clause = (tokens: readonly Token[], at: number, restrictors: Restrictors): boolean =>
+  isWord(tokens[at], restrictors.relatives) ? verbAfterSubject(tokens, at + 1, restrictors.subjects) : contactClause(tokens, at, restrictors.subjects);
+
+/** 分詞の後ろに文の動詞があるか。and を挟んだ動詞（The best option changed quickly and won）は分詞と並ぶ述語。 */
+const mainVerbFollows = (tokens: readonly Token[], at: number): boolean => {
+  const rest = tokens.slice(at + 1);
+  const verb = rest.findIndex(isVerbal);
+  return verb !== -1 && !rest.slice(0, verb).some((token) => token.pos === "CCONJ");
+};
+
+/**
+ * 名詞の後ろの過去分詞（the most scalable option discussed）。名詞句が動詞の目的語か補語で（We chose the best option discussed）、
+ * または分詞の後ろに文の動詞がある（The best results obtained were poor）ときだけ。目的語を取る分詞（The best solution
+ * proposed a fix）と、ほかに述語の無い分詞（The best option changed.）は文の動詞。
+ */
+const participle = (tokens: readonly Token[], range: TokenRange, at: number): boolean => {
+  const next = tokens[at + 1];
+  if (tokens[at]?.features?.["VerbForm"] !== "Part" || (next !== undefined && PHRASE_START.has(next.pos))) return false;
+  return isVerbal(tokens[range.start - 1]) || mainVerbFollows(tokens, at);
+};
+
+/** 最上級のすぐ後ろ（the best possible outcome）か、名詞句の後ろ（the best education possible）。 */
+const bounded = (tokens: readonly Token[], range: TokenRange, at: number, bounds: Lexicon): boolean =>
+  isWord(tokens[range.end], bounds) || isWord(tokens[at], bounds);
+
+/** 修飾の語は名詞の前に来るので、句の後ろで止まった分詞は名詞の後ろにある。 */
+const clauseOrParticiple = (tokens: readonly Token[], range: TokenRange, at: number, restrictors: Restrictors): boolean => {
+  const last = tokens[at - 1];
+  const endsPhrase = at === range.end || (last !== undefined && PHRASE_END.has(last.pos));
+  return (endsPhrase && clause(tokens, at, restrictors)) || participle(tokens, range, at);
+};
+
+/**
+ * 最上級の名詞句を後ろの節か分詞か形容詞が限っているか（the best we have measured・the most scalable option discussed・
+ * the best education possible）。何の中で最もなのかを言っているので、限定の無い最上級ではない。
+ * 名詞の後ろに節を置かない言語は関係詞の語彙表が空で、節も分詞も読まない。
+ */
+export const restricted = (tokens: readonly Token[], range: TokenRange, restrictors: Restrictors): boolean => {
+  const at = phraseEnd(tokens, range.end);
+  return bounded(tokens, range, at, restrictors.bounds) || (restrictors.relatives.length > 0 && clauseOrParticiple(tokens, range, at, restrictors));
+};

package/src/detectors/superlative-name.ts

@@ -0,0 +1,30 @@
+import type { Lexicon, Token } from "../plugin.ts";
+import type { TokenRange } from "./lexicon-match.ts";
+
+/** 記号（最高!）は名詞と付いても語を作らない。 */
+const LETTER = /\p{L}/u;
+
+const joinsAsNoun = (previous: Token, token: Token | undefined): token is Token =>
+  token !== undefined && token.pos === "NOUN" && LETTER.test(token.surface) && previous.span.end === token.span.start;
+
+/** 空白も助詞も挟まずに続く名詞の連なり（最大|瞬間|風速）の最後の語。連なりが無ければ undefined。 */
+const lastJoined = (tokens: readonly Token[], at: number): Token | undefined => {
+  const previous = tokens[at - 1];
+  const token = tokens[at];
+  if (previous === undefined || !joinsAsNoun(previous, token)) return undefined;
+  return lastJoined(tokens, at + 1) ?? token;
+};
+
+const measures = (noun: Token, quantities: Lexicon): boolean => quantities.some((entry) => entry.pattern === noun.surface);
+
+/**
+ * 最上級の名詞がそのまま名詞と 1 語になり、その連なりが測る量の名詞で終わるか（最大風速・最高気温・最大値・最大駐車台数）。
+ * これは量の名前で、何かが一番だという主張ではない。「最大の効果」「最も速い」は助詞や用言を挟むので当たらない。
+ * ほかの名詞で終わる語（最高品質・最高精度・最大効果）は一番だという主張のまま。量の名詞は言語パッケージの語彙表が持つ。
+ */
+export const namesQuantity = (tokens: readonly Token[], range: TokenRange, quantities: Lexicon): boolean => {
+  const superlative = tokens[range.start];
+  const single = range.end - range.start === 1 && superlative?.pos === "NOUN";
+  const last = single ? lastJoined(tokens, range.end) : undefined;
+  return last !== undefined && measures(last, quantities);
+};

package/src/detectors/superlative-scope.ts

@@ -21,14 +21,14 @@ export const scopeMarkersOf = (lexicon: Lexicon): ScopeMarkers => ({
 const NOMINAL = new Set(["NOUN", "PROPN"]);
 
 /** 名詞句の始まり。the world・Chicago・our products・the three・all。 */
-const PHRASE_START = new Set(["DET", "NOUN", "PROPN", "PRON", "NUM", "ADJ"]);
+export const PHRASE_START = new Set(["DET", "NOUN", "PROPN", "PRON", "NUM", "ADJ"]);
 
 /** 名詞の前に来る修飾（most skilled・widely used・stuffed）。名詞が出た後は名詞の連なりだけが続く。 */
 const PREMODIFIER = new Set(["ADJ", "ADV", "VERB", "NOUN", "PROPN", "NUM"]);
 const NOUN_RUN = new Set(["NOUN", "PROPN", "NUM"]);
 
 /** 範囲の前に置ける語。修飾だけで終わった句（the best is in …）は範囲ではなく述語。 */
-const PHRASE_END = new Set(["NOUN", "PROPN", "NUM", "ADJ"]);
+export const PHRASE_END = new Set(["NOUN", "PROPN", "NUM", "ADJ"]);
 
 const isMarker = (token: Token | undefined, markers: Lexicon): boolean =>
   token !== undefined && markers.some((entry) => entry.pattern.toLowerCase() === token.surface.toLowerCase());
@@ -47,7 +47,7 @@ const namedBefore = (tokens: readonly Token[], range: TokenRange, markers: Lexic
   isMarker(tokens[range.start - 1], markers) && isNamed(tokens[range.start - 2]);
 
 /** 最上級に続く名詞句の終わり。名詞が出るまでは修飾を、出た後は名詞の連なりを読む。 */
-const phraseEnd = (tokens: readonly Token[], at: number, nounSeen = false): number => {
+export const phraseEnd = (tokens: readonly Token[], at: number, nounSeen = false): number => {
   const token = tokens[at];
   if (token === undefined || !(nounSeen ? NOUN_RUN : PREMODIFIER).has(token.pos)) return at;
   return phraseEnd(tokens, at + 1, nounSeen || NOMINAL.has(token.pos));

package/src/detectors/team.ts

@@ -1,7 +1,8 @@
 import { proseText } from "../measure.ts";
 import { joinWords } from "./word-list.ts";
 import { wordsOf } from "./structure.ts";
-import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
+import { nameSpans } from "../team-names.ts";
+import type { Detector, Finding, Sentence, Span, Token } from "../plugin.ts";
 
 /**
  * チームの言葉。社内でしか通じない語を、チームが chaff.yaml に自分で並べる。
@@ -76,8 +77,23 @@ const isProperNoun = (token: Token): boolean => token.pos === "PROPN";
  * spec は未知語率としていたが、**品詞解析があれば PROPN を数えるだけで足りる**。
  * 辞書を別に持つ必要はない。
  */
+const within = (spans: readonly Span[], token: Token): Span | undefined => spans.find((span) => token.span.start >= span.start && token.span.end <= span.end);
+
+/** 並べた名前は、何語に割れても 1 つの固有名詞（Bank of England は 2 つでなく 1 つ）。名前の中の 2 語目からを落とす。 */
+const properNounsOf = (sentence: Sentence, names: readonly string[]): Token[] => {
+  const named = nameSpans(sentence.text, names).map((span) => ({ start: sentence.span.start + span.start, end: sentence.span.start + span.end }));
+  const counted = new Set<Span>();
+  return (sentence.tokens ?? []).filter(isProperNoun).filter((token) => {
+    const name = within(named, token);
+    if (name === undefined) return true;
+    if (counted.has(name)) return false;
+    counted.add(name);
+    return true;
+  });
+};
+
 export const properNounDensity: Detector = (doc, options): Finding[] => {
-  const hits = doc.sentences.flatMap((sentence) => (sentence.tokens ?? []).filter(isProperNoun).map((token) => ({ sentence, token })));
+  const hits = doc.sentences.flatMap((sentence) => properNounsOf(sentence, doc.names ?? []).map((token) => ({ sentence, token })));
   const length = wordsOf(doc);
   const rate = length === 0 ? 0 : Math.round((hits.length / length) * PER);
   const first = hits[0];

package/src/detectors/token-shape.ts

@@ -1,4 +1,5 @@
 import { hasParticle, isClosed, lastContent } from "../sentence-shape.ts";
+import { isWithinAny, quotedIn } from "../quoted-span.ts";
 import type { Detector, Finding, Span, Token } from "../plugin.ts";
 
 /**
@@ -44,10 +45,11 @@ export const nounEnding: Detector = (doc, options): Finding[] => {
  */
 type Run = { readonly surface: string; readonly tokens: readonly Token[] };
 
-const extend = (runs: readonly Run[], token: Token): Run[] => {
+const extend = (runs: Run[], token: Token): Run[] => {
   const last = runs.at(-1);
-  if (last !== undefined && last.surface === token.surface) return [...runs.slice(0, -1), { surface: last.surface, tokens: [...last.tokens, token] }];
-  return [...runs, { surface: token.surface, tokens: [token] }];
+  if (last !== undefined && last.surface === token.surface) runs[runs.length - 1] = { surface: last.surface, tokens: [...last.tokens, token] };
+  else runs.push({ surface: token.surface, tokens: [token] });
+  return runs;
 };
 
 const PARTICLE = new Set(["ADP", "SCONJ", "PART", "CCONJ"]);
@@ -57,17 +59,22 @@ const BREAK: Run = { surface: "", tokens: [] };
 /**
  * 名詞は連なりの中身なので飛ばす。読点と、語彙表に無い助詞は連なりを切る。
  * 「弊社のAはBの」を 2 回続いたと数えないため。「は」でいちど句が閉じている。
+ *
+ * 鉤括弧で引いたもの（括弧ごと）は、名詞と同じく連なりの中身として飛ばす。引いた題名（「食品中のウイルスの制御のための…ガイドライン」）や
+ * 発言は書き手が言い換えられないので、中の助詞は数えない。題名も名前なので、外の連なり（弊社の「新製品」の販売の計画）は続けて数える。
  */
-const runsOf = (tokens: readonly Token[], nesting: readonly string[]): Run[] =>
+const runsOf = (tokens: readonly Token[], nesting: readonly string[], quoted: readonly Span[]): Run[] =>
   tokens.reduce<Run[]>((acc, token) => {
+    if (isWithinAny(quoted, token.span)) return acc;
     if (nesting.includes(token.surface)) return extend(acc, token);
-    return token.pos === "PUNCT" || PARTICLE.has(token.pos) ? [...acc, BREAK] : acc;
+    if (token.pos === "PUNCT" || PARTICLE.has(token.pos)) acc.push(BREAK);
+    return acc;
   }, []);
 
 export const doubledParticle: Detector = (doc, options): Finding[] => {
   const nesting = (options.lexicon ?? []).map((entry) => entry.pattern);
   return doc.sentences.flatMap((sentence) =>
-    runsOf(sentence.tokens ?? [], nesting)
+    runsOf(sentence.tokens ?? [], nesting, quotedIn(sentence))
       .filter((run) => run.tokens.length > options.limit)
       .map((run) => ({
         rule: "no-doubled-joshi",

package/src/document.ts

@@ -6,6 +6,9 @@ import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
 import { atxHeadingText, headingText } from "./heading-text.ts";
 import { hasTitle } from "./heading-title.ts";
 import { maskSpans } from "./mask.ts";
+import { spansWithin, unmaskedSoftBreaks } from "./soft-break.ts";
+import { segmentJoined } from "./joined-view.ts";
+import { lineParagraphs } from "./line-paragraphs.ts";
 import { buildTree, type Outline } from "./structure/build.ts";
 import { isMarkdownPath } from "./structure/markdown-path.ts";
 import { pageFurniture, textOutline } from "./page-furniture.ts";
@@ -187,15 +190,17 @@ const spansOfType = (root: Node, type: string, keep: (node: Node) => boolean = (
  */
 const shift = (span: Span, by: number): Span => ({ start: by + span.start, end: by + span.end });
 
-const sentencesOf = (prose: string, paragraphs: readonly Span[], adapter: LanguageAdapter): Sentence[] =>
+const breaksWithin = (breaks: readonly Span[], paragraph: Span): Span[] => spansWithin(breaks, paragraph).map((span) => shift(span, -paragraph.start));
+
+const sentencesOf = (prose: string, paragraphs: readonly Span[], adapter: LanguageAdapter, softBreaks: readonly Span[]): Sentence[] =>
   paragraphs.flatMap((paragraph) =>
-    adapter
-      .segment(prose.slice(paragraph.start, paragraph.end))
-      .sentences.filter((sentence) => sentence.text.trim().length > 0)
+    segmentJoined(prose.slice(paragraph.start, paragraph.end), breaksWithin(softBreaks, paragraph), (text) => adapter.segment(text))
+      .filter((sentence) => sentence.text.trim().length > 0)
       .map((sentence) => ({
         span: shift(sentence.span, paragraph.start),
         text: sentence.text,
         ...(sentence.tokens === undefined ? {} : { tokens: sentence.tokens.map((token) => ({ ...token, span: shift(token.span, paragraph.start) })) }),
+        ...(sentence.wrapBreaks === undefined ? {} : { wrapBreaks: sentence.wrapBreaks.map((span) => shift(span, paragraph.start)) }),
       })),
   );
 
@@ -217,12 +222,32 @@ const sectionsOf = (headings: readonly Heading[], sentences: readonly Sentence[]
     });
 };
 
-const paragraphsOf = (spans: readonly Span[], sentences: readonly Sentence[], listSpans: readonly Span[]): Paragraph[] =>
+/** sentences（並び順）の中で、start が offset 以上の最初の添字。1 行 1 段落の何万行でも、段落ごとに全部をなめない。 */
+const firstStartingAt = (sentences: readonly Sentence[], offset: number): number => {
+  const search = (low: number, high: number): number => {
+    if (low >= high) return low;
+    const middle = (low + high) >> 1;
+    return (sentences[middle]?.span.start ?? Number.POSITIVE_INFINITY) >= offset ? search(low, middle) : search(middle + 1, high);
+  };
+  return search(0, sentences.length);
+};
+
+const sentencesWithin = (sentences: readonly Sentence[], span: Span): Sentence[] =>
+  sentences.slice(firstStartingAt(sentences, span.start), firstStartingAt(sentences, span.end));
+
+const paragraphsOf = (prose: string, spans: readonly Span[], sentences: readonly Sentence[], listSpans: readonly Span[]): Paragraph[] =>
   spans
     // 箇条書きの中の段落は「段落」として数えない。項目 1 つを 1 段落と読むと、
     // 段落あたりの文数も長さのばらつきも、箇条書きの多い文書で壊れる。
     .filter((span) => !listSpans.some((list) => span.start >= list.start && span.start < list.end))
-    .map((span) => ({ span, sentences: sentences.filter((sentence) => within(sentence.span, span.start, span.end)) }));
+    .flatMap((span) =>
+      lineParagraphs(
+        prose,
+        span,
+        sentencesWithin(sentences, span).map((sentence) => sentence.span),
+      ),
+    )
+    .map((span) => ({ span, sentences: sentencesWithin(sentences, span) }));
 
 /** 箇条書きは list ノードの直下の項目を数える。入れ子の項目は内側の list のものとして数える。目次のような案内だけの箇条書きは数えない。 */
 const listsOf = (root: Node, source: string, anchors: InPageAnchors): BulletList[] => {
@@ -246,6 +271,8 @@ export type TeamRules = {
   readonly requiredSections: readonly string[];
   /** { 使わない書き方: 使う書き方 }。preferred-term が語彙表として読む。 */
   readonly prefer?: Readonly<Record<string, string>>;
+  /** チームの固有名詞。1 つの名前として読む rule が見る。 */
+  readonly names?: readonly string[];
 };
 
 const EMPTY_TEAM: TeamRules = { jargon: [], requiredSections: [] };
@@ -255,10 +282,12 @@ export const teamRules = (config: {
   readonly jargon: readonly string[];
   readonly requiredSections: readonly string[];
   readonly prefer?: Readonly<Record<string, string>>;
+  readonly names?: readonly string[];
 }): TeamRules => ({
   jargon: config.jargon,
   prefer: config.prefer ?? {},
   requiredSections: config.requiredSections,
+  names: config.names ?? [],
 });
 
 export const buildDocument = (
@@ -279,7 +308,9 @@ export const buildDocument = (
   // ページの案内は段落としても数えない。数えると、目次の行が「本題までの段落」に入る。
   const paragraphSpans = spansOfType(root, "paragraph", (node) => !isInPageNavigation(node, anchors));
   const listItems = spansOfType(root, "listItem");
-  const sentences = sentencesOf(prose, paragraphSpans, adapter);
+  // Markdown は段落を流し込んで表示するので、段落の中の改行は読み手に見えない。テキストの文書は行をそのまま見せる（法令は 1 行 1 号）。
+  const softBreaks = isMarkdownPath(path) ? unmaskedSoftBreaks(source, prose) : [];
+  const sentences = sentencesOf(prose, paragraphSpans, adapter, softBreaks);
   const lexicons = {
     ...adapter.lexicons,
     "internal-jargon": team.jargon.map((pattern) => ({ pattern })),
@@ -299,10 +330,12 @@ export const buildDocument = (
     sections: sectionsOf(headingsOf(root, source), sentences, strongSpans(root, blocks), source.length),
     sentences,
     listSpans: listItems,
-    paragraphs: paragraphsOf(paragraphSpans, sentences, listItems),
+    paragraphs: paragraphsOf(prose, paragraphSpans, sentences, listItems),
     lists: listsOf(root, source, anchors),
+    links: [...spansOfType(root, "link"), ...spansOfType(root, "linkReference")],
     lexicons: tagged ? tokenizedLexicons(lexicons, adapter) : lexicons,
     requiredSections: team.requiredSections,
+    names: team.names ?? [],
     // 構造の rule（参照先が無い・番号の抜け）が読む木。どの rule も読まなければ作らない。何万行の契約書で、他の rule の lint に代金を払わせない。
     get structure(): StructureNode | undefined {
       tree.value ??=

package/src/eval.ts

@@ -41,7 +41,7 @@ const candidates = (rule: RuleDefinition, current: number): number[] => {
   const fromLevels = [rule.levels.strict, rule.levels.normal, rule.levels.relaxed].filter((value) => value !== undefined);
   const scaled = MULTIPLIERS.map((factor) => Math.max(1, Math.round(base * factor)));
   // 数値で決めた上限は、段の表に無くても掃引に入れる。入れないと「現在」の行が出ない。
-  return [...new Set([...fromLevels, ...scaled, current])].sort((left, right) => left - right);
+  return [...new Set([...fromLevels, ...scaled, current])].toSorted((left, right) => left - right);
 };
 
 const countAt = (docs: readonly ProseDocument[], rule: RuleDefinition, limit: number): Point => {

package/src/feedback/draft.ts

@@ -61,7 +61,7 @@ const TEXT: Texts<{
       "false-positive": "<!-- Why it is wrong, and how the text should be read -->",
       missed: "<!-- What is wrong in the text, and which rule should have said so -->",
     },
-    lines: (from, to) => `lines ${String(from)}-${String(to)}`,
+    lines: (from, to) => (from === to ? `line ${String(from)}` : `lines ${String(from)}-${String(to)}`),
   },
 };
 

package/src/feedback/excerpt.ts

@@ -1,14 +1,14 @@
 /** 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;
+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)
+    .toSorted((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);

package/src/file-header.ts

@@ -0,0 +1,31 @@
+import { CLI_TEXT, type GenreSource } from "./cli-text.ts";
+import { loadGenres } from "./genre-load.ts";
+import type { GenreDefinition } from "./genre-parse.ts";
+import { suggestGenre } from "./genre-suggest.ts";
+import { loadProfiles } from "./profile/load.ts";
+import { uiLanguageOf } from "./ui.ts";
+
+/** The file's first lines, and the notes after its not-run list: the genre it looks like, when none was set. */
+type FileHeader = { readonly header: string; readonly notes: readonly string[] };
+
+/** unread: a genre the front matter wrote that chaff does not know (already reported on stderr). */
+type Placed = { readonly genre: string; readonly from: GenreSource; readonly unread?: string | undefined };
+
+type Counts = { readonly shelved: number; readonly hushed: number };
+
+/**
+ * The genre the file looks like, only when nothing set or guessed one: suggested on screen, never used for the run.
+ * A front matter genre chaff could not read is a genre the writer did set, so the note's "no genre was set" would be untrue.
+ */
+const suggestionFor = (path: string, source: string, language: string, placed: Placed): GenreDefinition | undefined =>
+  placed.from === "default" && placed.unread === undefined ? suggestGenre({ path, source, language }, loadGenres(), loadProfiles()) : undefined;
+
+/** In the file's language. The note names the genre the file was checked as. */
+export const fileHeader = (path: string, source: string, language: string, placed: Placed, counts: Counts): FileHeader => {
+  const text = CLI_TEXT[uiLanguageOf(language)];
+  const first = text.header(path, placed.genre, text.languageName(language), text.genreSource[placed.from], counts.shelved, counts.hushed);
+  const suggestion = suggestionFor(path, source, language, placed);
+  if (suggestion === undefined) return { header: first, notes: [] };
+  const name = suggestion.name[uiLanguageOf(language)] ?? suggestion.id;
+  return { header: [first, text.suggested(name, suggestion.id)].join("\n"), notes: [text.suggestedNote(name, suggestion.id, placed.genre)] };
+};

package/src/files.ts

@@ -4,11 +4,11 @@ import { join, relative, sep } from "node:path";
 const MARKDOWN = [".md", ".markdown", ".mdx"];
 
 /** 走査から外す。ここを通すと node_modules の README を延々と検査することになる。 */
-const SKIP = ["node_modules", "dist", "build", "coverage", ".git", ".chaff-cache"];
+const SKIP: ReadonlySet<string> = new Set(["node_modules", "dist", "build", "coverage", ".git", ".chaff-cache"]);
 
 const isMarkdown = (path: string): boolean => MARKDOWN.some((ext) => path.toLowerCase().endsWith(ext));
 
-const isSkipped = (path: string): boolean => path.split(sep).some((part) => SKIP.includes(part));
+const isSkipped = (path: string): boolean => path.split(sep).some((part) => SKIP.has(part));
 
 const expand = (target: string): string[] => {
   const stat = statSync(target, { throwIfNoEntry: false });
@@ -30,5 +30,5 @@ const byPath = (left: string, right: string): number => left.localeCompare(right
 
 export const collectTargets = (targets: readonly string[]): string[] => {
   const found = targets.flatMap(expand).filter((path) => !isSkipped(path));
-  return [...new Set(found)].sort((left, right) => byPath(relative(".", left), relative(".", right)));
+  return [...new Set(found)].toSorted((left, right) => byPath(relative(".", left), relative(".", right)));
 };

package/src/genre-check.ts

@@ -0,0 +1,46 @@
+import { frontMatterValues } from "./genre.ts";
+
+/** Where a genre was set: the command line, chaff.yaml's genre, or one of its by_path entries. */
+export type GenreSetting = "--genre" | "config" | "by_path";
+
+type UnknownGenre = {
+  readonly where: GenreSetting;
+  readonly genre: string;
+  /** The by_path entry's files, so the message can say which entry; empty elsewhere. */
+  readonly files: readonly string[];
+};
+
+type PathGenre = { readonly files: readonly string[]; readonly genre: string | undefined };
+
+type WrittenGenres = { readonly flag: string | undefined; readonly config: string | undefined; readonly byPath: readonly PathGenre[] };
+
+/** Commands that never read a genre from chaff.yaml. A wrong one there must not stop them: genres is how to find the right name. */
+const GENRE_FREE: ReadonlySet<string> = new Set(["init", "genres", "skill", "relax", "strict", "off"]);
+
+/** The genres a command would read: --genre always (every command refuses a wrong one), chaff.yaml's only where the command reads a genre. */
+export const writtenGenres = (
+  command: string,
+  flag: string | undefined,
+  config: { readonly genre: string | undefined; readonly byPath: readonly PathGenre[] },
+): WrittenGenres => (GENRE_FREE.has(command) ? { flag, config: undefined, byPath: [] } : { flag, config: config.genre, byPath: config.byPath });
+
+const setting = (where: GenreSetting, genre: string | undefined, files: readonly string[] = []): UnknownGenre[] =>
+  genre === undefined ? [] : [{ where, genre, files }];
+
+/**
+ * Every genre a setting names that chaff does not know: no rule's use_for matches one, so nothing would run and nothing be listed as not run.
+ * All of them, not only the one a file would use, because a wrong setting is wrong for every file.
+ */
+export const unknownGenres = (written: WrittenGenres, known: readonly string[]): UnknownGenre[] =>
+  [
+    ...setting("--genre", written.flag),
+    ...setting("config", written.config),
+    ...written.byPath.flatMap((entry) => setting("by_path", entry.genre, entry.files)),
+  ].filter((entry) => !known.includes(entry.genre));
+
+/**
+ * The front matter's genre that was not read. Front matter is the document's and often another tool's, so this warns and does not stop:
+ * the file falls back to the path, the content or the default. type is not looked at (Zenn's tech / idea mean something else).
+ */
+export const unknownFrontMatterGenre = (source: string, known: readonly string[]): string | undefined =>
+  frontMatterValues(source, "genre").find((value) => value !== "" && !known.includes(value));

package/src/genre-load.ts

@@ -0,0 +1,24 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "yaml";
+import { parseGenres, presetLevelsOf, presetProfileOf, type GenreData, type PresetLevels } from "./genre-parse.ts";
+
+const GENRES_FILE = join(dirname(fileURLToPath(import.meta.url)), "..", "genres.yaml");
+
+const loaded: { value: GenreData | undefined } = { value: undefined };
+
+/** The bundled genres.yaml. Read once. */
+export const loadGenres = (): GenreData => {
+  if (loaded.value !== undefined) return loaded.value;
+  try {
+    loaded.value = parseGenres(parse(readFileSync(GENRES_FILE, "utf8")));
+  } catch (error) {
+    throw new Error(`cannot read ${GENRES_FILE}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+  return loaded.value;
+};
+
+export const presetLevels = (genre: string): PresetLevels => presetLevelsOf(loadGenres(), genre);
+
+export const presetProfile = (genre: string): string | undefined => presetProfileOf(loadGenres(), genre);