chaffjs 0.28.0 → 0.29.0

package/src/place-names.ts

@@ -0,0 +1,248 @@
+import { isNearWord, nameKey } from "./name-variants.ts";
+import { escapeRegExp } from "./orthography.ts";
+import { toKatakana } from "./kana-spelling.ts";
+
+// 場所の名前を、文書の中で二通りに書いた所（八重洲中央口 と 八重州中央口、11th Street と 11th St.、King's Cross と Kings Cross）。
+// 場所の名前は、場所を言う語（口、駅、センター、Street、Station）で終わる名前。場所の語は語彙表 place-word が言い、group が同じ語は
+// 同じ語の別の書き方（Street と St.、Center と Centre）。名前の部分は、場所の語のすぐ前の、名前に使う字の連なり。
+
+type Span = { readonly start: number; readonly end: number };
+
+export type PlaceWord = { readonly pattern: string; readonly group: string };
+
+/**
+ * surface は場所の語も含めた書いたまま。base は名前の部分、place は場所の語の組。reading は名前の部分の読み（読めなければ無い）。properAt は
+ * base の字のうち、品詞解析が固有名詞と読んだ語に入る字の位置（八重洲中央口 の 八・重・洲）。
+ */
+export type PlaceMention = {
+  readonly surface: string;
+  readonly offset: number;
+  readonly base: string;
+  readonly place: string;
+  readonly reading?: string | undefined;
+  readonly properAt: readonly number[];
+};
+
+/**
+ * 名前の現れの読み方。properWords は範囲に掛かる、品詞解析が固有名詞と読んだ語の範囲、isFunctionWord は名前の頭に立たない語（The、At）、readingOf は範囲の読み、joiners は
+ * 英字の名前の中に立つ小さい語（of）。
+ */
+export type PlaceReader = {
+  readonly properWords: (start: number, end: number) => readonly Span[];
+  readonly joiners: ReadonlySet<string>;
+  readonly isFunctionWord: (start: number, end: number) => boolean;
+  readonly readingOf: (start: number, end: number) => string | undefined;
+};
+
+/** spelling は記号・幅・大小だけ、place-word は場所の語の書き方、reading は読みが同じ、near は名前の一字違い。 */
+export type PlaceRelation = "spelling" | "place-word" | "reading" | "near";
+
+export type PlaceVariant = { readonly mention: PlaceMention; readonly usual: string; readonly kind: PlaceRelation };
+
+const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+/** 漢字・カタカナの名前に使う字。ひらがなは名前の外（の、で、にて）。 */
+const CJK_NAME = /[\p{Script=Katakana}\p{Script=Han}\p{Script=Latin}\p{N}ー・々]/u;
+const HIRAGANA = /\p{Script=Hiragana}/u;
+const JOINER = "・";
+/** かなだけの名前の前に立つもの。空白、行の頭、開き括弧。読点のあと（、この口）は文の続き。 */
+const KANA_NAME_OPENS = /^$|[\s（「『【([]/u;
+/** 英字の名前の一語。大文字で始まる語か、序数（11th）。 */
+const LATIN_NAME_WORD = /^(?:\p{Lu}[\p{L}'’&-]*|\d+(?:st|nd|rd|th))$/u;
+
+/** 場所の語が語の終わりに立つか。続く字が名前の字なら、長い語の一部（口座、Streetcar）。 */
+const endsWord = (source: string, end: number, latin: boolean): boolean => {
+  const next = source.charAt(end);
+  return latin ? !LETTER.test(next) : !CJK_NAME.test(next) || next === JOINER;
+};
+
+/** 名前を探す、場所の語の前の範囲（UTF-16 の単位）。 */
+const LOOKBACK = 40;
+
+/** end のすぐ前の、char の字の連なりの始まり。 */
+const runStart = (source: string, end: number, char: RegExp): number => {
+  const chars = Array.from(source.slice(Math.max(0, end - LOOKBACK), end));
+  return end - chars.slice(chars.findLastIndex((letter) => !char.test(letter)) + 1).join("").length;
+};
+
+/**
+ * 漢字・カタカナの名前: 場所の語の前の、名前に使う字の連なり。それが無く、空白や開き括弧のあとにひらがなだけが続くなら、かなで書いた
+ * 名前（博多駅 ちくし口）。語のあとのひらがな（東京駅の北口 の の）は名前の外。
+ */
+const cjkBaseBefore = (source: string, end: number): Span | undefined => {
+  const start = runStart(source, end, CJK_NAME);
+  const kanaStart = start === end ? runStart(source, end, HIRAGANA) : start;
+  const from = kanaStart < start && !KANA_NAME_OPENS.test(source.charAt(kanaStart - 1)) ? start : kanaStart;
+  const trimmed = source.startsWith(JOINER, from) ? from + 1 : from;
+  return trimmed < end ? { start: trimmed, end } : undefined;
+};
+
+/** 英字の名前の一語の前に、空白一つで続く語。 */
+const wordBefore = (source: string, at: number): Span | undefined => {
+  if (source.charAt(at - 1) !== " ") return undefined;
+  const from = Math.max(0, at - 1 - LOOKBACK);
+  const text = source.slice(from, at - 1);
+  const parts = text.split(/\s/u);
+  const word = parts.at(-1) ?? "";
+  if (word === "" || (from > 0 && parts.length === 1)) return undefined;
+  const start = from + text.length - word.length;
+  return { start, end: start + word.length };
+};
+
+/** 名前の前の、大文字で始まる短い略語（St. George Street の St.）。名前はそこから続くので、どこからが名前か分からない。 */
+const LEADING_ABBREVIATION = /^\p{Lu}\p{L}{0,2}\.$/u;
+
+/**
+ * 英字の名前: 場所の語の前の、空白一つでつながる大文字の語か序数の続き。名前の中の小さい語（University of Tokyo の of）は語彙表
+ * place-name-joiner が言う。頭の機能語（The、At）は外す。前に略語（St.）が立てば、名前の始まりが分からないので読まない。
+ */
+const latinBaseBefore = (source: string, end: number, reader: PlaceReader): Span | undefined => {
+  const words: Span[] = [];
+  const isNameWord = (span: Span | undefined): span is Span => span !== undefined && LATIN_NAME_WORD.test(source.slice(span.start, span.end));
+  const step = (at: number): Span | undefined => {
+    const word = wordBefore(source, at);
+    if (word === undefined) return undefined;
+    const joined = reader.joiners.has(source.slice(word.start, word.end)) && isNameWord(wordBefore(source, word.start));
+    if (!isNameWord(word) && !joined) return word;
+    words.unshift(word);
+    return step(word.start);
+  };
+  const stopper = step(end);
+  if (stopper !== undefined && LEADING_ABBREVIATION.test(source.slice(stopper.start, stopper.end))) return undefined;
+  const name = words.slice(
+    Math.max(
+      0,
+      words.findIndex((word) => !reader.isFunctionWord(word.start, word.end)),
+    ),
+  );
+  const [first, last] = [name[0], name.at(-1)];
+  return first === undefined || last === undefined || reader.isFunctionWord(first.start, first.end) ? undefined : { start: first.start, end: last.end };
+};
+
+/**
+ * base の字のうち、名前の部分の中で閉じる固有名詞の語に入る字の位置。場所の語まで続く固有名詞（北口、日比谷公園）は、名前でなく
+ * 出口や施設の呼び名として読まれたものなので数えない。
+ */
+const properIndexes = (source: string, base: Span, properWords: readonly Span[]): number[] => {
+  const inside = properWords.filter((word) => word.end <= base.end);
+  return Array.from(source.slice(base.start, base.end)).flatMap((_char, index, chars) => {
+    const at = base.start + chars.slice(0, index).join("").length;
+    return inside.some((word) => word.start <= at && at < word.end) ? [index] : [];
+  });
+};
+
+const mentionAt = (source: string, word: PlaceWord, at: number, reader: PlaceReader): PlaceMention | undefined => {
+  const latin = LATIN.test(word.pattern);
+  const end = at + word.pattern.length;
+  if (!endsWord(source, end, latin) || (latin && LETTER.test(source.charAt(at - 1)))) return undefined;
+  const base = latin ? latinBaseBefore(source, at, reader) : cjkBaseBefore(source, at);
+  if (base === undefined) return undefined;
+  return {
+    surface: source.slice(base.start, end),
+    offset: base.start,
+    base: source.slice(base.start, latin ? at - 1 : at),
+    place: word.group,
+    reading: latin ? undefined : reader.readingOf(base.start, at),
+    properAt: latin ? [] : properIndexes(source, base, reader.properWords(base.start, end)),
+  };
+};
+
+/** 文書の中の場所の名前の現れ。同じ所で終わる場所の語は長いほうを取る（中央口 と 口）。 */
+export const placeMentionsIn = (source: string, words: readonly PlaceWord[], reader: PlaceReader): PlaceMention[] => {
+  const ends = new Set<number>();
+  return words
+    .toSorted((left, right) => right.pattern.length - left.pattern.length)
+    .flatMap((word) =>
+      [...source.matchAll(new RegExp(escapeRegExp(word.pattern), "gu"))].flatMap((match) => {
+        const end = match.index + word.pattern.length;
+        if (ends.has(end)) return [];
+        const mention = mentionAt(source, word, match.index, reader);
+        if (mention !== undefined) ends.add(end);
+        return mention === undefined ? [] : [mention];
+      }),
+    )
+    .toSorted((left, right) => left.offset - right.offset);
+};
+
+const DIGIT = /\p{N}/u;
+
+/** 漢字・かなの名前の部分が一字だけ違い、その字が、多いほうで固有名詞の語に入る（八重洲 と 八重州）。数字や方角（北口 と 南口）は別の所。 */
+const isCjkSlip = (slip: PlaceMention, usual: PlaceMention): boolean => {
+  const [slipChars, usualChars] = [[...slip.base], [...usual.base]];
+  if (slipChars.length !== usualChars.length) return false;
+  const differ = usualChars.flatMap((char, index) => (char === slipChars[index] ? [] : [index]));
+  const [at] = differ;
+  return differ.length === 1 && at !== undefined && usual.properAt.includes(at) && !DIGIT.test(usualChars[at] ?? "") && !DIGIT.test(slipChars[at] ?? "");
+};
+
+const latinWords = (base: string): string[] =>
+  base
+    .toLowerCase()
+    .replaceAll(/['’]/gu, "")
+    .split(/[\s-]+/u);
+
+/** 英字の名前の部分が、一語だけ一字違い（Union と Unoin）。 */
+const isLatinSlip = (slip: PlaceMention, usual: PlaceMention): boolean => {
+  const [slipWords, usualWords] = [latinWords(slip.base), latinWords(usual.base)];
+  const differ = usualWords.flatMap((word, index) => (word === slipWords[index] ? [] : [index]));
+  const [at] = differ;
+  return slipWords.length === usualWords.length && differ.length === 1 && at !== undefined && isNearWord(slipWords[at] ?? "", usualWords[at] ?? "");
+};
+
+const HIRAGANA_ONLY = /^\p{Script=Hiragana}+$/u;
+
+/**
+ * ひらがなで書いた名前（ちくし）が、漢字で書いた名前（筑紫）の読みと同じか、一字だけ違う。解析器は地名の読みを一通りしか持たず
+ * （筑紫 を ツクシ と読む）、かなで書いた読み（チクシ）と一字ずれることがある。
+ */
+const isKanaSpellingOf = (slip: PlaceMention, usual: PlaceMention): boolean => {
+  if (!HIRAGANA_ONLY.test(slip.base) || usual.reading === undefined || HIRAGANA_ONLY.test(usual.base)) return false;
+  const [kana, reading] = [[...toKatakana(slip.base)], [...usual.reading]];
+  return kana.length === reading.length && kana.filter((char, index) => char !== reading[index]).length <= 1;
+};
+
+/** 一度だけ書いた形と、二度以上書いた形。読みの同じ別の所や一字違いの別の所もあるので、書き損じと見るのはこのときだけ。 */
+type Counted = { readonly mention: PlaceMention; readonly count: number };
+
+const isSlipOf = (slip: Counted, usual: Counted): boolean => slip.count === 1 && usual.count >= 2;
+
+/**
+ * 二つの書き方が、同じ所を二通りに書いたものか。場所の語の組が同じで、名前と語の全体が記号・幅・大小だけ違うか、場所の語の
+ * 書き方だけが違う（11th St. と 11th Street）か。名前の部分の読みが同じか、かなで書いた読み（筑紫口 と ちくし口）か、一字違い
+ * （八重洲 と 八重州）なのは、
+ * 少ないほうが一度だけ、多いほうが二度以上のときに限る。
+ */
+export const placeRelation = (slip: Counted, usual: Counted): PlaceRelation | undefined => {
+  const [left, right] = [slip.mention, usual.mention];
+  if (left.surface === right.surface || left.place !== right.place) return undefined;
+  if (nameKey(left.surface) === nameKey(right.surface)) return "spelling";
+  if (nameKey(left.base) === nameKey(right.base)) return "place-word";
+  if (!isSlipOf(slip, usual)) return undefined;
+  if ((left.reading !== undefined && left.reading === right.reading) || isKanaSpellingOf(left, right)) return "reading";
+  const latin = LATIN.test(left.base) && LATIN.test(right.base);
+  const slipped = latin ? isLatinSlip(left, right) : isCjkSlip(left, right);
+  return slipped ? "near" : undefined;
+};
+
+const talliesOf = (mentions: readonly PlaceMention[]): Counted[] => {
+  const tallies = new Map<string, Counted>();
+  mentions.forEach((mention) => {
+    const tally = tallies.get(mention.surface);
+    tallies.set(mention.surface, { mention: tally?.mention ?? mention, count: (tally?.count ?? 0) + 1 });
+  });
+  return [...tallies.values()];
+};
+
+/** 多いほうが先。同数なら先に書いたほう。 */
+const byUsage = (left: Counted, right: Counted): number => right.count - left.count || left.mention.offset - right.mention.offset;
+
+/** 同じ所の、少ないほうの書き方。同じ所と言える相手のうち一番多いものと比べる。書き方ごとに最初の現れを一つ。 */
+export const placeVariants = (mentions: readonly PlaceMention[]): PlaceVariant[] => {
+  const tallies = talliesOf(mentions);
+  return tallies.flatMap((tally) => {
+    const [usual] = tallies.filter((other) => other !== tally && placeRelation(tally, other) !== undefined).toSorted(byUsage);
+    if (usual === undefined || byUsage(usual, tally) > 0) return [];
+    const kind = placeRelation(tally, usual);
+    return kind === undefined ? [] : [{ mention: tally.mention, usual: usual.mention.surface, kind }];
+  });
+};

package/src/plugin.ts

@@ -275,6 +275,8 @@ export type DocumentProfile = {
    * inside の単位の行に、番号の後ろの本文が続くときだけ。
    */
   readonly unnumbered?: { readonly indent: string; readonly inside: string; readonly depth: number } | undefined;
+  /** 定義した語を括弧に入れて、語そのものを指す（「株主」とあるのは、"controller" has the same meaning）。定義し直しでも、括弧の付け忘れでもない。 */
+  readonly quoteMentionsTerm?: boolean | undefined;
 };
 
 /**
@@ -497,6 +499,8 @@ export type RuleDefinition = {
   /** 動かす言語。未指定は全言語。「ですます調」のように言語に固有の rule が使う。 */
   readonly languages: readonly string[] | undefined;
   readonly use_for: readonly string[];
+  /** Off unless chaff.yaml or its style gives the rule a level: a house style's own rule (a 公用文 spelling), wrong for other documents. */
+  readonly opt_in?: true;
   readonly severity: Severity;
   /** Options beyond the level (the direction and length for katakana-long-vowel). Most rules have none. */
   readonly options?: Readonly<Record<string, RuleOption>>;

package/src/prerequisite-order.ts

@@ -0,0 +1,39 @@
+// A prerequisite ("Before you begin, stop the service", 「作業を始める前に、」) written after the numbered steps of its own
+// section: the reader has done the steps by the time they read it. Pure; the openers come from the language's
+// prerequisite-opener lexicon.
+
+/** A span of the source, and the text of a sentence there. */
+export type Placed = { readonly start: number; readonly end: number };
+export type PlacedSentence = Placed & { readonly text: string };
+
+/**
+ * What may follow an opener: a comma, or the end of the sentence. "Before you begin step 3" names one step, and
+ * 「始める前に戻すには」 is a state to return to, not a prerequisite.
+ */
+const AFTER_OPENER = new Set([",", "、", "，", ""]);
+
+/** Whether a sentence opens with one of the openers, as a phrase of its own. */
+export const opensWithPrerequisite = (text: string, openers: readonly string[]): boolean => {
+  const lowered = text.trimStart().toLowerCase();
+  return openers.some((opener) => {
+    const target = opener.toLowerCase();
+    return lowered.startsWith(target) && AFTER_OPENER.has(lowered.charAt(target.length));
+  });
+};
+
+/**
+ * The sentences that open with a prerequisite and come after a numbered procedure ending in the same section. A section's
+ * prerequisite for a later section's steps comes before those steps, in that section, and is not reported.
+ */
+export const latePrerequisites = (
+  sections: readonly Placed[],
+  procedures: readonly Placed[],
+  sentences: readonly PlacedSentence[],
+  openers: readonly string[],
+): PlacedSentence[] =>
+  sentences.filter((sentence) => {
+    if (!opensWithPrerequisite(sentence.text, openers)) return false;
+    const section = sections.findLast((candidate) => candidate.start <= sentence.start && sentence.start < candidate.end);
+    if (section === undefined) return false;
+    return procedures.some((procedure) => procedure.start >= section.start && procedure.end <= sentence.start);
+  });

package/src/profile/parse.ts

@@ -90,7 +90,16 @@ const languagesOf = (id: string, raw: Record<string, unknown>): Record<string, D
         const unnumbered = unnumberedOf(section["unnumbered"]);
         return [
           language,
-          { id, addresses: strings(section["addresses"]), connectives: strings(section["connectives"]), addressEnd, caption, relative, unnumbered },
+          {
+            id,
+            addresses: strings(section["addresses"]),
+            connectives: strings(section["connectives"]),
+            addressEnd,
+            caption,
+            relative,
+            unnumbered,
+            ...(section["quote_mentions_term"] === true ? { quoteMentionsTerm: true } : {}),
+          },
         ];
       }),
   );

package/src/reasons.ts

@@ -9,6 +9,8 @@ export type Reasons = {
   readonly unreadTags: string;
   readonly semantic: string;
   readonly experimental: string;
+  /** A rule of one house style: it runs when chaff.yaml names that style, or gives the rule a level. */
+  readonly optIn: string;
   readonly turnedOff: string;
   readonly presetOff: (genre: string) => string;
   readonly noStructure: (language: string) => string;
@@ -41,6 +43,7 @@ export const REASONS: Texts<Reasons> = {
     unreadTags: "言語のパッケージがこの文書を読めなかったため（品詞の取れない段落があります）",
     semantic: "意味を読む検査のため（npx chaffjs test で動きます）",
     experimental: "まだ試験中のため",
+    optIn: "決まった書き方（chaff.yaml の style）のための rule で、style か rules で動かすため",
     turnedOff: "設定で止めているため",
     presetOff: (genre) => `ジャンル ${genre} では見ないため`,
     noStructure: (language) => `${language} のパッケージは文書の構造を読めないため`,
@@ -63,6 +66,7 @@ export const REASONS: Texts<Reasons> = {
     unreadTags: "the language package could not read this document (some paragraphs have no parts of speech)",
     semantic: "it reads meaning; npx chaffjs test runs it",
     experimental: "still experimental",
+    optIn: "it belongs to a house style, and runs when chaff.yaml names the style or gives it a level",
     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`,

package/src/render/rules-json.ts

@@ -21,6 +21,7 @@ const TEXT: Texts<{
   readonly offByGenre: (genre: string) => string;
   readonly offUnsuited: (genre: string) => string;
   readonly offExperimental: string;
+  readonly offOptIn: string;
   readonly valuesNote: string;
   readonly reason: string;
   readonly byFile: string;
@@ -32,6 +33,7 @@ const TEXT: Texts<{
     offByGenre: (genre) => `ジャンル ${genre} では見ない`,
     offUnsuited: (genre) => `ジャンル ${genre} の文書には向かない rule（use_for）`,
     offExperimental: "experimental な rule は既定で動かさない",
+    offOptIn: "決まった書き方（style）のための rule で、chaff.yaml の style か rules で動かす",
     valuesNote: "この 4 語のかわりに数字を直接書いてもよい。4 語のほうを勧める。",
     reason: "<理由>",
     byFile: "chaff.yaml の rules に <rule-id>: <level> を足す。既定のままのものは書かない。",
@@ -49,6 +51,7 @@ const TEXT: Texts<{
     offByGenre: (genre) => `the ${genre} genre does not check it`,
     offUnsuited: (genre) => `not a rule for ${genre} documents (use_for)`,
     offExperimental: "experimental rules do not run by default",
+    offOptIn: "a house style's rule: it runs when chaff.yaml names the style or gives it a level",
     valuesNote: "A number may be written instead of these four words. The words are recommended.",
     reason: "<reason>",
     byFile: "Add <rule-id>: <level> under rules in chaff.yaml. Leave out anything at its default.",
@@ -76,6 +79,7 @@ const now = (rule: RuleDefinition, config: Config, limits: Limits, genre: string
   const limit = rule.level_sets === "severity" ? undefined : limits[rule.id];
   if (limit !== undefined) return { level: "normal", limit, set_as: "number" };
   if (explicit !== undefined) return { level: explicit, ...effectAt(rule, explicit, genre) };
+  if (rule.opt_in === true) return { level: "off", why_off: text.offOptIn };
   if (rule.status === "experimental" && !config.experimental) {
     const alone = offOnlyAsExperimental(rule, config, genre, preset, language);
     return { level: "off", why_off: text.offExperimental, ...(alone ? { turn_on_with: `npx chaffjs enable ${rule.id}` } : {}) };

package/src/render/rules-table.ts

@@ -7,7 +7,7 @@ import { nowFor } from "./rules-json.ts";
 // `chaff rules`: every rule, grouped the way the reference groups them, with the level it runs at now.
 // `chaff rules --json` carries the same and more, for an AI to read.
 
-type RunsWhen = "default" | "experimental" | "team" | "test";
+type RunsWhen = "default" | "experimental" | "style" | "team" | "test";
 
 const TEXT: Texts<{
   readonly heading: (genre: string, count: number) => string;
@@ -17,11 +17,12 @@ const TEXT: Texts<{
 }> = {
   ja: {
     heading: (genre, count) => `chaff のルール ${count} 本（ジャンル ${genre}）`,
-    runsWhen: { default: "既定", experimental: "試験中", team: "要設定", test: "AI" },
+    runsWhen: { default: "既定", experimental: "試験中", style: "style", team: "要設定", test: "AI" },
     ungrouped: "（グループ未設定）",
     footer: [
       "既定: 何も書かなくても動く   試験中: --experimental か chaff.yaml で動く",
       "要設定: chaff.yaml に語や見出しを書いたときだけ   AI: npx chaffjs test で動く",
+      "style: chaff.yaml の style（koyobun など）か rules で動く",
       "",
       "詳しく:    npx chaffjs explain <rule>",
       "AI に渡す: npx chaffjs rules --json",
@@ -29,11 +30,12 @@ const TEXT: Texts<{
   },
   en: {
     heading: (genre, count) => `chaff's ${count} rules (genre ${genre})`,
-    runsWhen: { default: "default", experimental: "experimental", team: "needs list", test: "AI" },
+    runsWhen: { default: "default", experimental: "experimental", style: "style", team: "needs list", test: "AI" },
     ungrouped: "(no group yet)",
     footer: [
       "default: runs with no settings   experimental: runs with --experimental or a level in chaff.yaml",
       "needs list: runs only on words or headings listed in chaff.yaml   AI: runs with npx chaffjs test",
+      "style: runs with a style in chaff.yaml (koyobun and others) or a level under rules",
       "",
       "More on one rule:  npx chaffjs explain <rule>",
       "For an AI:         npx chaffjs rules --json",
@@ -44,6 +46,7 @@ const TEXT: Texts<{
 const runsWhenOf = (rule: RuleDefinition): RunsWhen => {
   if (rule.layer === "L4") return "test";
   if (rule.guide?.group === "team") return "team";
+  if (rule.opt_in === true) return "style";
   return rule.status === "experimental" ? "experimental" : "default";
 };
 

package/src/rule-genres.ts

@@ -2,24 +2,27 @@ import type { Level, RuleDefinition } from "./plugin.ts";
 
 /**
  * How a rule stands in one genre, with no chaff.yaml: the same order of precedence as a run (use_for, then the genre's
- * preset, then the rule's status).
+ * preset, then opt_in, then the rule's status).
  *   unsuited:     the rule is not for this kind of document (use_for), and does not run
  *   genre-off:    the genre's preset turns it off
+ *   opt-in:       it runs only where chaff.yaml's style or rules give it a level
  *   experimental: it runs only with --experimental or a level in chaff.yaml
  *   on:           it runs, at this level
  */
 export type GenreStanding =
   | { readonly kind: "unsuited" }
   | { readonly kind: "genre-off" }
+  | { readonly kind: "opt-in" }
   | { readonly kind: "experimental" }
   | { readonly kind: "on"; readonly level: Exclude<Level, "off">; readonly byPreset: boolean };
 
-type RuleFacts = Pick<RuleDefinition, "id" | "status" | "use_for">;
+type RuleFacts = Pick<RuleDefinition, "id" | "status" | "use_for" | "opt_in">;
 
 export const standingIn = (rule: RuleFacts, genre: string, preset: Readonly<Record<string, Level>>): GenreStanding => {
   if (!rule.use_for.some((target) => genre.startsWith(target))) return { kind: "unsuited" };
   const fromPreset = preset[rule.id];
   if (fromPreset === "off") return { kind: "genre-off" };
   if (fromPreset !== undefined) return { kind: "on", level: fromPreset, byPreset: true };
+  if (rule.opt_in === true) return { kind: "opt-in" };
   return rule.status === "experimental" ? { kind: "experimental" } : { kind: "on", level: "normal", byPreset: false };
 };

package/src/rule-load.ts

@@ -105,10 +105,11 @@ const numberFor = (raw: unknown, language: string): number | undefined => {
 
 const stringList = (value: unknown): string[] | undefined => (Array.isArray(value) ? value.map((entry) => String(entry)) : undefined);
 
-/** What only some rules declare: options beyond the level, and token features the adapter computes on request. */
-const extrasOf = (raw: Record<string, unknown>, file: string): Pick<RuleDefinition, "options" | "token_features"> => ({
+/** What only some rules declare: options beyond the level, token features the adapter computes on request, and opt_in. */
+const extrasOf = (raw: Record<string, unknown>, file: string): Pick<RuleDefinition, "options" | "token_features" | "opt_in"> => ({
   ...(raw["options"] === undefined ? {} : { options: optionsOf(raw["options"], file) }),
   ...(raw["token_features"] === undefined ? {} : { token_features: stringList(raw["token_features"]) ?? [] }),
+  ...(raw["opt_in"] === true ? { opt_in: true } : {}),
 });
 
 /** The table flattenLevels reads, before its severities become numbers. */

package/src/run.ts

@@ -47,14 +47,16 @@ export const levelFor = (rule: RuleDefinition, settings: Settings, experimental:
   // ジャンルの既定は chaff.yaml より弱く、status の既定より強い。--experimental でも、ジャンルが止めたものは止めたまま。
   const fromPreset = preset[rule.id];
   if (fromPreset !== undefined) return fromPreset;
+  if (rule.opt_in === true) return "off";
   if (rule.status === "experimental" && !experimental) return "off";
   return "normal";
 };
 
-/** Why a rule at off did not run: chaff.yaml turned it off, the genre's preset did, or it is experimental. */
+/** Why a rule at off did not run: chaff.yaml turned it off, the genre's preset did, it waits for a style, or it is experimental. */
 const offSkip = (rule: RuleDefinition, settings: Settings, preset: Settings, genre: string, reasons: Reasons): Skipped => {
   if (settings[rule.id] !== undefined) return { rule: rule.id, why: reasons.turnedOff };
   if (preset[rule.id] !== undefined) return { rule: rule.id, why: reasons.presetOff(genre) };
+  if (rule.opt_in === true) return { rule: rule.id, why: reasons.optIn };
   return { rule: rule.id, why: reasons.experimental, offUntilExperimental: true };
 };
 

package/src/spelling.ts

@@ -79,3 +79,11 @@ export const wordsToCheck = (text: string, minLength: number, maxLength: number)
     )
     .map((match) => ({ offset: match.index, word: match[0] }));
 };
+
+/** 頭の字を強調（**G**lobally）や角括弧（引用を変えた [e]xpressions）で分けた語の残りの、直前の形。 */
+const SPLIT_HEAD = /(?:\p{L}[*_~]+|\[\p{L}\])$/u;
+/** 直前を見る字の数。強調の印と頭の字が収まればよい。 */
+const SPLIT_LOOKBACK = 8;
+
+/** source（Markdown のままの文書）の offset から始まる語が、頭の字を分けた語の残りか。 */
+export const isSplitWord = (source: string, offset: number): boolean => SPLIT_HEAD.test(source.slice(Math.max(0, offset - SPLIT_LOOKBACK), offset));