chaffjs 0.18.0 → 0.19.0

package/src/render/compact.ts

@@ -1,4 +1,4 @@
-import type { RuleDefinition } from "../plugin.ts";
+import type { Finding, RuleDefinition } from "../plugin.ts";
 import type { RunResult } from "../run.ts";
 import { messageOf } from "./text.ts";
 import { counted } from "./plural.ts";
@@ -12,14 +12,24 @@ const TALLY: Texts<{ readonly findings: (n: number) => string; readonly notRun:
   en: { findings: (n) => counted(n, "finding"), notRun: (n) => `${counted(n, "rule")} not run`, separator: ", " },
 };
 
+const POSITION_MIN_WIDTH = 8;
+const SEVERITY_WIDTH = 8;
+
+const positionOf = (finding: Finding): string => `${String(finding.line)}:${String(finding.column)}`;
+
+/** 「行:桁」の列の幅。一番長い位置の後ろにも空白を 1 つ残す。grep や awk が重さの語と区切れるように。 */
+export const positionWidthOf = (findings: readonly Finding[]): number =>
+  findings.reduce((width, finding) => Math.max(width, positionOf(finding).length + 1), POSITION_MIN_WIDTH);
+
 /** エンジニア向け。1 件 2 行。 */
 export const renderCompact = (header: string, result: RunResult, rules: readonly RuleDefinition[], language: string): string => {
   const byId = new Map(rules.map((rule) => [rule.id, rule]));
+  const width = positionWidthOf(result.findings);
   const lines = result.findings.flatMap((finding) => {
     const rule = byId.get(finding.rule);
     if (rule === undefined) return [];
-    const at = `${finding.line}:${finding.column}`.padEnd(8);
-    return [`  ${at}${finding.severity.padEnd(8)}${messageOf(rule, finding, language)}`, `          ${" ".repeat(8)}${finding.rule}`];
+    const message = `  ${positionOf(finding).padEnd(width)}${finding.severity.padEnd(SEVERITY_WIDTH)}${messageOf(rule, finding, language)}`;
+    return [message, `  ${" ".repeat(width + SEVERITY_WIDTH)}${finding.rule}`];
   });
   const text = TALLY[uiLanguageOf(language)];
   const tail = [text.findings(result.findings.length), result.skipped.length > 0 ? text.notRun(result.skipped.length) : undefined].filter(

package/src/render/explain.ts

@@ -1,7 +1,7 @@
 import { definedLevels, resolve, severityAt } from "../levels.ts";
-import { readableText } from "./text.ts";
+import { fill, localized, readableText } from "./text.ts";
 import { SEVERITY_NAME } from "./severity-name.ts";
-import { uiLanguageOf, type Texts, type UiLanguage } from "../ui.ts";
+import { uiLanguageOf, type Texts } from "../ui.ts";
 import type { Level, RuleDefinition } from "../plugin.ts";
 import { optionLines } from "./options.ts";
 import type { OptionLayer } from "../rule-options.ts";
@@ -13,10 +13,12 @@ const TEXT: Texts<{
   readonly experimental: string;
   readonly howToFix: string;
   readonly example: string;
-  readonly definedIn: string;
-  readonly values: (unit: string) => string;
+  readonly definedIn: (plugin: string | undefined) => string;
+  readonly values: string;
+  readonly times: string;
   readonly severities: string;
   readonly now: (level: string) => string;
+  readonly nowNumber: (limit: string) => string;
   readonly from: (source: string) => string;
   readonly change: (id: string) => string;
 }> = {
@@ -27,10 +29,13 @@ const TEXT: Texts<{
     experimental: "このルールはまだ試験中で、既定では動きません（--experimental で動きます）。",
     howToFix: "直しかた",
     example: "例",
-    definedIn: "このルールはチームが chaff.yaml の custom_rules で決めたものです。",
-    values: (unit) => `設定できる値（単位: ${unit}）:`,
+    definedIn: (plugin) =>
+      plugin === undefined ? "このルールはチームが chaff.yaml の custom_rules で決めたものです。" : `このルールはプラグイン ${plugin} のものです。`,
+    values: "設定できる値:",
+    times: "回",
     severities: "設定できる値（数える上限は無く、指摘の重さが変わります）:",
     now: (level) => `いまは ${level} です。`,
+    nowNumber: (limit) => `いまは段階ではなく数です: ${limit}。`,
     from: (source) => `（${source} で決めています）`,
     change: (id) => `変える:  npx chaff relax ${id} --why "理由"`,
   },
@@ -41,23 +46,38 @@ const TEXT: Texts<{
     experimental: "This rule is still experimental and does not run by default (--experimental runs it).",
     howToFix: "How to fix",
     example: "Example",
-    definedIn: "The team defined this rule under custom_rules in chaff.yaml.",
-    values: (unit) => `Levels (unit: ${unit}):`,
+    definedIn: (plugin) =>
+      plugin === undefined ? "The team defined this rule under custom_rules in chaff.yaml." : `This rule comes from the plugin ${plugin}.`,
+    values: "Levels:",
+    times: "times",
     severities: "Levels (there is no limit to count to; a level sets how a finding is marked):",
     now: (level) => `Now: ${level}.`,
+    nowNumber: (limit) => `Now: ${limit}, set as a number rather than a level.`,
     from: (source) => ` (set by ${source})`,
     change: (id) => `Change it:  npx chaff relax ${id} --why "reason"`,
   },
 };
 
+/**
+ * A limit in the rule's words for what it counts ("up to 8 emoji per 1000 words"), as the rule reference shows it.
+ * A rule that says nothing (a team's custom rule) counts matches, so its limit is a number of times.
+ */
+const limitText = (rule: RuleDefinition, limit: number, language: string): string => {
+  const meaning = localized(rule.guide?.levelMeaning ?? {}, language);
+  return meaning === "" ? `${String(limit)} ${TEXT[uiLanguageOf(language)].times}` : fill(meaning, { limit });
+};
+
 /** What a level holds: the limit a detector counts to, or the severity a rule with nothing to count gives. */
-const valueAt = (rule: RuleDefinition, level: Exclude<Level, "off">, genre: string | undefined, ui: UiLanguage): string =>
-  rule.level_sets === "severity" ? SEVERITY_NAME[ui][severityAt(rule, level, genre)] : String(resolve(rule, level, genre).limit);
+const valueAt = (rule: RuleDefinition, level: Exclude<Level, "off">, genre: string | undefined, language: string): string =>
+  rule.level_sets === "severity"
+    ? SEVERITY_NAME[uiLanguageOf(language)][severityAt(rule, level, genre)]
+    : limitText(rule, resolve(rule, level, genre).limit, language);
 
-const levelLine = (rule: RuleDefinition, level: Level, current: Level, genre: string | undefined, ui: UiLanguage): string => {
+/** current is undefined when a number, not a level, sets the limit: no level is marked. */
+const levelLine = (rule: RuleDefinition, level: Level, current: Level | undefined, genre: string | undefined, language: string): string => {
   const mark = level === current ? "→" : " ";
   const name = level.padEnd(9);
-  return level === "off" ? `  ${mark} ${name}${TEXT[ui].off}` : `  ${mark} ${name}${valueAt(rule, level, genre, ui)}`;
+  return level === "off" ? `  ${mark} ${name}${TEXT[uiLanguageOf(language)].off}` : `  ${mark} ${name}${valueAt(rule, level, genre, language)}`;
 };
 
 /** ジャンルで数字が変わる rule は、それを言わないと「設定したのに効かない」に見える。 */
@@ -72,17 +92,24 @@ const exampleLines = (rule: RuleDefinition, language: string, text: (typeof TEXT
   const examples = rule.guide?.examples ?? {};
   const example = examples[language] ?? examples["en"] ?? Object.values(examples)[0];
   if (rule.custom === undefined || example === undefined) return [];
-  return ["", `  ${text.example}:  ${example.before}`, `      →  ${example.after}`, "", `  ${text.definedIn}`];
+  return ["", `  ${text.example}:  ${example.before}`, `      →  ${example.after}`, "", `  ${text.definedIn(rule.plugin)}`];
 };
 
 /** Where the rule's settings come from: the option layers, strongest first, and the source of its level when a style set it. */
-export type ExplainSettings = { readonly optionLayers?: readonly OptionLayer[]; readonly levelFrom?: string | undefined };
+/** limit: a number chaff.yaml or its style set for the rule (rules: { id: 80 }, a style's limits), which a level does not show. */
+export type ExplainSettings = {
+  readonly optionLayers?: readonly OptionLayer[];
+  readonly levelFrom?: string | undefined;
+  readonly limit?: number | undefined;
+};
 
 /** rule の意図と根拠を読む。指摘に納得できないときの入口。 */
-export const renderExplain = (rule: RuleDefinition, current: Level, language: string, unit: string, genre?: string, settings: ExplainSettings = {}): string => {
+export const renderExplain = (rule: RuleDefinition, current: Level, language: string, genre?: string, settings: ExplainSettings = {}): string => {
   const { optionLayers = [], levelFrom } = settings;
-  const ui = uiLanguageOf(language);
-  const text = TEXT[ui];
+  // A rule with nothing to count has no number to set; chaff.yaml's number on it is reported as a problem and ignored.
+  const limit = rule.level_sets === "severity" ? undefined : settings.limit;
+  const marked = limit === undefined ? current : undefined;
+  const text = TEXT[uiLanguageOf(language)];
   const experimental = rule.status === "experimental" ? [`  ${text.experimental}`] : [];
   return [
     "",
@@ -93,12 +120,12 @@ export const renderExplain = (rule: RuleDefinition, current: Level, language: st
     `  ${text.howToFix}: ${readableText(rule, rule.how_to_fix, language)}`,
     ...exampleLines(rule, language, text),
     "",
-    `  ${rule.level_sets === "severity" ? text.severities : text.values(unit)}`,
-    ...definedLevels(rule).map((level) => levelLine(rule, level, current, genre, ui)),
+    `  ${rule.level_sets === "severity" ? text.severities : text.values}`,
+    ...definedLevels(rule).map((level) => levelLine(rule, level, marked, genre, language)),
     ...genreNote(rule, genre, text),
     ...optionLines(rule, optionLayers, language),
     "",
-    `  ${text.now(current)}${levelFrom === undefined ? "" : text.from(levelFrom)}`,
+    `  ${limit === undefined ? text.now(current) : text.nowNumber(limitText(rule, limit, language))}${levelFrom === undefined ? "" : text.from(levelFrom)}`,
     ...experimental,
     "",
     `  ${text.change(rule.id)}`,

package/src/render/rules-json.ts

@@ -8,9 +8,10 @@ import { presetLevelsOf, type PresetLevels } from "../genre-parse.ts";
 import { RULE_GROUPS, groupTextOf } from "../rule-guide.ts";
 import { standingIn } from "../rule-genres.ts";
 import { optionsJson } from "./options.ts";
-import { styleLevelSource } from "../config/style.ts";
+import { limitsFor, styleLevelSource } from "../config/style.ts";
 import { loadStyles } from "../style-load.ts";
 import type { OptionLayer } from "../rule-options.ts";
+import { CUSTOM_TYPES } from "../custom/parse.ts";
 
 const TEXT: Texts<{
   readonly offBySetting: string;
@@ -59,13 +60,15 @@ const TEXT: Texts<{
   },
 };
 
-const now = (rule: RuleDefinition, config: Config, genre: string, text: (typeof TEXT)["ja"], preset: PresetLevels): Record<string, unknown> => {
+type Limits = Readonly<Record<string, number>>;
+
+const now = (rule: RuleDefinition, config: Config, limits: Limits, genre: string, text: (typeof TEXT)["ja"], preset: PresetLevels): Record<string, unknown> => {
   // A run leaves out a rule whose use_for does not cover the genre before it reads any level.
   if (standingIn(rule, genre, {}).kind === "unsuited") return { level: "off", why_off: text.offUnsuited(genre) };
   const explicit = config.rules[rule.id] ?? preset[rule.id];
   if (explicit === "off" && config.rules[rule.id] === undefined) return { level: "off", why_off: text.offByGenre(genre) };
   if (explicit === "off") return { level: "off", why_off: text.offBySetting };
-  const limit = rule.level_sets === "severity" ? undefined : config.limits[rule.id];
+  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.status === "experimental" && !config.experimental) {
@@ -76,23 +79,23 @@ const now = (rule: RuleDefinition, config: Config, genre: string, text: (typeof
 
 /** The level a rule runs at now, and why it is off when it is: what `chaff rules` shows in its table. */
 export const nowFor = (rule: RuleDefinition, config: Config, language: string, genre: string): Record<string, unknown> =>
-  now(rule, config, genre, TEXT[uiLanguageOf(language)], presetLevels(genre));
+  now(rule, config, limitsFor(config, language), genre, TEXT[uiLanguageOf(language)], presetLevels(genre));
 
 /** What a level does to a rule: the limit it counts to, or, with nothing to count, the severity of its findings. */
 const effectAt = (rule: RuleDefinition, level: Exclude<Level, "off">, genre: string): Record<string, unknown> =>
   rule.level_sets === "severity" ? { severity: severityAt(rule, level, genre) } : { limit: resolve(rule, level, genre).limit };
 
-const yourSetting = (rule: RuleDefinition, config: Config): Record<string, unknown> | null => {
+const yourSetting = (rule: RuleDefinition, config: Config, limits: Limits): Record<string, unknown> | null => {
   const level = config.rules[rule.id];
   if (level === undefined) return null;
   const from = styleLevelSource(config, rule.id) ?? config.path;
-  const limit = rule.level_sets === "severity" ? undefined : config.limits[rule.id];
+  const limit = rule.level_sets === "severity" ? undefined : limits[rule.id];
   return limit === undefined ? { level, from } : { level, limit, from };
 };
 
 /** The house style chaff.yaml names: what it decides and the guideline it follows, so an AI can say where a setting came from. */
 const styleOf = (config: Config): Record<string, unknown> | null => {
-  const style = loadStyles().find((entry) => entry.id === config.applied?.style);
+  const style = [...loadStyles(), ...(config.extensions?.styles ?? [])].find((entry) => entry.id === config.applied?.style);
   return style === undefined ? null : { id: style.id, name: style.name, summary: style.summary, source: style.source };
 };
 
@@ -153,11 +156,11 @@ const groupsOf = (): Record<string, unknown>[] =>
 
 /**
  * What the local-rules release adds. Named now so an AI reading the JSON knows they are coming and does not invent them.
- * Filled in when they ship: the style presets under style:, the custom_rules types, and each rule's options.
+ * Filled in as they ship: the style presets under style:, each rule's options. The custom_rules types have shipped.
  */
 const COMING = {
   style_presets: { status: "coming", presets: [] },
-  custom_rule_types: { status: "coming", planned: ["words", "pattern", "tokens", "module"] },
+  custom_rule_types: { status: "available", types: CUSTOM_TYPES },
   rule_options: { status: "coming", note: "Each rule's options (with their types and allowed values) will be listed under options." },
 };
 
@@ -171,6 +174,7 @@ export const rulesJson = (
 ): string => {
   const text = TEXT[uiLanguageOf(language)];
   const preset = presetLevels(genre);
+  const limits = limitsFor(config, language);
   return JSON.stringify(
     {
       // 2: rules gained group, summary, example, not_flagged, level_meaning, languages, requires and genres,
@@ -194,10 +198,12 @@ export const rulesJson = (
         level_sets: rule.level_sets,
         ...levelsOf(rule, genre),
         levels_you_can_set: definedLevels(rule),
-        your_setting: yourSetting(rule, config),
-        now: now(rule, config, genre, text, preset),
+        your_setting: yourSetting(rule, config, limits),
+        now: now(rule, config, limits, genre, text, preset),
         ...(rule.options === undefined ? {} : { options: optionsJson(rule, optionLayers) }),
-        ...(rule.custom === undefined ? {} : { defined_in: "chaff.yaml custom_rules", custom: rule.custom }),
+        ...(rule.custom === undefined
+          ? {}
+          : { defined_in: rule.plugin === undefined ? "chaff.yaml custom_rules" : `plugin ${rule.plugin}`, custom: rule.custom }),
         ...guideOf(rule),
       })),
       how_to_write_settings_from_a_style_note: text.fromStyleNote,

package/src/render/suppressions.ts

@@ -1,4 +1,5 @@
 import type { Suppressed, Suppression } from "../stet.ts";
+import type { NotRun } from "../not-run.ts";
 import type { Texts, UiLanguage } from "../ui.ts";
 import { counted } from "./plural.ts";
 
@@ -11,6 +12,8 @@ const TEXT: Texts<{
   readonly none: string;
   readonly total: (n: number) => string;
   readonly reasonless: (n: number) => string;
+  readonly notRun: string;
+  readonly runExperimental: string;
 }> = {
   ja: {
     nudge: "  ← 設定の見直しを検討してください",
@@ -21,6 +24,8 @@ const TEXT: Texts<{
     none: "\n  抑制されている指摘はありません。\n",
     total: (n) => `抑制されている指摘: ${n} 件`,
     reasonless: (n) => `理由が書かれていない抑制: ${n} 件`,
+    notRun: "stet はあるが、今回動いていない rule（数えていません）:",
+    runExperimental: "試験中の rule は --experimental を付けると数えます。",
   },
   en: {
     nudge: "  <- consider changing the setting instead",
@@ -31,10 +36,18 @@ const TEXT: Texts<{
     none: "\n  No findings are silenced.\n",
     total: (n) => `Silenced findings: ${n}`,
     reasonless: (n) => `Silenced without a reason: ${n}`,
+    notRun: "Rules with a stet that did not run in this check (not counted):",
+    runExperimental: "Experimental rules are counted with --experimental.",
   },
 };
 
-export type PerFile = { readonly path: string; readonly suppressed: readonly Suppressed[]; readonly reasonless: readonly Suppression[] };
+export type PerFile = {
+  readonly path: string;
+  readonly suppressed: readonly Suppressed[];
+  readonly reasonless: readonly Suppression[];
+  /** Rules a stet in the file names that did not run, so their silenced findings could not be counted. */
+  readonly notRun: readonly NotRun[];
+};
 
 /** これを超えたら、その rule は (b) ではなく (c) にすべきというサイン。 */
 const NUDGE_AT = 5;
@@ -72,6 +85,19 @@ const groupLines = (group: Group, ui: UiLanguage): string[] => {
   ];
 };
 
+/** The rules whose stets were not counted because the rule did not run, one line each, with why and where. */
+const notRunLines = (files: readonly PerFile[], ui: UiLanguage): string[] => {
+  const text = TEXT[ui];
+  const rows = files.flatMap((file) => file.notRun.map((entry) => ({ ...entry, path: file.path })));
+  if (rows.length === 0) return [];
+  const rules = [...new Set(rows.map((row) => row.rule))];
+  const lines = rules.map((rule) => {
+    const mine = rows.filter((row) => row.rule === rule);
+    return `      ${rule.padEnd(26)}${mine[0]?.why ?? ""}   ${[...new Set(mine.map((row) => row.path))].join(", ")}`;
+  });
+  return ["", `  ${text.notRun}`, ...lines, ...(rows.some((row) => row.needsExperimental) ? [`  ${text.runExperimental}`] : [])];
+};
+
 /**
  * 抑制が溜まったことに気づけないと、規範と現実の乖離が静かに進む。
  * 同じ rule を何度も黙らせているなら、それは (b) ではなく (c) のサイン。
@@ -81,13 +107,15 @@ export const renderSuppressions = (files: readonly PerFile[], ui: UiLanguage = "
   const text = TEXT[ui];
   const groups = groupByRule(files);
   const total = groups.reduce((sum, group) => sum + group.count, 0);
-  if (total === 0) return text.none;
+  const notRun = notRunLines(files, ui);
+  if (total === 0) return notRun.length === 0 ? text.none : [text.none.trimEnd(), ...notRun, ""].join("\n");
   const reasonless = files.flatMap((file) => file.reasonless.map(() => file.path));
   return [
     "",
     `  ${text.total(total)}`,
     ...groups.flatMap((group) => groupLines(group, ui)),
     ...(reasonless.length > 0 ? ["", `  ${text.reasonless(reasonless.length)}`, `      ${[...new Set(reasonless)].join(", ")}`] : []),
+    ...notRun,
     "",
   ].join("\n");
 };

package/src/rule-guide.ts

@@ -80,6 +80,20 @@ export type ExampleOutcome = {
   readonly after: readonly ExampleFinding[];
 };
 
+/** One spot written the way the rule flags it, and the same spot rewritten without adding a fact. */
+export type RewritePair = { readonly before: string; readonly after: string };
+
+/**
+ * How to rewrite a spot the rule flags, for an AI or a person doing the fix (chaff fix-plan prints it).
+ * direction: what to do; keep: what must not change; avoid: the mistakes a rewriter makes here.
+ */
+export type RuleRewrite = {
+  readonly direction: string;
+  readonly pairs: readonly RewritePair[];
+  readonly keep: readonly string[];
+  readonly avoid: readonly string[];
+};
+
 /** The plain-language part of a rule file: what the reference tells a reader, apart from the texts chaff prints. */
 export type RuleGuide = {
   readonly group: RuleGroup | undefined;
@@ -91,6 +105,10 @@ export type RuleGuide = {
   readonly notFlagged: Localized;
   /** What a level's number means, with {limit} for the number ("一文 {limit} 字まで"). None when every level is the same. */
   readonly levelMeaning: Localized;
+  /** The bibliography entries the rule rests on: the anchors of site/src/content/guide/{ja,en}/bibliography.md. */
+  readonly sources: readonly string[];
+  /** By language, optional per rule. */
+  readonly rewrite: Readonly<Record<string, RuleRewrite>>;
 };
 
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -121,6 +139,24 @@ const examplesOf = (value: unknown): Readonly<Record<string, RuleExample>> =>
       )
     : {};
 
+const textsOf = (value: unknown): string[] => (Array.isArray(value) ? value.filter(isText) : []);
+
+const pairOf = (value: unknown): RewritePair[] =>
+  isRecord(value) && isText(value["before"]) && isText(value["after"]) ? [{ before: value["before"], after: value["after"] }] : [];
+
+/** A block that is written reads field by field; what is missing reads as empty, and the test on rule files names it. */
+const rewriteOf = (value: Readonly<Record<string, unknown>>): RuleRewrite => ({
+  direction: isText(value["direction"]) ? value["direction"] : "",
+  pairs: Array.isArray(value["pairs"]) ? value["pairs"].flatMap(pairOf) : [],
+  keep: textsOf(value["keep"]),
+  avoid: textsOf(value["avoid"]),
+});
+
+const rewritesOf = (value: unknown): Readonly<Record<string, RuleRewrite>> =>
+  isRecord(value)
+    ? Object.fromEntries(Object.entries(value).flatMap(([language, entry]) => (isRecord(entry) ? [[language, rewriteOf(entry)] as const] : [])))
+    : {};
+
 /** A field that is missing or malformed reads as empty; the test on rule files names what a rule lacks. */
 export const ruleGuideOf = (raw: Readonly<Record<string, unknown>>): RuleGuide => ({
   group: RULE_GROUPS.find((group) => group === raw["group"]),
@@ -128,6 +164,8 @@ export const ruleGuideOf = (raw: Readonly<Record<string, unknown>>): RuleGuide =
   examples: examplesOf(raw["example"]),
   notFlagged: localizedOf(raw["not_flagged"]),
   levelMeaning: localizedOf(raw["level_meaning"]),
+  sources: textsOf(raw["sources"]),
+  rewrite: rewritesOf(raw["rewrite"]),
 });
 
 /** The rules in each group, in the order the reference lists them. A rule with no group is in none, which the test on rule files reports. */

package/src/run-semantic.ts

@@ -6,6 +6,7 @@ import { localized } from "./render/text.ts";
 import type { AdapterNeeds, Finding, Level, ProseDocument, RuleDefinition, Severity } from "./plugin.ts";
 import { lineStarts, placeOf } from "./position.ts";
 import { wantsTags } from "./run.ts";
+import { byPosition } from "./finding-order.ts";
 
 export type SemanticResult = {
   readonly findings: readonly Finding[];
@@ -137,7 +138,7 @@ export const runSemantic = async (
     ),
   );
   return {
-    findings: answers.filter((finding) => finding !== undefined).toSorted((left, right) => left.line - right.line),
+    findings: answers.filter((finding) => finding !== undefined).toSorted(byPosition),
     skipped,
     asked: live.reduce((sum, job) => sum + job.candidates.length, 0),
     sentencesSeen: doc.sentences.length,

package/src/run.ts

@@ -13,9 +13,18 @@ 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 { byPosition } from "./finding-order.ts";
 import { PatternTimeout } from "./custom/bounded-match.ts";
-
-export type Skipped = { readonly rule: string; readonly why: string };
+import { PluginRuleFailure } from "./extension/module-detector.ts";
+import { failureReason } from "./extension/failure-text.ts";
+import { tagCoverage } from "./tag-coverage.ts";
+
+export type Skipped = {
+  readonly rule: string;
+  readonly why: string;
+  /** Off only because it is experimental: --experimental (or chaff.yaml's experimental) would run it. */
+  readonly offUntilExperimental?: true;
+};
 
 export type RunResult = {
   readonly findings: readonly Finding[];
@@ -40,9 +49,10 @@ const levelFor = (rule: RuleDefinition, settings: Settings, experimental: boolea
 };
 
 /** Why a rule at off did not run: chaff.yaml turned it off, the genre's preset did, or it is experimental. */
-const offReason = (rule: RuleDefinition, settings: Settings, preset: Settings, genre: string, reasons: Reasons): string => {
-  if (settings[rule.id] !== undefined) return reasons.turnedOff;
-  return preset[rule.id] === undefined ? reasons.experimental : reasons.presetOff(genre);
+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) };
+  return { rule: rule.id, why: reasons.experimental, offUntilExperimental: true };
 };
 
 const reasonsFor = (doc: ProseDocument): Reasons => REASONS[uiLanguageOf(doc.language)];
@@ -102,9 +112,13 @@ const has = (capabilities: ProseDocument["capabilities"], need: string): boolean
  *
  * `capabilities.pos: true` と言いながら token を返さないアダプタでも、rule は
  * `sentence.tokens ?? []` を見るので**例外にならず、指摘 0 件で終わる**。
- * 0 件は「問題なし」と見分けがつかない。
+ * 0 件は「問題なし」と見分けがつかない。一部の文にだけ token が無いとき（解析器が読めなかった段落）も、その段落の 0 件が同じく保証に見える。
  */
-const hasTokens = (doc: ProseDocument): boolean => doc.sentences.length === 0 || doc.sentences.some((sentence) => sentence.tokens !== undefined);
+const tagReason = (doc: ProseDocument): string | undefined => {
+  const coverage = tagCoverage(doc.sentences);
+  if (coverage === "all") return undefined;
+  return coverage === "none" ? reasonsFor(doc).noTags : reasonsFor(doc).unreadTags;
+};
 
 /** 要求を満たさない rule は動かせない。満たさないまま動かすと「指摘 0 件」が保証に見える。 */
 const unmet = (rule: RuleDefinition, doc: ProseDocument): string | undefined => {
@@ -119,7 +133,7 @@ const unmet = (rule: RuleDefinition, doc: ProseDocument): string | undefined =>
  * 先に聞くと、止めている rule まで「アダプタが品詞を返さなかった」と、違う理由で出る。
  */
 const untagged = (rule: RuleDefinition, doc: ProseDocument): string | undefined =>
-  rule.requires.some((need) => need === "pos" || need === "lemma") && !hasTokens(doc) ? reasonsFor(doc).noTags : undefined;
+  rule.requires.some((need) => need === "pos" || need === "lemma") ? tagReason(doc) : undefined;
 
 const forGenre = (rules: readonly RuleDefinition[], genre: string): RuleDefinition[] =>
   rules.filter((rule) => rule.use_for.some((target) => genre.startsWith(target)));
@@ -141,16 +155,21 @@ export const neededBy = (rules: readonly RuleDefinition[], settings: Settings, e
 /** 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. */
+/**
+ * A detector's findings, or why the rule did not run: a team's pattern stopped at its time limit (bounded-match.ts), or a
+ * plugin's detector that threw or returned something else than findings (module-detector.ts). Other errors are chaff's
+ * bugs and propagate.
+ */
 const runDetector = (
   detector: Detector,
   doc: ProseDocument,
   options: DetectorOptions,
-): { readonly findings: readonly Finding[] } | { readonly timedOut: number } => {
+): { readonly findings: readonly Finding[] } | { readonly notRun: string } => {
   try {
     return { findings: detector(doc, options) };
   } catch (error) {
-    if (error instanceof PatternTimeout) return { timedOut: error.budget_ms };
+    if (error instanceof PatternTimeout) return { notRun: reasonsFor(doc).patternTimeout(error.budget_ms) };
+    if (error instanceof PluginRuleFailure) return { notRun: failureReason(error.origin, error.failure, uiLanguageOf(doc.language)) };
     throw error;
   }
 };
@@ -210,6 +229,8 @@ export type RunContext = {
   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[];
+  /** The detectors loaded from the code chaff.yaml names, by rule id. They come before chaff's own table. */
+  readonly detectors?: Readonly<Record<string, Detector>>;
 };
 
 export const runRules = (
@@ -222,7 +243,7 @@ export const runRules = (
 ): 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 { settings, experimental, genre, limits = {}, optionLayers = [], detectors = {} } = context;
   const preset = presetLevels(genre);
   const starts = lineStarts(doc.source);
   const applicable = forGenre(rules, genre);
@@ -239,8 +260,7 @@ export const runRulesWith = (doc: ProseDocument, rules: readonly RuleDefinition[
       const blocked = unmet(rule, doc);
       if (blocked !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: blocked }] };
       const level = levelFor(rule, settings, experimental, preset);
-      if (level === "off")
-        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: offReason(rule, settings, preset, genre, reasonsFor(doc)) }] };
+      if (level === "off") return { findings: acc.findings, skipped: [...acc.skipped, offSkip(rule, settings, preset, genre, reasonsFor(doc))] };
       const noTags = untagged(rule, doc);
       if (noTags !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: noTags }] };
       // 木は capability ではなく、adapter が structure を持つかで決まる。持たない言語で動かすと「参照先が無い」が 0 件に見える。
@@ -251,7 +271,7 @@ export const runRulesWith = (doc: ProseDocument, rules: readonly RuleDefinition[
       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];
+      const detector = detectors[rule.id] ?? DETECTORS[rule.how_to_find];
       if (detector === undefined)
         return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: reasonsFor(doc).noDetector(rule.how_to_find) }] };
       // 語彙表を要求する rule で、その言語に語彙表が無ければ動かせない。黙って通さない。
@@ -268,7 +288,7 @@ export const runRulesWith = (doc: ProseDocument, rules: readonly RuleDefinition[
         ...(rule.custom === undefined ? {} : { custom: rule.custom }),
       };
       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) }] };
+      if ("notRun" in ran) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: ran.notRun }] };
       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 };
     },
@@ -280,5 +300,5 @@ export const runRulesWith = (doc: ProseDocument, rules: readonly RuleDefinition[
       compositeOf(rule, outcome.findings, limitFor(rule, levelFor(rule, settings, experimental, preset), genre, limits), starts, doc.language),
     );
   const all = [...outcome.findings, ...composites];
-  return { ...outcome, findings: all.toSorted((left, right) => left.line - right.line), forcedExperimental: forced, presetExperimental: presetOn };
+  return { ...outcome, findings: all.toSorted(byPosition), forcedExperimental: forced, presetExperimental: presetOn };
 };

package/src/setting-problems.ts

@@ -4,6 +4,7 @@ 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 { extensionProblems } from "./extension/problem-text.ts";
 import { GENRES } from "./genre.ts";
 import { unknownGenres, writtenGenres } from "./genre-check.ts";
 import { loadProfiles } from "./profile/load.ts";
@@ -25,6 +26,7 @@ const profileProblems = (command: string, 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),
+  ...styleProblems(config, [...loadStyles(), ...(config.extensions?.styles ?? [])], ui),
   ...customRuleProblems(config, ui),
+  ...extensionProblems(config, ui),
 ];

package/src/spacing-minority.ts

@@ -0,0 +1,27 @@
+import { minorityStyle } from "./orthography.ts";
+
+/**
+ * 少ないほうがこの割合を超えると、書き損じではなく、書き方が二通りある文書と読む。1 箇所ずつ「違う」と指すと、
+ * 半々に近い文書でどちらかの側に立つことになる。そのときは 1 件にまとめて、両方の数を言う。
+ */
+const MIXED_SHARE = 0.2;
+
+/** 割合が大きくても、これより少なければ 1 箇所ずつ言う。3 箇所のうち 1 箇所なら、その 1 箇所を見せるほうが早い。 */
+const MIN_MIXED = 5;
+
+/** each は少ないほうを 1 箇所ずつ、mixed は文書に書き方が二通りあることを 1 件で。first は少ないほうの最初の箇所。 */
+export type MinorityReport<T> =
+  | { readonly mode: "each"; readonly odd: readonly T[] }
+  | { readonly mode: "mixed"; readonly first: T; readonly odd: number; readonly spaced: number; readonly touching: number };
+
+/** 一つの種類の境目から、何をどう言うか。混ざっていない、または少ないほうが limit に届かなければ言わない。 */
+export const minorityReport = <T extends { readonly spaced: boolean }>(ofKind: readonly T[], limit: number): MinorityReport<T> | undefined => {
+  const minority = minorityStyle(ofKind);
+  if (minority === undefined) return undefined;
+  const odd = ofKind.filter((entry) => entry.spaced === minority);
+  const first = odd[0];
+  if (first === undefined || odd.length < limit) return undefined;
+  if (odd.length < MIN_MIXED || odd.length <= ofKind.length * MIXED_SHARE) return { mode: "each", odd };
+  const spaced = ofKind.filter((entry) => entry.spaced).length;
+  return { mode: "mixed", first, odd: odd.length, spaced, touching: ofKind.length - spaced };
+};