chaffjs 0.18.0 → 0.20.0

package/src/cross-run.ts

@@ -0,0 +1,107 @@
+import type { CrossDetector, DetectorOptions, DocumentFinding, Finding, Level, ProseDocument, RuleDefinition } from "./plugin.ts";
+import { levelFor, limitFor, place, type RunContext, type RunResult, type Skipped } from "./run.ts";
+import { presetLevels } from "./genre-load.ts";
+import { severityAt } from "./levels.ts";
+import { lineStarts } from "./position.ts";
+import { REASONS } from "./reasons.ts";
+import { uiLanguageOf } from "./ui.ts";
+import { byPosition } from "./finding-order.ts";
+import { optionValues, settleOptions } from "./rule-options.ts";
+
+// The second pass of a run over several files: the rules that compare documents (requires: [documents]). The first pass,
+// run on each document alone, gates them as it gates any rule (language, level, tags, Markdown) and, when nothing else
+// stops them, sets them aside with the reason oneDocument. Here every document that set a rule aside takes part in it.
+
+/** One document of the run, with what its own pass found and the settings it ran with. */
+export type CrossInput = {
+  readonly doc: ProseDocument;
+  readonly rules: readonly RuleDefinition[];
+  readonly context: RunContext;
+  readonly raw: RunResult;
+};
+
+const oneDocumentReason = (doc: ProseDocument): string => REASONS[uiLanguageOf(doc.language)].oneDocument;
+
+/** The rules the document's own pass set aside for this one: everything but the number of documents let them run. */
+const waitingRules = (input: CrossInput): string[] =>
+  input.raw.skipped.filter((entry) => entry.why === oneDocumentReason(input.doc)).map((entry) => entry.rule);
+
+const isOn = (level: Level): level is Exclude<Level, "off"> => level !== "off";
+
+/** The rule's level for this document. A rule set aside was not off, so off does not come back here; it reads as normal. */
+const levelOf = (input: CrossInput, rule: RuleDefinition): Exclude<Level, "off"> => {
+  const level = levelFor(rule, input.context.settings, input.context.experimental, presetLevels(input.context.genre));
+  return isOn(level) ? level : "normal";
+};
+
+/** The options a detector gets: those of the first document taking part, the way a single document's pass builds them. */
+const optionsFor = (input: CrossInput, rule: RuleDefinition): DetectorOptions => ({
+  limit: limitFor(rule, levelOf(input, rule), input.context.genre, input.context.limits ?? {}),
+  lexicon: rule.word_list === undefined ? undefined : input.doc.lexicons[rule.word_list],
+  where: rule.where,
+  ...(rule.options === undefined ? {} : { settings: optionValues(settleOptions(rule.id, rule.options, input.context.optionLayers ?? [])) }),
+});
+
+/** What one rule did to the documents taking part (by path): its findings, or why it did not run after all. */
+type RuleOutcome = {
+  readonly rule: string;
+  readonly paths: ReadonlySet<string>;
+  readonly findings: readonly DocumentFinding[];
+  readonly skip?: string;
+};
+
+const ruleOf = (input: CrossInput, id: string): RuleDefinition | undefined => input.rules.find((rule) => rule.id === id);
+
+const runRule = (id: string, participants: readonly CrossInput[], detectors: Readonly<Record<string, CrossDetector>>): RuleOutcome | undefined => {
+  const [first] = participants;
+  const rule = first === undefined ? undefined : ruleOf(first, id);
+  // One document taking part has nothing to be compared with: the reason it was set aside stays the reason.
+  if (first === undefined || rule === undefined || participants.length < 2) return undefined;
+  const paths = new Set(participants.map((input) => input.doc.path));
+  const detector = detectors[rule.how_to_find];
+  if (detector === undefined) return { rule: id, paths, findings: [], skip: REASONS[uiLanguageOf(first.doc.language)].noDetector(rule.how_to_find) };
+  const found = detector(
+    participants.map((input) => input.doc),
+    optionsFor(first, rule),
+  );
+  return { rule: id, paths, findings: found };
+};
+
+/** The rule's findings in one document, placed (line and column) and at that document's severity for the rule. */
+const placedIn = (input: CrossInput, outcome: RuleOutcome): Finding[] => {
+  const rule = ruleOf(input, outcome.rule);
+  if (rule === undefined) return [];
+  const starts = lineStarts(input.doc.source);
+  const severity = severityAt(rule, levelOf(input, rule), input.context.genre);
+  return outcome.findings.filter((entry) => entry.path === input.doc.path).map((entry) => place(starts, { ...entry.finding, rule: rule.id, severity }));
+};
+
+/** The document's results with the rules it took part in: their findings added, and the reason they were set aside gone. */
+const withOutcomes = (input: CrossInput, outcomes: readonly RuleOutcome[]): RunResult => {
+  const mine = outcomes.filter((outcome) => outcome.paths.has(input.doc.path));
+  if (mine.length === 0) return input.raw;
+  const decided = new Set(mine.map((outcome) => outcome.rule));
+  const skipped: Skipped[] = [
+    ...input.raw.skipped.filter((entry) => !(decided.has(entry.rule) && entry.why === oneDocumentReason(input.doc))),
+    ...mine.flatMap((outcome) => (outcome.skip === undefined ? [] : [{ rule: outcome.rule, why: outcome.skip }])),
+  ];
+  const added = mine.flatMap((outcome) => placedIn(input, outcome));
+  return { ...input.raw, findings: [...input.raw.findings, ...added].toSorted(byPosition), skipped };
+};
+
+/**
+ * Runs the rules that compare documents over the documents of one run, and returns each document's results with
+ * them in, in the order given. A rule that only one document took part in keeps that document's reason, oneDocument.
+ */
+export const runCrossRules = (inputs: readonly CrossInput[], detectors: Readonly<Record<string, CrossDetector>>): RunResult[] => {
+  const ids = [...new Set(inputs.flatMap(waitingRules))];
+  const outcomes = ids.flatMap((id) => {
+    const outcome = runRule(
+      id,
+      inputs.filter((input) => waitingRules(input).includes(id)),
+      detectors,
+    );
+    return outcome === undefined ? [] : [outcome];
+  });
+  return inputs.map((input) => withOutcomes(input, outcomes));
+};

package/src/cross-variants.ts

@@ -0,0 +1,55 @@
+// One word written one way in some files of a run and another way in the others (サーバ / サーバー, e-mail / email).
+// Pure: the words come in already read from each document, each with the key both spellings share.
+import { tallyVotes, type Vote } from "./cross-votes.ts";
+
+/** One written word: the key both its spellings share, the spelling as written (in a form that compares), and where. */
+export type KeyedWord = { readonly key: string; readonly form: string; readonly offset: number };
+
+/** A document's keyed words, by its path. */
+export type DocumentWords = { readonly path: string; readonly words: readonly KeyedWord[] };
+
+/** A file that spells a word unlike the run: its first such word, the usual form, how many files use it, and one of them. */
+export type OddSpelling = { readonly path: string; readonly word: KeyedWord; readonly usual: string; readonly files: number; readonly example: string };
+
+/** How one file writes one key: the forms it uses, and the first place it writes it. */
+type Usage = { readonly path: string; readonly forms: Set<string>; readonly first: KeyedWord };
+
+/** Each key's usage, file by file in the run's order, read in one pass. */
+const usagesByKey = (docs: readonly DocumentWords[]): Map<string, Usage[]> => {
+  const byKey = new Map<string, Usage[]>();
+  docs.forEach((doc) => {
+    const mine = new Map<string, Usage>();
+    doc.words.forEach((word) => {
+      const usage = mine.get(word.key) ?? { path: doc.path, forms: new Set<string>(), first: word };
+      usage.forms.add(word.form);
+      mine.set(word.key, usage);
+    });
+    mine.forEach((usage, key) => byKey.set(key, [...(byKey.get(key) ?? []), usage]));
+  });
+  return byKey;
+};
+
+/** A file's vote: the one form it writes the key in. A file writing it two ways does not vote (its own rules point at that). */
+const votesOf = (usages: readonly Usage[]): Vote<string>[] =>
+  usages.flatMap((usage) => {
+    const [form] = usage.forms;
+    return usage.forms.size === 1 && form !== undefined ? [{ path: usage.path, value: form }] : [];
+  });
+
+const oddAmong = (usages: readonly Usage[]): OddSpelling[] => {
+  const tally = tallyVotes(votesOf(usages), (left, right) => left === right);
+  const [example] = tally?.usual ?? [];
+  if (tally === undefined || example === undefined) return [];
+  const firstIn = new Map(usages.map((usage) => [usage.path, usage.first]));
+  return tally.odd.flatMap((vote) => {
+    const word = firstIn.get(vote.path);
+    return word === undefined ? [] : [{ path: vote.path, word, usual: example.value, files: tally.usual.length, example: example.path }];
+  });
+};
+
+/**
+ * The files that write a word unlike the rest of the run. Each file that writes a word one way votes for that way; a file
+ * writing it both ways does not vote. When the votes split, every file outside the usual way is reported once per word,
+ * at the first place it writes it.
+ */
+export const oddSpellings = (docs: readonly DocumentWords[]): OddSpelling[] => [...usagesByKey(docs).values()].flatMap(oddAmong);

package/src/cross-votes.ts

@@ -0,0 +1,29 @@
+// How the rules that compare files decide which file is out of step: each file votes with the one value it writes for an
+// item (a spelling, a price, a definition), and the files outside the value most files write are the ones reported.
+// Pure. chaff takes no side on which value is right; the fewer side is where to look.
+
+/** One file's value for one item. */
+export type Vote<T> = { readonly path: string; readonly value: T };
+
+/** The votes for the value most files write, and the votes for any other value, in the run's order. */
+export type Tally<T> = { readonly usual: readonly Vote<T>[]; readonly odd: readonly Vote<T>[]; readonly values: number };
+
+/** The votes grouped by value, each group in the order its first vote came. */
+const groupsOf = <T>(votes: readonly Vote<T>[], same: (left: T, right: T) => boolean): Vote<T>[][] =>
+  votes.reduce<Vote<T>[][]>((groups, vote) => {
+    const home = groups.find((group) => group[0] !== undefined && same(group[0].value, vote.value));
+    if (home === undefined) groups.push([vote]);
+    else home.push(vote);
+    return groups;
+  }, []);
+
+/**
+ * The votes split by value. The usual value is the one most files write; on a tie, the one whose first file comes first in
+ * the run's order. values: how many different values the files write. undefined when no file votes.
+ */
+export const tallyVotes = <T>(votes: readonly Vote<T>[], same: (left: T, right: T) => boolean): Tally<T> | undefined => {
+  const groups = groupsOf(votes, same);
+  const usual = groups.reduce<Vote<T>[] | undefined>((best, group) => (best === undefined || group.length > best.length ? group : best), undefined);
+  if (usual === undefined) return undefined;
+  return { usual, odd: votes.filter((vote) => !usual.includes(vote)), values: groups.length };
+};

package/src/custom/load.ts

@@ -5,11 +5,19 @@ import { loadGenres } from "../genre-load.ts";
 import { parseCustomRules, type CustomRules } from "./parse.ts";
 
 /** The team's custom_rules as rules, with what could not be read. A team's rule applies to every genre, like the team's words. */
-export const customRulesOf = (config: Pick<Config, "customRules">): CustomRules =>
+export const customRulesOf = (config: Pick<Config, "customRules" | "baseDir">): CustomRules =>
   parseCustomRules(config.customRules, {
     builtIn: new Set(loadRules("en").map((rule) => rule.id)),
     useFor: loadGenres().groups.map((group) => group.id),
+    baseDir: config.baseDir,
   });
 
-/** Every rule a run knows for a language: chaff's own, then the team's. Where the team's cannot be read, settingProblems stops the run. */
-export const rulesOf = (language: string, config: Pick<Config, "customRules">): RuleDefinition[] => [...loadRules(language), ...customRulesOf(config).rules];
+/**
+ * Every rule a run knows for a language: chaff's own, the team's, then the plugins'. Where the team's or a plugin's
+ * cannot be read, settingProblems stops the run.
+ */
+export const rulesOf = (language: string, config: Pick<Config, "customRules" | "baseDir" | "extensions">): RuleDefinition[] => [
+  ...loadRules(language),
+  ...customRulesOf(config).rules,
+  ...(config.extensions?.rules ?? []),
+];

package/src/custom/module-path.ts

@@ -0,0 +1,23 @@
+import { isAbsolute, relative, resolve, sep } from "node:path";
+
+// Where a type: module rule's file is. Loading it runs its code, so a relative path may not leave the folder chaff.yaml
+// is in: a chaff.yaml copied from elsewhere cannot reach for ../../somewhere. An absolute path is written on purpose and
+// is used as written. Pure: no file is read.
+
+export type ModulePathRefusal = "outside";
+
+export type ModulePath = { readonly file: string } | { readonly refusal: ModulePathRefusal };
+
+/** Whether file is inside dir (dir itself is not). Reads no file: the same check runs on real paths at load time. */
+export const isInside = (dir: string, file: string): boolean => {
+  const fromDir = relative(dir, file);
+  const leaves = fromDir === ".." || fromDir.startsWith(`..${sep}`);
+  return fromDir !== "" && !leaves && !isAbsolute(fromDir);
+};
+
+/** The file a module path names, relative to baseDir (where chaff.yaml is) unless it is absolute. */
+export const modulePathOf = (written: string, baseDir: string): ModulePath => {
+  if (isAbsolute(written)) return { file: written };
+  const file = resolve(baseDir, written);
+  return isInside(baseDir, file) ? { file } : { refusal: "outside" };
+};

package/src/custom/parse.ts

@@ -1,14 +1,12 @@
 import type { CustomSpec, LevelTable, Localized, RuleDefinition, Severity, TokenCondition } from "../plugin.ts";
 import { regexRefusal, type RegexRefusal } from "./regex-safety.ts";
 import { posTags } from "./token-pattern.ts";
+import { modulePathOf, type ModulePathRefusal } from "./module-path.ts";
 
 // custom_rules in chaff.yaml: a team's own deterministic rules, written without code. Each becomes a RuleDefinition like the
 // built-in ones, so findings, explain, rules --json, stet, the baseline and SARIF treat it the same. Pure: the YAML comes in parsed.
 
-export const CUSTOM_TYPES = ["words", "pattern", "tokens"] as const;
-
-/** Reserved for a small Node function a team writes. Refused with its own message until it is supported. */
-const RESERVED_TYPES: readonly string[] = ["module"];
+export const CUSTOM_TYPES = ["words", "pattern", "tokens", "module"] as const;
 
 export type CustomProblem =
   | { readonly kind: "not-a-list" }
@@ -17,7 +15,9 @@ export type CustomProblem =
   | { readonly kind: "duplicate-id"; readonly at: string }
   | { readonly kind: "built-in-id"; readonly at: string }
   | { readonly kind: "unknown-type"; readonly at: string; readonly written: string }
-  | { readonly kind: "not-yet"; readonly at: string; readonly written: string }
+  | { readonly kind: "bad-module"; readonly at: string; readonly written: string; readonly refusal: ModulePathRefusal }
+  | { readonly kind: "bad-requires"; readonly at: string; readonly written: string }
+  | { readonly kind: "bad-word-list"; readonly at: string; readonly written: string }
   | { readonly kind: "missing"; readonly at: string; readonly field: string }
   | { readonly kind: "unpaired-example"; readonly at: string }
   | { readonly kind: "bad-level"; readonly at: string; readonly written: string }
@@ -30,8 +30,11 @@ export type CustomProblem =
 
 export type CustomRules = { readonly rules: readonly RuleDefinition[]; readonly problems: readonly CustomProblem[] };
 
-/** What parsing needs to know: the built-in rule ids (a team's rule may not take one) and the genres a rule applies to. */
-export type CustomContext = { readonly builtIn: ReadonlySet<string>; readonly useFor: readonly string[] };
+/**
+ * What parsing needs to know: the built-in rule ids (a team's rule may not take one), the genres a rule applies to, and
+ * the folder a module's path is relative to (where chaff.yaml is).
+ */
+export type CustomContext = { readonly builtIn: ReadonlySet<string>; readonly useFor: readonly string[]; readonly baseDir: string };
 
 const RULE_ID = /^[a-z][a-z0-9-]*$/u;
 const SEVERITIES: readonly Severity[] = ["info", "warning", "error"];
@@ -113,16 +116,24 @@ const tokensOf = (raw: unknown, at: string): Checked<CustomSpec> => {
   return problems.length > 0 ? failed(...problems) : ok({ type: "tokens", tokens });
 };
 
-const specOf = (raw: Record<string, unknown>, type: string, at: string): Checked<CustomSpec> => {
+const moduleOf = (raw: Record<string, unknown>, at: string, baseDir: string): Checked<CustomSpec> => {
+  const written = raw["module"];
+  if (!nonEmpty(written)) return failed({ kind: "missing", at, field: "module" });
+  const path = modulePathOf(written.trim(), baseDir);
+  if ("refusal" in path) return failed({ kind: "bad-module", at, written, refusal: path.refusal });
+  return ok({ type: "module", module: written.trim(), file: path.file });
+};
+
+const specOf = (raw: Record<string, unknown>, type: string, at: string, baseDir: string): Checked<CustomSpec> => {
   if (type === "words") return wordsOf(raw["words"], at);
   if (type === "pattern") return patternOf(raw, at);
+  if (type === "module") return moduleOf(raw, at, baseDir);
   return tokensOf(raw["tokens"], at);
 };
 
 const typeOf = (raw: Record<string, unknown>, at: string): Checked<string> => {
   const type = raw["type"];
   if (!nonEmpty(type)) return failed({ kind: "missing", at, field: "type" });
-  if (RESERVED_TYPES.includes(type)) return failed({ kind: "not-yet", at, written: type });
   return CUSTOM_TYPES.some((known) => known === type) ? ok(type) : failed({ kind: "unknown-type", at, written: type });
 };
 
@@ -157,6 +168,33 @@ const textsOf = (raw: Record<string, unknown>, at: string): Checked<Texts> => {
   return ok({ name, why, how_to_fix: howToFix, before, after });
 };
 
+/** What a module's detector may ask the adapter for. Only parts of speech: without them, sentences have no tokens. */
+const REQUIRABLE: readonly string[] = ["pos"];
+
+const requiresOf = (raw: unknown, type: string, at: string): Checked<readonly string[]> => {
+  if (type === "tokens") return ok(["pos"]);
+  if (raw === undefined || type !== "module") return ok([]);
+  const written = (Array.isArray(raw) ? raw : [raw]).map((entry: unknown) => (typeof entry === "string" ? entry : printed(entry)));
+  const unknown = written.find((need) => !REQUIRABLE.includes(need));
+  return unknown === undefined ? ok([...new Set(written)]) : failed({ kind: "bad-requires", at, written: unknown });
+};
+
+/** A module's word list by name; its detector gets it as options.lexicon. The other types carry their words themselves. */
+const wordListOf = (raw: unknown, type: string, at: string): Checked<string | undefined> => {
+  if (raw === undefined || type !== "module") return ok(undefined);
+  return nonEmpty(raw) ? ok(raw.trim()) : failed({ kind: "bad-word-list", at, written: printed(raw) });
+};
+
+/** What a rule's detector needs besides the document: tokens from the adapter, and a word list. */
+type Needs = { readonly requires: readonly string[]; readonly wordList: string | undefined };
+
+const needsOf = (raw: Record<string, unknown>, type: string, at: string): Checked<Needs> => {
+  const requires = requiresOf(raw["requires"], type, at);
+  const wordList = wordListOf(raw["word_list"], type, at);
+  if (requires.value === undefined || wordList.problems.length > 0) return failed(...requires.problems, ...wordList.problems);
+  return ok({ requires: requires.value, wordList: wordList.value });
+};
+
 const languagesOf = (raw: unknown, at: string): Checked<readonly string[] | undefined> => {
   if (raw === undefined) return ok(undefined);
   const list = Array.isArray(raw) ? raw : [raw];
@@ -175,12 +213,19 @@ const PLACEHOLDERS: Readonly<Record<string, Localized>> = {
   preferred: { ja: "使う書き方", en: "the spelling to use" },
 };
 
-const HOW_TO_FIND: Readonly<Record<CustomSpec["type"], string>> = { words: "custom-words", pattern: "custom-pattern", tokens: "custom-tokens" };
+/** A module's detector is not in chaff's table: it is loaded from the module and found by the rule's id. */
+const HOW_TO_FIND: Readonly<Record<CustomSpec["type"], string>> = {
+  words: "custom-words",
+  pattern: "custom-pattern",
+  tokens: "custom-tokens",
+  module: "module",
+};
 
 type Example = { readonly before: string; readonly after: string };
 
 type Parts = {
   readonly spec: CustomSpec;
+  readonly needs: Needs;
   readonly severity: Severity;
   readonly texts: Texts;
   readonly languages: readonly string[] | undefined;
@@ -200,7 +245,7 @@ const examplesOf = (texts: Texts, languages: readonly string[] | undefined): Rec
 
 const definitionOf = (id: string, raw: Record<string, unknown>, parts: Parts, useFor: readonly string[]): RuleDefinition => ({
   id,
-  layer: parts.spec.type === "tokens" ? "L3" : "L2",
+  layer: parts.needs.requires.includes("pos") ? "L3" : "L2",
   status: "stable",
   name: parts.texts.name,
   why: parts.texts.why,
@@ -212,12 +257,12 @@ const definitionOf = (id: string, raw: Record<string, unknown>, parts: Parts, us
   level_sets: "severity",
   by_genre: {},
   how_to_find: HOW_TO_FIND[parts.spec.type],
-  word_list: undefined,
+  word_list: parts.needs.wordList,
   extra_word_lists: [],
   what_to_check: undefined,
   where: undefined,
   full_sentence: undefined,
-  requires: parts.spec.type === "tokens" ? ["pos"] : [],
+  requires: parts.needs.requires,
   uses: [],
   from: [],
   languages: parts.languages,
@@ -231,6 +276,8 @@ const definitionOf = (id: string, raw: Record<string, unknown>, parts: Parts, us
     examples: parts.examples,
     notFlagged: {},
     levelMeaning: {},
+    sources: [],
+    rewrite: {},
   },
 });
 
@@ -247,16 +294,18 @@ const ruleOf = (raw: unknown, index: number, seen: ReadonlySet<string>, context:
   const id = idOf(raw, index, seen, context.builtIn);
   const at = id.value ?? (nonEmpty(raw["id"]) ? raw["id"] : `#${String(index + 1)}`);
   const type = typeOf(raw, at);
-  const spec = type.value === undefined ? failed<CustomSpec>() : specOf(raw, type.value, at);
+  const spec = type.value === undefined ? failed<CustomSpec>() : specOf(raw, type.value, at, context.baseDir);
+  const needs = needsOf(raw, type.value ?? "", at);
   const severity = severityOf(raw["level"], at);
   const texts = textsOf(raw, at);
   const languages = languagesOf(raw["languages"], at);
   const examples = texts.value === undefined ? {} : examplesOf(texts.value, languages.value);
   const unpaired: CustomProblem[] = texts.value !== undefined && Object.keys(examples).length === 0 ? [{ kind: "unpaired-example", at }] : [];
-  const problems = [...[id, type, spec, severity, texts, languages].flatMap((checked) => checked.problems), ...unpaired];
-  if (id.value === undefined || spec.value === undefined || severity.value === undefined || texts.value === undefined || problems.length > 0)
-    return failed(...problems);
-  const parts = { spec: spec.value, severity: severity.value, texts: texts.value, languages: languages.value, examples };
+  const problems = [...[id, type, spec, needs, severity, texts, languages].flatMap((checked) => checked.problems), ...unpaired];
+  if (problems.length > 0) return failed(...problems);
+  if (id.value === undefined || spec.value === undefined || needs.value === undefined || severity.value === undefined || texts.value === undefined)
+    return failed();
+  const parts = { spec: spec.value, needs: needs.value, severity: severity.value, texts: texts.value, languages: languages.value, examples };
   return ok(definitionOf(id.value, raw, parts, context.useFor));
 };
 

package/src/custom/problems.ts

@@ -4,12 +4,20 @@ import type { CustomProblem } from "./parse.ts";
 import { customRulesOf } from "./load.ts";
 import { MAX_PATTERN_LENGTH, MAX_REPEATS, type RegexRefusal } from "./regex-safety.ts";
 import { POS_WRITTEN_NAMES } from "./token-pattern.ts";
+import type { ModulePathRefusal } from "./module-path.ts";
 
 /** Each problem's sentence, with {at}, {written}, {field}, {index}, {refusal} and {names} filled in from the problem. */
-type Text = { readonly problems: Readonly<Record<CustomProblem["kind"], string>>; readonly refusal: Readonly<Record<RegexRefusal, string>> };
+type Text = {
+  readonly problems: Readonly<Record<CustomProblem["kind"], string>>;
+  readonly refusal: Readonly<Record<RegexRefusal, string>>;
+  readonly modulePath: Readonly<Record<ModulePathRefusal, string>>;
+};
 
 const TEXT: Texts<Text> = {
   ja: {
+    modulePath: {
+      outside: "chaff.yaml のあるフォルダの外です。読み込むとそのコードが動くので、外のファイルは絶対パスで名指ししてください",
+    },
     refusal: {
       "too-long": `${String(MAX_PATTERN_LENGTH)} 字を超えています。いくつかのルールに分けてください`,
       "nested-quantifier": "繰り返しの中に繰り返しがあります（(a+)+ のような形）。長い行で止まらなくなるので使えません",
@@ -19,25 +27,30 @@ const TEXT: Texts<Text> = {
       invalid: "正規表現として読めません",
     },
     problems: {
-      "not-a-list": "custom_rules はルールの並び（- id: …）で書いてください",
-      "not-a-map": "custom_rules の {at}: id や type を持つ項目として書いてください",
-      "bad-id": "custom_rules の {at}: id は英小文字で始まり、英小文字・数字・ハイフンだけで書きます（例: team-no-tbd）",
-      "duplicate-id": "custom_rules の {at}: 同じ id のルールがもう一つあります",
-      "built-in-id": "custom_rules の {at}: chaff のルールと同じ id です。別の id にしてください",
-      "unknown-type": "custom_rules の {at}: type: {written} は使えません（words / pattern / tokens）",
-      "not-yet": "custom_rules の {at}: type: {written} はまだ使えません（words / pattern / tokens）",
-      missing: "custom_rules の {at}: {field} がありません",
-      "unpaired-example": "custom_rules の {at}: example の before と after を、ルールが見る言語の同じ言語で書いてください",
-      "bad-level": "custom_rules の {at}: level: {written} は読めません（error / warning / info）",
-      "bad-languages": "custom_rules の {at}: languages は言語の並びで書いてください（[ja] や [ja, en]）",
-      "no-words": "custom_rules の {at}: words に語がありません（「使わない書き方: 使う書き方」か語の並び）",
-      "no-tokens": "custom_rules の {at}: tokens に語の条件がありません（- { pos: 名詞 } のように並べます）",
-      "bad-token": "custom_rules の {at}: tokens の {index} 番目に pos・base・surface のどれもありません",
-      "unknown-pos": "custom_rules の {at}: 品詞 {written} は知りません（{names}）",
-      "bad-pattern": "custom_rules の {at}: pattern を使えません。{refusal}",
+      "not-a-list": "{scope} はルールの並び（- id: …）で書いてください",
+      "not-a-map": "{scope} の {at}: id や type を持つ項目として書いてください",
+      "bad-id": "{scope} の {at}: id は英小文字で始まり、英小文字・数字・ハイフンだけで書きます（例: team-no-tbd）",
+      "duplicate-id": "{scope} の {at}: 同じ id のルールがもう一つあります",
+      "built-in-id": "{scope} の {at}: chaff のルールと同じ id です。別の id にしてください",
+      "unknown-type": "{scope} の {at}: type: {written} は使えません（words / pattern / tokens / module）",
+      "bad-module": "{scope} の {at}: module: {written} は使えません。{refusal}",
+      "bad-requires": "{scope} の {at}: requires: {written} は求められません（求められるのは pos だけです）",
+      "bad-word-list": "{scope} の {at}: word_list: {written} は語彙表の名前として読めません",
+      missing: "{scope} の {at}: {field} がありません",
+      "unpaired-example": "{scope} の {at}: example の before と after を、ルールが見る言語の同じ言語で書いてください",
+      "bad-level": "{scope} の {at}: level: {written} は読めません（error / warning / info）",
+      "bad-languages": "{scope} の {at}: languages は言語の並びで書いてください（[ja] や [ja, en]）",
+      "no-words": "{scope} の {at}: words に語がありません（「使わない書き方: 使う書き方」か語の並び）",
+      "no-tokens": "{scope} の {at}: tokens に語の条件がありません（- { pos: 名詞 } のように並べます）",
+      "bad-token": "{scope} の {at}: tokens の {index} 番目に pos・base・surface のどれもありません",
+      "unknown-pos": "{scope} の {at}: 品詞 {written} は知りません（{names}）",
+      "bad-pattern": "{scope} の {at}: pattern を使えません。{refusal}",
     },
   },
   en: {
+    modulePath: {
+      outside: "it is outside the folder chaff.yaml is in. Loading a module runs its code, so name a file outside by its absolute path",
+    },
     refusal: {
       "too-long": `it is longer than ${String(MAX_PATTERN_LENGTH)} characters; split it into several rules`,
       "nested-quantifier": "it repeats something that repeats (a shape like (a+)+), which can run for minutes on a long line",
@@ -47,43 +60,52 @@ const TEXT: Texts<Text> = {
       invalid: "it is not a regular expression",
     },
     problems: {
-      "not-a-list": "write custom_rules as a list of rules (- id: …)",
-      "not-a-map": "custom_rules {at}: write each rule as an entry with id and type",
-      "bad-id": "custom_rules {at}: an id starts with a lowercase letter and has only lowercase letters, digits and hyphens (team-no-tbd)",
-      "duplicate-id": "custom_rules {at}: another rule has the same id",
-      "built-in-id": "custom_rules {at}: chaff has a rule with this id; choose another",
-      "unknown-type": "custom_rules {at}: type: {written} is not a type (words / pattern / tokens)",
-      "not-yet": "custom_rules {at}: type: {written} is not supported yet (words / pattern / tokens)",
-      missing: "custom_rules {at}: {field} is missing",
-      "unpaired-example": "custom_rules {at}: write example's before and after in the same language, one the rule checks",
-      "bad-level": "custom_rules {at}: cannot read level: {written} (error / warning / info)",
-      "bad-languages": "custom_rules {at}: write languages as a list ([en] or [ja, en])",
-      "no-words": "custom_rules {at}: words has no words (avoid: use pairs, or a list)",
-      "no-tokens": "custom_rules {at}: tokens has no conditions (- { pos: noun } and so on)",
-      "bad-token": "custom_rules {at}: token {index} has none of pos, base and surface",
-      "unknown-pos": "custom_rules {at}: unknown part of speech {written} ({names})",
-      "bad-pattern": "custom_rules {at}: the pattern cannot be used: {refusal}",
+      "not-a-list": "write {scope} as a list of rules (- id: …)",
+      "not-a-map": "{scope} {at}: write each rule as an entry with id and type",
+      "bad-id": "{scope} {at}: an id starts with a lowercase letter and has only lowercase letters, digits and hyphens (team-no-tbd)",
+      "duplicate-id": "{scope} {at}: another rule has the same id",
+      "built-in-id": "{scope} {at}: chaff has a rule with this id; choose another",
+      "unknown-type": "{scope} {at}: type: {written} is not a type (words / pattern / tokens / module)",
+      "bad-module": "{scope} {at}: module: {written} cannot be used: {refusal}",
+      "bad-requires": "{scope} {at}: requires: {written} cannot be asked for (only pos can)",
+      "bad-word-list": "{scope} {at}: cannot read word_list: {written} as the name of a word list",
+      missing: "{scope} {at}: {field} is missing",
+      "unpaired-example": "{scope} {at}: write example's before and after in the same language, one the rule checks",
+      "bad-level": "{scope} {at}: cannot read level: {written} (error / warning / info)",
+      "bad-languages": "{scope} {at}: write languages as a list ([en] or [ja, en])",
+      "no-words": "{scope} {at}: words has no words (avoid: use pairs, or a list)",
+      "no-tokens": "{scope} {at}: tokens has no conditions (- { pos: noun } and so on)",
+      "bad-token": "{scope} {at}: token {index} has none of pos, base and surface",
+      "unknown-pos": "{scope} {at}: unknown part of speech {written} ({names})",
+      "bad-pattern": "{scope} {at}: the pattern cannot be used: {refusal}",
     },
   },
 };
 
-const PLACEHOLDER = /\{(at|written|field|index|refusal|names)\}/gu;
+const PLACEHOLDER = /\{(scope|at|written|field|index|refusal|names)\}/gu;
+
+const refusalOf = (problem: CustomProblem, text: Text): string => {
+  if (problem.kind === "bad-pattern") return text.refusal[problem.refusal];
+  return problem.kind === "bad-module" ? text.modulePath[problem.refusal] : "";
+};
 
 /** The values a problem's sentence names. Each kind carries only some of them. */
-const valuesOf = (problem: CustomProblem, text: Text): Readonly<Record<string, string>> => ({
+const valuesOf = (problem: CustomProblem, text: Text, scope: string): Readonly<Record<string, string>> => ({
+  scope,
   at: "at" in problem ? problem.at : "",
   written: "written" in problem ? problem.written : "",
   field: "field" in problem ? problem.field : "",
   index: "index" in problem ? String(problem.index) : "",
-  refusal: "refusal" in problem ? text.refusal[problem.refusal] : "",
+  refusal: refusalOf(problem, text),
   names: POS_WRITTEN_NAMES.join(" / "),
 });
 
-const sentenceOf = (problem: CustomProblem, text: Text): string => {
-  const values = valuesOf(problem, text);
-  return text.problems[problem.kind].replace(PLACEHOLDER, (_whole, key: string) => values[key] ?? "");
+/** One problem as a sentence. scope names the list the rule is in: custom_rules, or a plugin's rules. */
+export const customProblemSentence = (problem: CustomProblem, ui: UiLanguage, scope = "custom_rules"): string => {
+  const values = valuesOf(problem, TEXT[ui], scope);
+  return TEXT[ui].problems[problem.kind].replace(PLACEHOLDER, (_whole, key: string) => values[key] ?? "");
 };
 
 /** What in custom_rules cannot run. Each stops the run: a team's rule that silently does not run looks like a clean document. */
-export const customRuleProblems = (config: Pick<Config, "customRules" | "path">, ui: UiLanguage): string[] =>
-  customRulesOf(config).problems.map((problem) => `chaff: ${config.path ?? "chaff.yaml"}: ${sentenceOf(problem, TEXT[ui])}`);
+export const customRuleProblems = (config: Pick<Config, "customRules" | "path" | "baseDir">, ui: UiLanguage): string[] =>
+  customRulesOf(config).problems.map((problem) => `chaff: ${config.path ?? "chaff.yaml"}: ${customProblemSentence(problem, ui)}`);