chaffjs 0.6.0 → 0.7.0

package/src/commands/eval.ts

@@ -58,6 +58,7 @@ export const runEval = async (targets: readonly string[], argv: readonly string[
         rules,
         genre,
         language,
+        config.limits,
       ),
       docs.length,
       paths.length,

package/src/config/load.ts

@@ -14,12 +14,18 @@ export type Config = {
   readonly aiBackend: BackendName;
   readonly language: string | undefined;
   readonly rules: Readonly<Record<string, Level>>;
+  /** rules に数値で書いた上限。段階の 4 語では足りないときに、その rule の数値を直接決める。段階は normal として扱う。 */
+  readonly limits: Readonly<Record<string, number>>;
+  /** rules に書かれていたが読めなかった値。黙って捨てると、書いた設定が効いていないことに気づけない。 */
+  readonly unreadableRules: readonly { readonly id: string; readonly value: string }[];
   readonly experimental: boolean;
   readonly path: string | undefined;
   readonly aiModel: string;
   readonly confidenceThreshold: number;
   /** チームの言葉。社内でしか通じない語を、チームが自分で並べる。 */
   readonly jargon: readonly string[];
+  /** チームの表記。{ 使わない書き方: 使う書き方 }。「サーバー」ではなく「サーバ」、のように。 */
+  readonly prefer: Readonly<Record<string, string>>;
   /** この種類の文書に無いと困る見出し。チームが自分で決める。 */
   readonly requiredSections: readonly string[];
   /** パスごとの上書き。設定ファイルのある場所からの相対で照合する。 */
@@ -35,12 +41,15 @@ export const EMPTY: Config = {
   genre: undefined,
   language: undefined,
   rules: {},
+  limits: {},
+  unreadableRules: [],
   experimental: false,
   path: undefined,
   aiBackend: DEFAULT_BACKEND,
   aiModel: defaultModel(DEFAULT_BACKEND),
   confidenceThreshold: 0.7,
   jargon: [],
+  prefer: {},
   requiredSections: [],
   byPath: [],
   baseDir: process.cwd(),
@@ -48,11 +57,29 @@ export const EMPTY: Config = {
 
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
 
+const isLimit = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value) && value > 0;
+
+/** 段階の 4 語はそのまま、数値の上限は normal として読む。上限そのものは limitsOf が持つ。 */
 const rulesOf = (raw: unknown): Record<string, Level> => {
   if (!isRecord(raw)) return {};
-  return Object.entries(raw).reduce<Record<string, Level>>((acc, [id, value]) => (isLevel(value) ? { ...acc, [id]: value } : acc), {});
+  return Object.fromEntries(
+    Object.entries(raw).flatMap(([id, value]): [string, Level][] => {
+      if (isLevel(value)) return [[id, value]];
+      return isLimit(value) ? [[id, "normal"]] : [];
+    }),
+  );
 };
 
+const limitsOf = (raw: unknown): Record<string, number> =>
+  isRecord(raw) ? Object.fromEntries(Object.entries(raw).flatMap(([id, value]): [string, number][] => (isLimit(value) ? [[id, value]] : []))) : {};
+
+const unreadableOf = (raw: unknown): { id: string; value: string }[] =>
+  isRecord(raw)
+    ? Object.entries(raw)
+        .filter(([, value]) => !isLevel(value) && !isLimit(value))
+        .map(([id, value]) => ({ id, value: JSON.stringify(value) ?? String(value) }))
+    : [];
+
 const str = (value: unknown): string | undefined => (typeof value === "string" ? value : undefined);
 
 /** files は 1 つの文字列でも配列でも書ける。 */
@@ -72,6 +99,18 @@ const toPathRule = (raw: unknown): PathRule | undefined => {
 /** 利用者が書く語の並び。空白だけのものは落とす。 */
 const wordsOf = (raw: unknown): string[] => (Array.isArray(raw) ? raw.map((entry) => String(entry).trim()).filter((entry) => entry.length > 0) : []);
 
+/** 両側とも空でない文字列の対だけを読む。同じ語どうし（「サーバ: サーバ」）は何も言えないので捨てる。 */
+const preferOf = (raw: unknown): Record<string, string> =>
+  isRecord(raw)
+    ? Object.fromEntries(
+        Object.entries(raw).flatMap(([avoid, use]): [string, string][] => {
+          const from = avoid.trim();
+          const to = typeof use === "string" ? use.trim() : "";
+          return from !== "" && to !== "" && from !== to ? [[from, to]] : [];
+        }),
+      )
+    : {};
+
 const byPathOf = (raw: unknown): PathRule[] => (Array.isArray(raw) ? raw.map(toPathRule).filter((rule) => rule !== undefined) : []);
 
 /** 設定ファイルが無くても動く。あっても、既定から変えたものだけが書かれている。spec §18。 */
@@ -84,12 +123,15 @@ export const loadConfig = (path: string): Config => {
     genre: str(raw["genre"]),
     language: str(raw["language"]),
     rules: rulesOf(raw["rules"]),
+    limits: limitsOf(raw["rules"]),
+    unreadableRules: unreadableOf(raw["rules"]),
     experimental: raw["experimental"] === true,
     path,
     aiBackend: backend,
     aiModel: str(raw["ai_model"]) ?? defaultModel(backend),
     confidenceThreshold: typeof raw["confidence_threshold"] === "number" ? raw["confidence_threshold"] : 0.7,
     jargon: wordsOf(raw["jargon"]),
+    prefer: preferOf(raw["prefer"]),
     requiredSections: wordsOf(raw["required_sections"]),
     byPath: byPathOf(raw["by_path"]),
     baseDir: dirname(path),

package/src/config/rule-problems.ts

@@ -0,0 +1,24 @@
+import type { Config } from "./load.ts";
+
+/**
+ * chaff.yaml の rules のうち、効いていないもの。知らない rule 名と、読めない値。
+ * どちらも黙って捨てると、書いた人は設定したつもりで何も変わっていない。打ち間違いがいちばん多い。
+ */
+export const ruleProblems = (
+  config: Pick<Config, "rules" | "limits" | "unreadableRules" | "path">,
+  known: readonly { readonly id: string; readonly layer: string }[],
+): string[] => {
+  const knownIds = new Set(known.map((rule) => rule.id));
+  const where = config.path ?? "chaff.yaml";
+  const written = [...new Set([...Object.keys(config.rules), ...Object.keys(config.limits), ...config.unreadableRules.map((entry) => entry.id)])];
+  const unknown = written.filter((id) => !knownIds.has(id)).map((id) => `${where}: ${id} というルールはありません（npx chaff rules --json で一覧が出ます）`);
+  const unreadable = config.unreadableRules
+    .filter((entry) => knownIds.has(entry.id))
+    .map((entry) => `${where}: ${entry.id} の値 ${entry.value} は読めません（strict / normal / relaxed / off か、正の数）`);
+  // 意味を読む検査（L4）に閾値は無い。数を書いても normal として動くので、そう言う。
+  const semantic = new Set(known.filter((rule) => rule.layer === "L4").map((rule) => rule.id));
+  const numberOnSemantic = Object.keys(config.limits)
+    .filter((id) => semantic.has(id))
+    .map((id) => `${where}: ${id} は意味を読む検査なので数値の上限はありません。normal として動きます（strict / normal / relaxed / off で書いてください）`);
+  return [...unknown, ...unreadable, ...numberOnSemantic];
+};

package/src/detectors/index.ts

@@ -14,6 +14,7 @@ import { paragraphLength, paragraphVariance, preambleLength, ruleOfThree, sectio
 import { concreteEvidence, dashDensity, emojiDensity, ngramRepetition, undefinedAcronym } from "./signals.ts";
 import { aiTell, contractionMix, cushionDensity, hedgingDensity, repeatedConjunction, unqualifiedSuperlative } from "./lexicon.ts";
 import { internalJargon, properNounDensity, requiredSections } from "./team.ts";
+import { latinSpacing, preferredTerm } from "./orthography.ts";
 import { danglingReference, duplicateDefinition, numberingGap } from "./structure-tree.ts";
 
 /** rule 定義の how_to_find がここを引く。rule 側は実装を知らない。 */
@@ -54,6 +55,8 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "internal-jargon": internalJargon,
   "required-sections": requiredSections,
   "proper-noun-density": properNounDensity,
+  "preferred-term": preferredTerm,
+  "latin-spacing": latinSpacing,
   "dangling-reference": danglingReference,
   "numbering-gap": numberingGap,
   "duplicate-definition": duplicateDefinition,

package/src/detectors/orthography.ts

@@ -0,0 +1,55 @@
+import type { Detector, Finding, Sentence } from "../plugin.ts";
+import { latinBoundaries, minorityStyle, occurrencesOutside, type SpacingKind } from "../orthography.ts";
+
+/** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
+export const preferredTerm: Detector = (doc, options): Finding[] => {
+  const pairs = (options.lexicon ?? []).flatMap((entry) => (entry.instead_of === undefined ? [] : [{ avoid: entry.pattern, use: entry.instead_of }]));
+  const hits = doc.sentences.flatMap((sentence) =>
+    pairs.flatMap((pair) => occurrencesOutside(sentence.text, pair.avoid, pair.use).map((at) => ({ sentence, at, pair }))),
+  );
+  if (hits.length === 0 || hits.length < options.limit) return [];
+  return hits.map((hit) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: hit.sentence.text.trim(),
+    values: { matched: hit.pair.avoid, preferred: hit.pair.use, count: hits.length, limit: options.limit, offset: hit.sentence.span.start + hit.at },
+  }));
+};
+
+const KIND_NAME: Readonly<Record<SpacingKind, string>> = { letter: "英字", "before-digit": "後ろの数字", "after-digit": "前の数字" };
+const KINDS: readonly SpacingKind[] = ["letter", "before-digit", "after-digit"];
+
+type Located = { readonly sentence: Sentence; readonly offset: number; readonly kind: SpacingKind; readonly spaced: boolean };
+
+/**
+ * 日本語と英字・数字のあいだを、空けるか詰めるか。文書の中で混ざっていたら、少ないほうを指摘する。
+ * どちらが正しいかは決めない。決めるのはチームで、chaff はそろっているかだけを見る。
+ */
+export const latinSpacing: Detector = (doc, options): Finding[] => {
+  const located: Located[] = doc.sentences.flatMap((sentence) => latinBoundaries(sentence.text).map((boundary) => ({ sentence, ...boundary })));
+  return KINDS.flatMap((kind) => {
+    const ofKind = located.filter((entry) => entry.kind === kind);
+    const minority = minorityStyle(ofKind);
+    if (minority === undefined) return [];
+    const odd = ofKind.filter((entry) => entry.spaced === minority);
+    if (odd.length < options.limit) return [];
+    return odd.map((entry) => ({
+      rule: "",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: entry.sentence.text.trim(),
+      values: {
+        kind: KIND_NAME[kind],
+        style: minority ? "空けています" : "詰めています",
+        usual: minority ? "詰める" : "空ける",
+        count: odd.length,
+        of: ofKind.length,
+        limit: options.limit,
+        offset: entry.sentence.span.start + entry.offset,
+      },
+    }));
+  });
+};

package/src/document.ts

@@ -3,6 +3,7 @@ import { gfmTable } from "micromark-extension-gfm-table";
 import { gfmTableFromMarkdown } from "mdast-util-gfm-table";
 import { frontmatter } from "micromark-extension-frontmatter";
 import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
+import { atxHeadingText, headingText } from "./heading-text.ts";
 import { maskSpans } from "./mask.ts";
 import { buildTree, NO_OUTLINE, type Outline } from "./structure/build.ts";
 import { isMarkdownPath } from "./structure/markdown-path.ts";
@@ -130,7 +131,10 @@ const headingsOf = (root: Node, source: string): Heading[] => {
     if (node.type !== "heading") return;
     const span = spanOf(node);
     const depth = typeof node === "object" && "depth" in node && typeof node.depth === "number" ? node.depth : 1;
-    if (span !== undefined) found.push({ depth, text: textOf(node, source).trim(), start: span.start, end: span.end });
+    if (span === undefined) return;
+    // ATX（行頭が #）なら閉じの # も外す。setext の見出しの末尾の # は言葉なので残す。
+    const read = source.startsWith("#", span.start) ? atxHeadingText : headingText;
+    found.push({ depth, text: read(textOf(node, source)), start: span.start, end: span.end });
   });
   return found;
 };
@@ -229,13 +233,23 @@ const listsOf = (root: Node, source: string): BulletList[] => {
 };
 
 /** チームが chaff.yaml に書いたもの。語彙表と同じ器に入れて、detector には出所を見せない。 */
-export type TeamRules = { readonly jargon: readonly string[]; readonly requiredSections: readonly string[] };
+export type TeamRules = {
+  readonly jargon: readonly string[];
+  readonly requiredSections: readonly string[];
+  /** { 使わない書き方: 使う書き方 }。preferred-term が語彙表として読む。 */
+  readonly prefer?: Readonly<Record<string, string>>;
+};
 
 const EMPTY_TEAM: TeamRules = { jargon: [], requiredSections: [] };
 
 /** Config から取り出す。document は Config の形を知らない。 */
-export const teamRules = (config: { readonly jargon: readonly string[]; readonly requiredSections: readonly string[] }): TeamRules => ({
+export const teamRules = (config: {
+  readonly jargon: readonly string[];
+  readonly requiredSections: readonly string[];
+  readonly prefer?: Readonly<Record<string, string>>;
+}): TeamRules => ({
   jargon: config.jargon,
+  prefer: config.prefer ?? {},
   requiredSections: config.requiredSections,
 });
 
@@ -263,7 +277,12 @@ export const buildDocument = (path: string, source: string, adapter: LanguageAda
     listSpans: listItems,
     paragraphs: paragraphsOf(paragraphSpans, sentences, listItems),
     lists: listsOf(root, source),
-    lexicons: { ...adapter.lexicons, "internal-jargon": team.jargon.map((pattern) => ({ pattern })) },
+    lexicons: {
+      ...adapter.lexicons,
+      "internal-jargon": team.jargon.map((pattern) => ({ pattern })),
+      // 使わない書き方を pattern に、使う書き方を instead_of に置く。語彙表の「同じことの別の書き方」と同じ向き。
+      "preferred-term": Object.entries(team.prefer ?? {}).map(([pattern, use]) => ({ pattern, instead_of: use })),
+    },
     requiredSections: team.requiredSections,
     // 構造の rule（参照先が無い・番号の抜け）が読む木。どの rule も読まなければ作らない。何万行の契約書で、他の rule の lint に代金を払わせない。
     get structure(): StructureNode | undefined {

package/src/eval.ts

@@ -35,11 +35,12 @@ const stricterIsHigher = (rule: RuleDefinition): boolean => (rule.levels.strict
 const MULTIPLIERS = [0.5, 0.7, 0.85, 1, 1.25, 1.5, 2, 3];
 
 /** rule 自身が持つ段を基点に掃引する。rule ごとに単位が違うので、倍率で散らす。 */
-const candidates = (rule: RuleDefinition): number[] => {
+const candidates = (rule: RuleDefinition, current: number): number[] => {
   const base = rule.levels.normal ?? 1;
   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])].sort((left, right) => left - right);
+  // 数値で決めた上限は、段の表に無くても掃引に入れる。入れないと「現在」の行が出ない。
+  return [...new Set([...fromLevels, ...scaled, current])].sort((left, right) => left - right);
 };
 
 const countAt = (docs: readonly ProseDocument[], rule: RuleDefinition, limit: number): Point => {
@@ -84,12 +85,22 @@ const measurable = (rule: RuleDefinition, docs: readonly ProseDocument[], genre:
   return rule.requires.every((need) => meets(need, docs));
 };
 
-export const evaluate = (docs: readonly ProseDocument[], rules: readonly RuleDefinition[], genre: string, language: string): RuleReport[] =>
+/**
+ * limits は chaff.yaml に数値で書いた上限。書いてあれば、それが lint で効いている「現在」の値。
+ * 段の言葉（relaxed など）で書いた設定は、これまでどおり normal の値を「現在」とする。
+ */
+export const evaluate = (
+  docs: readonly ProseDocument[],
+  rules: readonly RuleDefinition[],
+  genre: string,
+  language: string,
+  limits: Readonly<Record<string, number>> = {},
+): RuleReport[] =>
   rules
     .filter((rule) => measurable(rule, docs, genre, language))
     .map((rule) => {
-      const sweep = candidates(rule).map((limit) => countAt(docs, rule, limit));
-      const current = rule.levels.normal ?? 1;
+      const current = limits[rule.id] ?? rule.levels.normal ?? 1;
+      const sweep = candidates(rule, current).map((limit) => countAt(docs, rule, limit));
       return {
         rule: rule.id,
         name: rule.name[language] ?? rule.id,

package/src/heading-text.ts

@@ -0,0 +1,26 @@
+/**
+ * 見出しの末尾に付けた属性を外した、見出しの言葉。`## ステップ 1 {#step1}` は「ステップ 1」。
+ * kramdown（`{#id}`、`{: .class}`）と pandoc（`{#id .class}`）の書き方。属性は読者に見えないので、
+ * 残すと見出しの言い直しや番号の読み取りが、見えない文字に引きずられる。
+ * 波括弧で終わっていても、中身が `#` `.` `:` で始まらないもの（`## {name} の設定`）は言葉のうち。
+ */
+export const headingText = (raw: string): string => {
+  const trimmed = raw.trim();
+  if (!trimmed.endsWith("}")) return trimmed;
+  const open = trimmed.lastIndexOf("{");
+  if (open === -1) return trimmed;
+  const inner = trimmed.slice(open + 1, -1).trimStart();
+  const isAttributes = inner.startsWith("#") || inner.startsWith(".") || inner.startsWith(":");
+  return isAttributes ? trimmed.slice(0, open).trim() : trimmed;
+};
+
+/**
+ * ATX 見出し（`## 見出し ##`）の言葉。属性を外してから、閉じの `#` を外す。
+ * `## Install ## {#install}` は閉じの `#` の後ろに属性があるので、この順でないと `##` が言葉に残る。
+ * 下線で書く見出し（setext）には使わない。そちらの末尾の `##` は本当に言葉の一部。
+ */
+export const atxHeadingText = (content: string): string => {
+  const withoutAttributes = headingText(content);
+  const closing = withoutAttributes.search(/(?:^|[ \t])#+$/u);
+  return (closing === -1 ? withoutAttributes : withoutAttributes.slice(0, closing)).trim();
+};

package/src/orthography.ts

@@ -0,0 +1,115 @@
+// 表記のそろい。書き方の決まりのうち、文字だけで決まるもの。
+
+const escapeRegExp = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+/** text の中で word が現れる [始まり, 終わり) を、左から順に。大文字小文字を区別しないときは i で探す（位置は元の文字列のまま）。 */
+const spansOf = (text: string, word: string, ignoreCase: boolean): [number, number][] => {
+  const pattern = new RegExp(escapeRegExp(word), ignoreCase ? "giu" : "gu");
+  const found: [number, number][] = [];
+  for (let match = pattern.exec(text); match !== null; match = pattern.exec(text)) {
+    found.push([match.index, match.index + match[0].length]);
+    // 重なって現れるものも拾う。次は 1 つ先から探す。
+    pattern.lastIndex = match.index + 1;
+  }
+  return found;
+};
+
+/**
+ * avoid が現れる位置のうち、use の一部として現れたものを除いたもの。
+ * 「ユーザ」を避けて「ユーザー」と書く決まりのとき、「ユーザー」の中の「ユーザ」は指摘しない。
+ * 大文字小文字は区別しない（文頭の「E-mail」も「e-mail」）。ただし二つが大文字小文字だけ違う組
+ * （「Javascript」→「JavaScript」）は、それ自体が大文字小文字の決まりなので区別して探す。
+ */
+export const occurrencesOutside = (text: string, avoid: string, use: string): number[] => {
+  if (avoid === "") return [];
+  const ignoreCase = avoid.toLowerCase() !== use.toLowerCase();
+  const covered = use === "" ? [] : spansOf(text, use, ignoreCase);
+  const found: number[] = [];
+  // covered は始まりの順に並ぶ。始まりが at 以前のものの終わりの最大が end 以上なら、どれかに収まっている。
+  let next = 0;
+  let reach = -1;
+  let at = 0;
+  for (const [start, end] of spansOf(text, avoid, ignoreCase)) {
+    if (start < at) continue;
+    while (next < covered.length && (covered[next]?.[0] ?? Infinity) <= start) {
+      reach = Math.max(reach, covered[next]?.[1] ?? -1);
+      next += 1;
+    }
+    if (reach < end) found.push(start);
+    at = end;
+  }
+  return found;
+};
+
+export type SpacingKind = "letter" | "before-digit" | "after-digit";
+export type Boundary = { readonly offset: number; readonly kind: SpacingKind; readonly spaced: boolean };
+
+const JAPANESE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}ー]/u;
+const LETTER = /[A-Za-z]/u;
+const DIGIT = /\d/u;
+
+/** Latin 側の字の種類。digitSide は、その数字が日本語の右（前に日本語）か左（後ろに日本語）か。 */
+const kindOf = (char: string | undefined, digitSide: "before-digit" | "after-digit"): SpacingKind | undefined => {
+  if (char === undefined) return undefined;
+  if (LETTER.test(char)) return "letter";
+  return DIGIT.test(char) ? digitSide : undefined;
+};
+
+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 =>
+  isJapanese(japanese) ? kindOf(other, digitSide) : undefined;
+
+/** 日本語の字の隣にある英字・数字との境目。間が半角空白 1 つなら「空けている」、何も無ければ「詰めている」。 */
+const ALPHANUMERIC = /[A-Za-z0-9.]/u;
+
+/**
+ * 日本語の左にある英数字の並びの、先頭の字。「3GBの」の「GB」は数量の単位で、並びは数字で始まる。
+ * そうした並びと日本語の境目は、英字の空け方ではなく数字の後ろの空け方として数える（「3回」と同じ）。
+ */
+const runStart = (chars: readonly string[], last: number): string | undefined => {
+  let first = last;
+  while (first > 0 && ALPHANUMERIC.test(chars[first - 1] ?? "")) first -= 1;
+  return chars[first];
+};
+
+/** 左の並びの種類。数字で始まる並び（3GB、10ms）は数字として扱う。 */
+const leftRunBeside = (chars: readonly string[], last: number, japanese: string | undefined): SpacingKind | undefined => {
+  const kind = latinBeside(japanese, chars[last], "after-digit");
+  return kind === "letter" && DIGIT.test(runStart(chars, last) ?? "") ? "after-digit" : kind;
+};
+
+const boundaryAt = (chars: readonly string[], index: number): Omit<Boundary, "offset"> | undefined => {
+  const [left, right, after] = [chars[index], chars[index + 1], chars[index + 2]];
+  const touching = latinBeside(left, right, "before-digit") ?? leftRunBeside(chars, index, right);
+  if (touching !== undefined) return { kind: touching, spaced: false };
+  if (right !== " ") return undefined;
+  const spaced = latinBeside(left, after, "before-digit") ?? leftRunBeside(chars, index, after);
+  return spaced === undefined ? undefined : { kind: spaced, spaced: true };
+};
+
+/** 文の中の境目を全部。offset は境目の位置（左の字の直後、UTF-16）。配列を作り直さずに一度なめる。 */
+export const latinBoundaries = (text: string): Boundary[] => {
+  const chars = [...text];
+  const found: Boundary[] = [];
+  let offset = 0;
+  chars.forEach((char, index) => {
+    offset += char.length;
+    const boundary = boundaryAt(chars, index);
+    if (boundary !== undefined) found.push({ ...boundary, offset });
+  });
+  return found;
+};
+
+/**
+ * 混ざっているとき、そろえるべき少数派。種類（英字・数字の前・数字の後ろ）ごとに数える。
+ * 同数なら、文書が先に使った書き方をその文書の書き方とみなし、後から出た書き方を少数派にする。
+ */
+export const minorityStyle = (boundaries: readonly Boundary[]): boolean | undefined => {
+  const spaced = boundaries.filter((boundary) => boundary.spaced).length;
+  const touching = boundaries.length - spaced;
+  if (spaced === 0 || touching === 0) return undefined;
+  if (spaced !== touching) return spaced < touching;
+  return !(boundaries[0]?.spaced ?? false);
+};

package/src/render/rules-json.ts

@@ -5,6 +5,8 @@ import type { RuleDefinition } from "../plugin.ts";
 const now = (rule: RuleDefinition, config: Config, genre: string): Record<string, unknown> => {
   const explicit = config.rules[rule.id];
   if (explicit === "off") return { level: "off", why_off: "設定で止めている" };
+  const limit = rule.layer === "L4" ? undefined : config.limits[rule.id];
+  if (limit !== undefined) return { level: "normal", limit, set_as: "number" };
   if (explicit !== undefined) return { level: explicit, limit: resolve(rule, explicit, genre).limit };
   if (rule.status === "experimental" && !config.experimental) {
     return { level: "off", why_off: "experimental な rule は既定で動かさない", turn_on_with: `npx chaff lint --experimental` };
@@ -12,6 +14,13 @@ const now = (rule: RuleDefinition, config: Config, genre: string): Record<string
   return { level: "normal", limit: resolve(rule, "normal", genre).limit };
 };
 
+const yourSetting = (rule: RuleDefinition, config: Config): Record<string, unknown> | null => {
+  const level = config.rules[rule.id];
+  if (level === undefined) return null;
+  const limit = rule.layer === "L4" ? undefined : config.limits[rule.id];
+  return limit === undefined ? { level, from: config.path } : { level, limit, from: config.path };
+};
+
 /** ジャンルで数字が変わる rule があるので、いま効いている表と既定の表の両方を出す。 */
 const levelsOf = (rule: RuleDefinition, genre: string): Record<string, unknown> => {
   const effective = Object.fromEntries(
@@ -42,7 +51,7 @@ export const rulesJson = (rules: readonly RuleDefinition[], config: Config, lang
         use_for: rule.use_for,
         ...levelsOf(rule, genre),
         levels_you_can_set: definedLevels(rule),
-        your_setting: config.rules[rule.id] === undefined ? null : { level: config.rules[rule.id], from: config.path },
+        your_setting: yourSetting(rule, config),
         now: now(rule, config, genre),
       })),
       how_to_change: {

package/src/run.ts

@@ -92,7 +92,19 @@ const compositeOf = (rule: RuleDefinition, found: readonly Finding[], limit: num
   ];
 };
 
-export const runRules = (doc: ProseDocument, rules: readonly RuleDefinition[], settings: Settings, experimental: boolean, genre: string): RunResult => {
+/** chaff.yaml の rules に数値で書いた上限。段階の表より先に効く。 */
+export type Limits = Readonly<Record<string, number>>;
+
+const limitFor = (rule: RuleDefinition, level: Level, genre: string, limits: Limits): number => limits[rule.id] ?? resolve(rule, level, genre).limit;
+
+export const runRules = (
+  doc: ProseDocument,
+  rules: readonly RuleDefinition[],
+  settings: Settings,
+  experimental: boolean,
+  genre: string,
+  limits: Limits = {},
+): RunResult => {
   const starts = lineStarts(doc.source);
   const applicable = forGenre(rules, genre);
   const forced = applicable
@@ -121,7 +133,7 @@ export const runRules = (doc: ProseDocument, rules: readonly RuleDefinition[], s
       const detector = DETECTORS[rule.how_to_find];
       if (detector === undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: `検出器 ${rule.how_to_find} がないため` }] };
       const options = {
-        limit: resolve(rule, level, genre).limit,
+        limit: limitFor(rule, level, genre, limits),
         lexicon: rule.word_list === undefined ? undefined : doc.lexicons[rule.word_list],
         where: rule.where,
       };
@@ -136,7 +148,7 @@ export const runRules = (doc: ProseDocument, rules: readonly RuleDefinition[], s
   );
   const composites = applicable
     .filter((rule) => rule.from.length > 0 && levelFor(rule, settings, experimental) !== "off")
-    .flatMap((rule) => compositeOf(rule, outcome.findings, resolve(rule, levelFor(rule, settings, experimental), genre).limit, starts));
+    .flatMap((rule) => compositeOf(rule, outcome.findings, limitFor(rule, levelFor(rule, settings, experimental), genre, limits), starts));
   const all = [...outcome.findings, ...composites];
   return { ...outcome, findings: [...all].sort((left, right) => left.line - right.line), forcedExperimental: forced };
 };

package/src/structure/build.ts

@@ -1,4 +1,5 @@
 import type { Heading } from "../document.ts";
+import { atxHeadingText, headingText } from "../heading-text.ts";
 import { maskSpans } from "../mask.ts";
 import type { Mention, NumberedLine, NumberingContext, Span, StructureKind, StructureNode, StructurePatterns } from "../plugin.ts";
 import { lineNumberAt, linesOf, type Line } from "./lines.ts";
@@ -156,17 +157,18 @@ const headingsByLine = (lines: readonly Line[], headings: readonly Heading[]): M
   );
 
 /** 見出しの行から「#」の印を外した文字列。コードを覆った後の行から取るので、見出しの中のコードも読まない。 */
-const atxText = (text: string): string => {
-  const body = text
-    .trim()
-    .replace(/^#{1,6}(?=[ \t]|$)/u, "")
-    .trim();
-  const closing = body.search(/[ \t]#+$/u);
-  return (closing === -1 ? body : body.slice(0, closing)).trim();
+/**
+ * 見出しの行から見出しの言葉を取る。コードを覆った後の行から取るので、見出しの中のコードも読まない。
+ * ATX（行頭が #）なら印と閉じの # を外す。setext（下線で書く見出し）の末尾の # は言葉なので残す。
+ */
+const headingLineText = (text: string): string => {
+  const line = text.trim();
+  if (!line.startsWith("#")) return headingText(line);
+  return atxHeadingText(line.replace(/^#{1,6}(?=[ \t]|$)/u, "").trim());
 };
 
 const readLine = (state: State, patterns: StructurePatterns, line: Line, heading: Heading | undefined): void => {
-  const text = heading === undefined ? line.text : atxText(line.text);
+  const text = heading === undefined ? line.text : headingLineText(line.text);
   const openNumbers = state.stack.flatMap((frame) => (frame.numbered === undefined ? [] : [frame.numbered]));
   const context = { open: openNumbers, isHeading: heading !== undefined };
   const numbered = patterns.numbered(text, context) ?? universalNumber(patterns, text, context);