chaffjs 0.17.0 → 0.18.0

package/src/rule-load.ts

@@ -2,7 +2,10 @@ import { readFileSync, readdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { parse } from "yaml";
-import type { LevelTable, RuleDefinition, Severity } from "./plugin.ts";
+import type { LanguageLevels, LevelSets, LevelTable, RuleDefinition, Severity } from "./plugin.ts";
+import { rankOfSeverity, severityAt } from "./levels.ts";
+import { optionsOf } from "./rule-options.ts";
+import { ruleGuideOf } from "./rule-guide.ts";
 
 const RULES_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "rules");
 
@@ -10,13 +13,8 @@ const isRecord = (value: unknown): value is Record<string, unknown> => typeof va
 
 const isLocalized = (value: unknown): value is Record<string, string> => isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
 
-const SEVERITY_BY_NAME: Readonly<Record<string, number>> = { info: 1, warning: 2, error: 3 };
-
-/** L4 は件数ではなく深刻度を段で持つ。error/warning/info を数に写して同じ器に入れる。 */
-const asNumber = (entry: unknown): number | undefined => {
-  if (typeof entry === "number") return entry;
-  return typeof entry === "string" ? SEVERITY_BY_NAME[entry] : undefined;
-};
+/** 数えるものの無い rule（L4、番号の抜け）は件数ではなく重さを段で持つ。error/warning/info を数に写して同じ器に入れる。 */
+const asNumber = (entry: unknown): number | undefined => (typeof entry === "number" ? entry : rankOfSeverity(entry));
 
 const isLevelTable = (value: unknown): value is LevelTable =>
   isRecord(value) && Object.entries(value).every(([key, entry]) => ["strict", "normal", "relaxed"].includes(key) && asNumber(entry) !== undefined);
@@ -41,6 +39,20 @@ const genreTables = (raw: unknown, language: string): Readonly<Record<string, Le
   return Object.fromEntries(entries);
 };
 
+/** levels を言語別に書いた rule の、loaded 以外の言語の段。言語で分けていない rule は空。 */
+const otherLanguages = (raw: Record<string, unknown>, loaded: string): Record<string, LanguageLevels> => {
+  const levels = raw["levels"];
+  if (!isRecord(levels) || isLevelTable(levels)) return {};
+  return Object.fromEntries(
+    Object.keys(levels)
+      .filter((language) => language !== loaded && language !== "default")
+      .flatMap((language) => {
+        const table = flattenLevels(levels, language);
+        return table === undefined ? [] : [[language, { levels: table, by_genre: genreTables(raw["by_genre"], language) }] as const];
+      }),
+  );
+};
+
 const SEVERITIES: readonly Severity[] = ["error", "warning", "info"];
 const isSeverity = (value: unknown): value is Severity => SEVERITIES.some((entry) => entry === value);
 
@@ -68,8 +80,8 @@ const missingFields = (raw: Record<string, unknown>, levels: LevelTable | undefi
 
 const localizedOf = (value: unknown): Record<string, string> => (isLocalized(value) ? value : {});
 
-/** 見つけ方ごとの message。読めないものは捨てる。 */
-const messagesOf = (value: unknown): Record<string, Record<string, string>> =>
+/** 見つけ方ごとの message、置き場所ごとの読みかた。読めないものは捨てる。 */
+const localizedByKey = (value: unknown): Record<string, Record<string, string>> =>
   isRecord(value) ? Object.fromEntries(Object.entries(value).flatMap(([variant, text]) => (isLocalized(text) ? [[variant, text]] : []))) : {};
 
 /**
@@ -92,38 +104,83 @@ 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"> => ({
+  ...(raw["options"] === undefined ? {} : { options: optionsOf(raw["options"], file) }),
+  ...(raw["token_features"] === undefined ? {} : { token_features: stringList(raw["token_features"]) ?? [] }),
+});
+
+/** The table flattenLevels reads, before its severities become numbers. */
+const writtenTable = (raw: unknown, language: string): unknown => {
+  if (isLevelTable(raw) || !isRecord(raw)) return raw;
+  return raw[language] ?? raw["default"];
+};
+
+/** Every level value written for a language: the rule's own table and each genre's. */
+const writtenValues = (raw: Record<string, unknown>, language: string): unknown[] => {
+  const genres = isRecord(raw["by_genre"]) ? Object.values(raw["by_genre"]) : [];
+  return [raw["levels"], ...genres].flatMap((written) => {
+    const table = writtenTable(written, language);
+    return isRecord(table) ? Object.values(table) : [];
+  });
+};
+
+/** Levels written as severities set the severity; a rule that mixes the two would say both. */
+const levelSetsOf = (raw: Record<string, unknown>, language: string, file: string): LevelSets => {
+  const values = writtenValues(raw, language);
+  const severities = values.filter((value) => typeof value === "string").length;
+  if (severities === 0) return "limit";
+  if (severities < values.length) throw new Error(`${file}: levels と by_genre に重さ（error / warning / info）と数を混ぜて書けません`);
+  // A genre's table would give the rule a default severity other than its severity field.
+  if (isRecord(raw["by_genre"])) throw new Error(`${file}: 重さを段に持つ rule は by_genre を持てません`);
+  return "severity";
+};
+
+/** severity は normal の段の重さそのもの。食い違うと、段を書かないときと normal と書いたときで重さが変わる。 */
+const checkedSeverity = (rule: RuleDefinition, file: string): RuleDefinition => {
+  if (rule.level_sets === "limit" || severityAt(rule, "normal") === rule.severity) return rule;
+  throw new Error(`${file}: severity ${rule.severity} が levels の normal（${severityAt(rule, "normal")}）と違います`);
+};
+
 const toRule = (raw: unknown, language: string, file: string): RuleDefinition => {
   if (!isRecord(raw)) throw new Error(`${file}: rule は object であること`);
   const levels = flattenLevels(raw["levels"], language);
   const missing = missingFields(raw, levels);
   if (missing.length > 0) throw new Error(`${file}: 必須フィールドがありません: ${missing.join(", ")}`);
   if (levels === undefined) throw new Error(`${file}: levels を解決できません`);
-  return {
-    id: String(raw["id"]),
-    layer: pick(raw["layer"], LAYERS) ?? "L1",
-    status: pick(raw["status"], STATUSES) ?? "experimental",
-    name: localizedOf(raw["name"]),
-    why: localizedOf(raw["why"]),
-    how_to_fix: localizedOf(raw["how_to_fix"]),
-    message: localizedOf(raw["message"]),
-    messages: messagesOf(raw["messages"]),
-    levels,
-    by_genre: genreTables(raw["by_genre"], language),
-    how_to_find: String(raw["how_to_find"]),
-    word_list: typeof raw["word_list"] === "string" ? raw["word_list"] : undefined,
-    extra_word_lists: stringList(raw["extra_word_lists"]) ?? [],
-    what_to_check: isLocalized(raw["what_to_check"]) ? raw["what_to_check"] : undefined,
-    where: typeof raw["where"] === "string" ? raw["where"] : undefined,
-    full_sentence: numberFor(raw["full_sentence"], language),
-    requires: stringList(raw["requires"]) ?? [],
-    uses: stringList(raw["uses"]) ?? [],
-    from: stringList(raw["from"]) ?? [],
-    languages: stringList(raw["languages"]),
-    use_for: Array.isArray(raw["use_for"]) ? raw["use_for"].map((entry) => String(entry)) : [],
-    severity: severityOf(raw["severity"], language),
-  };
+  return checkedSeverity(ruleOf(raw, levels, levelSetsOf(raw, language, file), language, file), file);
 };
 
+const ruleOf = (raw: Record<string, unknown>, levels: LevelTable, levelSets: LevelSets, language: string, file: string): RuleDefinition => ({
+  id: String(raw["id"]),
+  layer: pick(raw["layer"], LAYERS) ?? "L1",
+  status: pick(raw["status"], STATUSES) ?? "experimental",
+  name: localizedOf(raw["name"]),
+  why: localizedOf(raw["why"]),
+  how_to_fix: localizedOf(raw["how_to_fix"]),
+  message: localizedOf(raw["message"]),
+  messages: localizedByKey(raw["messages"]),
+  placeholders: localizedByKey(raw["placeholders"]),
+  levels,
+  level_sets: levelSets,
+  by_genre: genreTables(raw["by_genre"], language),
+  other_languages: otherLanguages(raw, language),
+  how_to_find: String(raw["how_to_find"]),
+  word_list: typeof raw["word_list"] === "string" ? raw["word_list"] : undefined,
+  extra_word_lists: stringList(raw["extra_word_lists"]) ?? [],
+  what_to_check: isLocalized(raw["what_to_check"]) ? raw["what_to_check"] : undefined,
+  where: typeof raw["where"] === "string" ? raw["where"] : undefined,
+  full_sentence: numberFor(raw["full_sentence"], language),
+  requires: stringList(raw["requires"]) ?? [],
+  uses: stringList(raw["uses"]) ?? [],
+  from: stringList(raw["from"]) ?? [],
+  languages: stringList(raw["languages"]),
+  use_for: Array.isArray(raw["use_for"]) ? raw["use_for"].map((entry) => String(entry)) : [],
+  severity: severityOf(raw["severity"], language),
+  ...extrasOf(raw, file),
+  guide: ruleGuideOf(raw),
+});
+
 /**
  * 読めない rule ファイルは、どれが何で読めないかを言う。
  * yaml の例外をそのまま投げると、スタックトレースだけが出てファイル名が出ない。

package/src/rule-options.ts

@@ -0,0 +1,131 @@
+import type { Localized, OptionValue, RuleOption } from "./plugin.ts";
+
+// A rule's options: what its YAML declares, whether a written value fits, and which setting decides each one.
+// Pure: no file is read here. The settings come in as layers, strongest first (chaff.yaml, then a style, then the default).
+
+const KINDS: readonly RuleOption["kind"][] = ["choice", "count", "words"];
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isLocalized = (value: unknown): value is Localized =>
+  isRecord(value) && Object.keys(value).length > 0 && Object.values(value).every((entry) => typeof entry === "string" && entry !== "");
+
+const isCount = (value: unknown): value is number => typeof value === "number" && Number.isInteger(value) && value >= 1;
+
+const isWords = (value: unknown): value is string[] => Array.isArray(value) && value.every((entry) => typeof entry === "string" && entry.trim() !== "");
+
+/** Whether value fits the option: one of the choices, a whole number of 1 or more, or a list of words. */
+export const fitsOption = (option: RuleOption, value: unknown): value is OptionValue => {
+  if (option.kind === "count") return isCount(value);
+  if (option.kind === "words") return isWords(value);
+  return typeof value === "string" && option.choices.includes(value);
+};
+
+/** What a value must look like, for a problem message: the choices, or the kind. */
+export const expectedOf = (option: RuleOption): string => (option.kind === "choice" ? option.choices.join(" / ") : option.kind);
+
+const kindOf = (raw: Record<string, unknown>, where: string): RuleOption["kind"] => {
+  const kind = KINDS.find((entry) => entry === raw["kind"]);
+  if (kind === undefined) throw new Error(`${where}: kind must be one of ${KINDS.join(", ")}`);
+  return kind;
+};
+
+const choicesOf = (raw: Record<string, unknown>, kind: RuleOption["kind"], where: string): string[] => {
+  if (kind !== "choice") return [];
+  const choices = raw["choices"];
+  if (!isRecord(choices) || Object.keys(choices).length < 2) throw new Error(`${where}: a choice needs two or more choices, each with its meaning`);
+  return Object.keys(choices);
+};
+
+const choiceNamesOf = (raw: Record<string, unknown>, where: string): Record<string, Localized> => {
+  const choices = raw["choices"];
+  if (!isRecord(choices)) return {};
+  return Object.fromEntries(
+    Object.entries(choices).map(([choice, meaning]) => {
+      if (!isLocalized(meaning)) throw new Error(`${where}: choice ${choice} needs its meaning in ja and/or en`);
+      return [choice, meaning];
+    }),
+  );
+};
+
+const optionOf = (name: string, raw: unknown, file: string): RuleOption => {
+  const where = `${file}: options.${name}`;
+  if (!isRecord(raw)) throw new Error(`${where} must be a map`);
+  const kind = kindOf(raw, where);
+  const about = raw["about"];
+  if (!isLocalized(about)) throw new Error(`${where}: about needs what the option decides, in ja and/or en`);
+  const option: RuleOption = {
+    kind,
+    choices: choicesOf(raw, kind, where),
+    default: kind === "words" ? [] : 0,
+    about,
+    choiceNames: kind === "choice" ? choiceNamesOf(raw, where) : {},
+  };
+  const fallback: unknown = raw["default"] ?? (kind === "words" ? [] : undefined);
+  if (!fitsOption(option, fallback)) throw new Error(`${where}: default must be ${expectedOf(option)}`);
+  return { ...option, default: fallback };
+};
+
+/** The options a rule's YAML declares. A wrong declaration is chaff's own bug, so it throws with the file and the option. */
+export const optionsOf = (raw: unknown, file: string): Record<string, RuleOption> => {
+  if (raw === undefined) return {};
+  if (!isRecord(raw)) throw new Error(`${file}: options must be a map of option names`);
+  return Object.fromEntries(Object.entries(raw).map(([name, option]) => [name, optionOf(name, option, file)]));
+};
+
+/** One place settings come from, and what it sets: { rule id: { option: value } }. */
+export type OptionLayer = { readonly from: string; readonly values: Readonly<Record<string, unknown>> };
+
+export type SettledOption = { readonly value: OptionValue; readonly from: string };
+
+/** The source name of an option left at its default. */
+export const DEFAULT_SOURCE = "default";
+
+const optionMap = (layer: OptionLayer, ruleId: string): Readonly<Record<string, unknown>> => {
+  const values = layer.values[ruleId];
+  return isRecord(values) ? values : {};
+};
+
+/**
+ * Each option of a rule at the value of the strongest layer that sets it with a value that fits, and where that came from.
+ * A value that does not fit falls through to the next layer; optionProblems says so, so it is never silent.
+ */
+export const settleOptions = (ruleId: string, options: Readonly<Record<string, RuleOption>>, layers: readonly OptionLayer[]): Record<string, SettledOption> =>
+  Object.fromEntries(
+    Object.entries(options).map(([name, option]) => {
+      const fitting = layers.flatMap((layer): SettledOption[] => {
+        const value = optionMap(layer, ruleId)[name];
+        return fitsOption(option, value) ? [{ value, from: layer.from }] : [];
+      });
+      return [name, fitting[0] ?? { value: option.default, from: DEFAULT_SOURCE }];
+    }),
+  );
+
+/** The values alone, as the detector gets them. */
+export const optionValues = (settled: Readonly<Record<string, SettledOption>>): Record<string, OptionValue> =>
+  Object.fromEntries(Object.entries(settled).map(([name, entry]) => [name, entry.value]));
+
+/** What a layer sets that has no effect: an unknown rule, a rule with no options, an unknown option, or a value that does not fit. */
+export type OptionProblem =
+  | { readonly kind: "unknown-rule"; readonly rule: string }
+  | { readonly kind: "no-options"; readonly rule: string }
+  | { readonly kind: "not-a-map"; readonly rule: string }
+  | { readonly kind: "unknown-option"; readonly rule: string; readonly option: string; readonly known: readonly string[] }
+  | { readonly kind: "bad-value"; readonly rule: string; readonly option: string; readonly value: string; readonly expected: string };
+
+const printed = (value: unknown): string => JSON.stringify(value) ?? String(value);
+
+const problemsOfRule = (ruleId: string, options: Readonly<Record<string, RuleOption>> | undefined, written: unknown): OptionProblem[] => {
+  if (options === undefined) return [{ kind: "unknown-rule", rule: ruleId }];
+  if (Object.keys(options).length === 0) return [{ kind: "no-options", rule: ruleId }];
+  if (!isRecord(written)) return [{ kind: "not-a-map", rule: ruleId }];
+  return Object.entries(written).flatMap(([name, value]): OptionProblem[] => {
+    const option = options[name];
+    if (option === undefined) return [{ kind: "unknown-option", rule: ruleId, option: name, known: Object.keys(options) }];
+    return fitsOption(option, value) ? [] : [{ kind: "bad-value", rule: ruleId, option: name, value: printed(value), expected: expectedOf(option) }];
+  });
+};
+
+/** Every problem in what a layer sets, given each known rule's options (a rule with none maps to {}). */
+export const optionProblems = (layer: OptionLayer, known: Readonly<Record<string, Readonly<Record<string, RuleOption>>>>): OptionProblem[] =>
+  Object.entries(layer.values).flatMap(([ruleId, written]) => problemsOfRule(ruleId, known[ruleId], written));

package/src/run.ts

@@ -1,6 +1,6 @@
 import { DETECTORS } from "./detectors/index.ts";
-import { resolve } from "./levels.ts";
-import type { AdapterNeeds, Finding, Level, ProseDocument, RuleDefinition } from "./plugin.ts";
+import { resolve, severityAt } from "./levels.ts";
+import type { AdapterNeeds, Detector, DetectorOptions, Finding, Level, ProseDocument, RuleDefinition } from "./plugin.ts";
 import { lineStarts, placeOf } from "./position.ts";
 import { REASONS, type Reasons } from "./reasons.ts";
 import { joinWords } from "./detectors/word-list.ts";
@@ -11,6 +11,9 @@ import { maskSpans } from "./mask.ts";
 import { textOutline } from "./page-furniture.ts";
 import { uiLanguageOf } from "./ui.ts";
 import { presetLevels } from "./genre-load.ts";
+import { bodySectionOf } from "./body-section.ts";
+import { optionValues, settleOptions, type OptionLayer } from "./rule-options.ts";
+import { PatternTimeout } from "./custom/bounded-match.ts";
 
 export type Skipped = { readonly rule: string; readonly why: string };
 
@@ -68,7 +71,7 @@ const treeProblem = (doc: ProseDocument): string | undefined => {
 
 /** 木が読んだのと同じ本文。Markdown はコードを覆ったもの、.txt はページの飾りだけを覆ったもの（.txt の字下げはコードではない）。 */
 const textTheTreeRead = (doc: ProseDocument): string =>
-  isMarkdownPath(doc.path) ? (doc.prose ?? doc.source) : maskSpans(doc.source, textOutline(doc.source).opaque);
+  isMarkdownPath(doc.path) ? (doc.prose ?? doc.source) : maskSpans(doc.source, textOutline(doc.source, doc.replyQuotes).opaque);
 
 const unreadByDocument = new WeakMap<ProseDocument, Unread | undefined>();
 
@@ -78,6 +81,15 @@ const unreadOf = (doc: ProseDocument): Unread | undefined => {
   return unreadByDocument.get(doc);
 };
 
+/** 見出しを読む rule の要求。表題より下の見出しが無い文書では、本題の前を測れない。0 件を「前置きが短い」に見せない。 */
+/** 記法を読む rule の要求（markdown）。.txt には見出しの記法も画像もリンクの記法も無いので、0 件を「問題なし」に見せない。 */
+const DOCUMENT_NEEDS: ReadonlySet<string> = new Set(["headings", "markdown"]);
+
+const documentNeed = (rule: RuleDefinition, doc: ProseDocument): string | undefined => {
+  if (rule.requires.includes("markdown") && !isMarkdownPath(doc.path)) return reasonsFor(doc).notMarkdown;
+  return rule.requires.includes("headings") && bodySectionOf(doc.sections) === undefined ? reasonsFor(doc).noHeadings : undefined;
+};
+
 /** 知らない要求は満たされていないものとして扱う。黙って無視すると、要求なしで動いてしまう。 */
 const has = (capabilities: ProseDocument["capabilities"], need: string): boolean => {
   if (need === "pos") return capabilities.pos;
@@ -97,7 +109,7 @@ const hasTokens = (doc: ProseDocument): boolean => doc.sentences.length === 0 ||
 /** 要求を満たさない rule は動かせない。満たさないまま動かすと「指摘 0 件」が保証に見える。 */
 const unmet = (rule: RuleDefinition, doc: ProseDocument): string | undefined => {
   if (rule.languages !== undefined && !rule.languages.includes(doc.language)) return reasonsFor(doc).otherLanguage(doc.language);
-  const missing = rule.requires.filter((need) => !TREE_NEEDS.has(need)).find((need) => !has(doc.capabilities, need));
+  const missing = rule.requires.filter((need) => !TREE_NEEDS.has(need) && !DOCUMENT_NEEDS.has(need)).find((need) => !has(doc.capabilities, need));
   if (missing !== undefined) return reasonsFor(doc).noCapability(missing);
   return undefined;
 };
@@ -119,12 +131,29 @@ export const wantsTags = (rule: RuleDefinition): boolean => [...rule.requires, .
  * 解析器の初期化に払う代金を決める。動く rule が 1 本も要求しないなら読み込まない。
  * capabilities は「払えばできる」の宣言なので、ここでは見ない。
  */
-export const neededBy = (rules: readonly RuleDefinition[], settings: Settings, experimental: boolean, genre: string, language: string): AdapterNeeds => ({
-  pos: forGenre(rules, genre)
+export const neededBy = (rules: readonly RuleDefinition[], settings: Settings, experimental: boolean, genre: string, language: string): AdapterNeeds => {
+  const running = forGenre(rules, genre)
     .filter((rule) => rule.layer !== "L4" && levelFor(rule, settings, experimental, presetLevels(genre)) !== "off")
-    .filter((rule) => rule.languages === undefined || rule.languages.includes(language))
-    .some(wantsTags),
-});
+    .filter((rule) => rule.languages === undefined || rule.languages.includes(language));
+  return { pos: running.some(wantsTags), features: tokenFeaturesOf(running) };
+};
+
+/** The token features the rules read (RuleDefinition.token_features), each once. */
+export const tokenFeaturesOf = (rules: readonly RuleDefinition[]): string[] => [...new Set(rules.flatMap((rule) => rule.token_features ?? []))];
+
+/** A detector's findings, or how long it ran before a team's pattern was stopped (bounded-match.ts). Other errors are chaff's bugs and propagate. */
+const runDetector = (
+  detector: Detector,
+  doc: ProseDocument,
+  options: DetectorOptions,
+): { readonly findings: readonly Finding[] } | { readonly timedOut: number } => {
+  try {
+    return { findings: detector(doc, options) };
+  } catch (error) {
+    if (error instanceof PatternTimeout) return { timedOut: error.budget_ms };
+    throw error;
+  }
+};
 
 const place = (starts: readonly number[], finding: Finding): Finding => {
   const offset = finding.values["offset"];
@@ -160,6 +189,29 @@ 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;
 
+/** 文書と違う言語で書いた文の上限。chaff.yaml の数値は文書の言語の単位で書いたものなので、ここには効かせない。 */
+const embeddedLimitsFor = (rule: RuleDefinition, level: Level, genre: string, embedded: readonly string[]): Record<string, number> =>
+  Object.fromEntries(
+    embedded.flatMap((language) => {
+      const tables = rule.other_languages?.[language];
+      return tables === undefined ? [] : [[language, resolve({ ...rule, ...tables }, level, genre).limit] as const];
+    }),
+  );
+
+const embeddedLanguagesOf = (doc: ProseDocument): string[] => [
+  ...new Set(doc.sentences.flatMap((sentence) => (sentence.embeddedLanguage === undefined ? [] : [sentence.embeddedLanguage.id]))),
+];
+
+/** What a run is set to: the levels chaff.yaml names, whether experimental rules run, the genre, and the numbers and options set. */
+export type RunContext = {
+  readonly settings: Settings;
+  readonly experimental: boolean;
+  readonly genre: string;
+  readonly limits?: Limits;
+  /** Where rule options come from, strongest first (chaff.yaml). An option no layer sets is at its default. */
+  readonly optionLayers?: readonly OptionLayer[];
+};
+
 export const runRules = (
   doc: ProseDocument,
   rules: readonly RuleDefinition[],
@@ -167,10 +219,14 @@ export const runRules = (
   experimental: boolean,
   genre: string,
   limits: Limits = {},
-): RunResult => {
+): RunResult => runRulesWith(doc, rules, { settings, experimental, genre, limits });
+
+export const runRulesWith = (doc: ProseDocument, rules: readonly RuleDefinition[], context: RunContext): RunResult => {
+  const { settings, experimental, genre, limits = {}, optionLayers = [] } = context;
   const preset = presetLevels(genre);
   const starts = lineStarts(doc.source);
   const applicable = forGenre(rules, genre);
+  const embedded = embeddedLanguagesOf(doc);
   const experimentalOn = applicable.filter((rule) => rule.status === "experimental" && levelFor(rule, settings, experimental, preset) !== "off");
   const forced = experimentalOn.filter((rule) => settings[rule.id] !== undefined).map((rule) => rule.id);
   const presetOn = experimentalOn.filter((rule) => settings[rule.id] === undefined && preset[rule.id] !== undefined).map((rule) => rule.id);
@@ -191,6 +247,8 @@ export const runRules = (
       // 段階を見た後で聞く。doc.structure は触れたときに木を作るので、止めている rule のために作らない。
       const noTree = treeNeed(rule, doc);
       if (noTree !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: noTree }] };
+      const noDocumentNeed = documentNeed(rule, doc);
+      if (noDocumentNeed !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: noDocumentNeed }] };
       // 複合シグナルは二段目で扱う。一段目では「検出器が無い」と言わせない。
       if (rule.from.length > 0) return acc;
       const detector = DETECTORS[rule.how_to_find];
@@ -205,8 +263,13 @@ export const runRules = (
         lexicon: rule.word_list === undefined ? undefined : doc.lexicons[rule.word_list],
         where: rule.where,
         fullSentence: rule.full_sentence,
+        embeddedLimits: embeddedLimitsFor(rule, level, genre, embedded),
+        ...(rule.options === undefined ? {} : { settings: optionValues(settleOptions(rule.id, rule.options, optionLayers)) }),
+        ...(rule.custom === undefined ? {} : { custom: rule.custom }),
       };
-      const found = detector(doc, options).map((finding) => place(starts, { ...finding, rule: rule.id, severity: rule.severity }));
+      const ran = runDetector(detector, doc, options);
+      if ("timedOut" in ran) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: reasonsFor(doc).patternTimeout(ran.timedOut) }] };
+      const found = ran.findings.map((finding) => place(starts, { ...finding, rule: rule.id, severity: severityAt(rule, level, genre) }));
       return { findings: [...acc.findings, ...found], skipped: acc.skipped };
     },
     { findings: [], skipped: [] },

package/src/sentence-shape.ts

@@ -1,4 +1,5 @@
 import type { Sentence, Token } from "./plugin.ts";
+import { ownEnd } from "./trailing-aside.ts";
 
 /**
  * 「これは文か」の判定を 1 箇所に置く。
@@ -21,13 +22,11 @@ const SKIP = new Set(["PUNCT", "PART", "SYM"]);
  * 「これを最優先制約とする（§17）。」の述語は「とする」であって「17」ではない。
  * 仕様書は相互参照を括弧で添えるので、これを数えると文末が全部そこになる。
  */
-const TRAILING = /[(（][^(（]*[)）][\s。．！？!?]*$/u;
-
 const beforeTrailing = (sentence: Sentence): readonly Token[] => {
   const tokens = sentence.tokens ?? [];
-  const match = TRAILING.exec(sentence.text);
-  if (match?.index === undefined) return tokens;
-  const cut = sentence.span.start + match.index;
+  const end = ownEnd(sentence.text);
+  if (end === sentence.text.length) return tokens;
+  const cut = sentence.span.start + end;
   const kept = tokens.filter((token) => token.span.end <= cut);
   // 括弧を外したら何も残らない文は、括弧そのものが中身。そのまま見る。
   return kept.length === 0 ? tokens : kept;

package/src/setting-problems.ts

@@ -1,5 +1,9 @@
 import type { Config } from "./config/load.ts";
 import type { CliText } from "./cli-text.ts";
+import type { UiLanguage } from "./ui.ts";
+import { styleProblems } from "./config/style.ts";
+import { loadStyles } from "./style-load.ts";
+import { customRuleProblems } from "./custom/problems.ts";
 import { GENRES } from "./genre.ts";
 import { unknownGenres, writtenGenres } from "./genre-check.ts";
 import { loadProfiles } from "./profile/load.ts";
@@ -18,7 +22,9 @@ const profileProblems = (command: string, config: Config, text: CliText): string
 };
 
 /** Settings that name something chaff does not have. Each would silently check less than was asked, so the run stops on them. */
-export const settingProblems = (command: string, genreFlag: string | undefined, config: Config, text: CliText): string[] => [
+export const settingProblems = (command: string, genreFlag: string | undefined, config: Config, text: CliText, ui: UiLanguage = "en"): string[] => [
   ...genreProblems(command, genreFlag, config, text),
   ...profileProblems(command, config, text),
+  ...styleProblems(config, loadStyles(), ui),
+  ...customRuleProblems(config, ui),
 ];

package/src/span-cut.ts

@@ -0,0 +1,28 @@
+import type { Span } from "./plugin.ts";
+import { mergeSpans } from "./span-merge.ts";
+import { firstEndingAfter } from "./soft-break.ts";
+
+const piecesOutside = (span: Span, sortedCuts: readonly Span[]): Span[] => {
+  const overlapping = sortedCuts
+    .slice(firstEndingAfter(sortedCuts, span.start), firstEndingAfter(sortedCuts, span.end) + 1)
+    .filter((cut) => cut.start < span.end);
+  const { pieces, cursor } = overlapping.reduce<{ pieces: Span[]; cursor: number }>(
+    (acc, cut) => ({
+      pieces: cut.start > acc.cursor ? [...acc.pieces, { start: acc.cursor, end: cut.start }] : acc.pieces,
+      cursor: Math.max(acc.cursor, cut.end),
+    }),
+    { pieces: [], cursor: span.start },
+  );
+  return cursor < span.end ? [...pieces, { start: cursor, end: span.end }] : pieces;
+};
+
+/** The parts of each span that no cut covers, in order. Cuts may overlap one another and come in any order. */
+export const cutSpans = (spans: readonly Span[], cuts: readonly Span[]): Span[] => {
+  if (cuts.length === 0) return [...spans];
+  const sortedCuts = mergeSpans(cuts, true);
+  return spans.flatMap((span) => piecesOutside(span, sortedCuts));
+};
+
+/** cutSpans, less the pieces of `source` that hold only white space. */
+export const cutTextSpans = (spans: readonly Span[], cuts: readonly Span[], source: string): Span[] =>
+  cuts.length === 0 ? [...spans] : cutSpans(spans, cuts).filter((piece) => source.slice(piece.start, piece.end).trim() !== "");

package/src/structure/aside-depth.ts

@@ -0,0 +1,67 @@
+import type { RelativeVocabulary } from "../plugin.ts";
+
+type Aside = RelativeVocabulary["aside"];
+
+/** 文字と、その位置（UTF-16 の単位で）。絵文字のような 2 単位の文字も 1 文字として読む。 */
+export const characters = (text: string): { readonly char: string; readonly at: number }[] => {
+  const found: { char: string; at: number }[] = [];
+  let at = 0;
+  for (const char of text) {
+    found.push({ char, at });
+    at += char.length;
+  }
+  return found;
+};
+
+/** at の位置で開いたままの括弧書きの開きの位置。text の頭から at まで読む。 */
+export const openAsidesAt = (text: string, at: number, aside: Aside): number[] => {
+  const opens: number[] = [];
+  if (aside === undefined) return opens;
+  characters(text.slice(0, at)).forEach(({ char, at: position }) => {
+    if (char === aside.open) opens.push(position);
+    if (char === aside.close) opens.pop();
+  });
+  return opens;
+};
+
+/** at で開いたままの括弧書きの数（depth）と、一番内側の開きの位置（innermost）。 */
+export type AsideDepth = { readonly depth: (at: number) => number; readonly innermost: (at: number) => number | undefined };
+
+/** 文字の切れ目でない位置（2 単位の文字の途中）の印。 */
+const UNREAD = -2;
+const NO_OPEN = -1;
+
+/**
+ * 本文を一度だけ読み、文字の切れ目ごとに openAsidesAt の答えを覚える。参照ごとに頭から読み直すと、参照の数と行の長さの積になる。
+ * 覚えていない位置（2 単位の文字の途中）は openAsidesAt で読む。
+ */
+export const asideDepth = (text: string, aside: Aside): AsideDepth => {
+  if (aside === undefined) return { depth: () => 0, innermost: () => undefined };
+  const depths = new Int32Array(text.length + 1).fill(UNREAD);
+  const innermosts = new Int32Array(text.length + 1).fill(UNREAD);
+  const opens: number[] = [];
+  depths[0] = 0;
+  innermosts[0] = NO_OPEN;
+  characters(text).forEach(({ char, at }) => {
+    if (char === aside.open) opens.push(at);
+    if (char === aside.close) opens.pop();
+    depths[at + char.length] = opens.length;
+    innermosts[at + char.length] = opens.at(-1) ?? NO_OPEN;
+  });
+  // text.slice(0, at) が切る位置。負の数は後ろから数え、本文の外は端に寄せる。文字の途中なら覚えていない。
+  const cut = (at: number): number => {
+    const whole = Math.trunc(Number.isNaN(at) ? 0 : at);
+    return whole < 0 ? Math.max(text.length + whole, 0) : Math.min(whole, text.length);
+  };
+  return {
+    depth: (at) => {
+      const depth = depths[cut(at)] ?? UNREAD;
+      return depth === UNREAD ? openAsidesAt(text, at, aside).length : depth;
+    },
+    innermost: (at) => {
+      const open = innermosts[cut(at)] ?? UNREAD;
+      if (open === UNREAD) return openAsidesAt(text, at, aside).at(-1);
+      return open === NO_OPEN ? undefined : open;
+    },
+  };
+};