chaffjs 0.19.0 → 0.21.0

package/src/commands/read-document.ts

@@ -2,23 +2,32 @@ import { loadAdapter } from "../adapter-load.ts";
 import { buildDocument, teamRules } from "../document.ts";
 import { profileFor } from "../profile/for-file.ts";
 import { resolveGenre } from "../resolve-genre.ts";
+import type { Config } from "../config/load.ts";
 import type { ProseDocument, StructurePatterns } from "../plugin.ts";
 import { readSource, treeLanguage, type TreeContext } from "./tree.ts";
 
 /** One document as lint reads it, and its language package's structure reader. */
 export type ReadDocument = { readonly doc: ProseDocument; readonly language: string; readonly structure: StructurePatterns | undefined };
 
-/**
- * Reads one file as lint does: its language, genre, document profile and the team's rules. `pos` loads the
- * part-of-speech tagger, which costs time, so only a command that reads names asks for it.
- */
+/** One text as lint reads it. `pos` loads the part-of-speech tagger, which costs time, so only a command that reads names asks for it. */
+export const documentFromSource = async (
+  path: string,
+  source: string,
+  choice: { readonly language: string; readonly genre: string },
+  config: Config,
+  pos: boolean,
+): Promise<ReadDocument> => {
+  const adapter = await loadAdapter(choice.language);
+  await adapter.prepare?.({ pos });
+  const doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, choice.language, choice.genre));
+  return { doc, language: choice.language, structure: adapter.structure };
+};
+
+/** Reads one file as lint does: its language, genre, document profile and the team's rules. */
 export const readDocument = async (path: string, argv: readonly string[], context: TreeContext, pos: boolean): Promise<ReadDocument | undefined> => {
   const source = await readSource(path, context);
   if (source === undefined) return undefined;
   const language = treeLanguage(path, source, argv, context);
-  const adapter = await loadAdapter(language);
-  await adapter.prepare?.({ pos });
   const genre = resolveGenre(path, source, context.config, context.flag(argv, "--genre")).genre;
-  const doc = buildDocument(path, source, adapter, teamRules(context.config), profileFor(context.config, path, source, language, genre));
-  return { doc, language, structure: adapter.structure };
+  return documentFromSource(path, source, { language, genre }, context.config, pos);
 };

package/src/commands/suppressions.ts

@@ -5,10 +5,11 @@ import type { UiLanguage } from "../ui.ts";
 /** `chaff suppressions`: what the stets in these files (this folder by default) silence, and the stets whose rule did not run. */
 export const runSuppressions = async (
   targets: readonly string[],
-  inspect: (path: string) => Promise<{ readonly perFile: PerFile }>,
+  inspectRun: (paths: readonly string[]) => Promise<readonly { readonly perFile: PerFile }[]>,
   ui: UiLanguage,
+  include: readonly string[] = [],
 ): Promise<number> => {
-  const inspected = await Promise.all(collectTargets(targets.length > 0 ? targets : ["."]).map(inspect));
+  const inspected = await inspectRun(collectTargets(targets.length > 0 ? targets : ["."], include));
   console.log(
     renderSuppressions(
       inspected.map((file) => file.perFile),

package/src/commands/test.ts

@@ -155,9 +155,9 @@ const notRunNotice = (why: string, what: string, envFile: string | undefined, la
  * 見出しと指摘は文書の言語、締めは文書がそろっていればその言語、混ざっていれば ui の言語。
  */
 export const runTest = async (targets: readonly string[], argv: readonly string[], context: TestContext): Promise<number> => {
-  const paths = collectTargets(targets.length > 0 ? targets : ["."]);
+  const paths = collectTargets(targets.length > 0 ? targets : ["."], context.config.include);
   if (paths.length === 0) {
-    console.error(CLI_TEXT[context.ui].noMarkdown(targets.join(", ")));
+    console.error(CLI_TEXT[context.ui].noMarkdown(targets.join(", "), context.config.include ?? []));
     return 1;
   }
   const { config, resolveGenre, inspect } = context;

package/src/commands/tree.ts

@@ -1,10 +1,10 @@
 import { readDocumentFile } from "../files.ts";
 import { loadAdapter } from "../adapter-load.ts";
-import { applyByPath } from "../config/by-path.ts";
 import { profileFor } from "../profile/for-file.ts";
 import { resolveGenre } from "../resolve-genre.ts";
-import { guessLanguage } from "../detect.ts";
+import { documentLanguage } from "../check-source.ts";
 import { isMarkdownPath } from "../structure/markdown-path.ts";
+import { structureText } from "../document-reading.ts";
 import { buildStructure } from "../structure/of.ts";
 import { toSexp } from "../structure/sexp.ts";
 import { foldPostOrder } from "../tree-walk.ts";
@@ -63,13 +63,20 @@ export const readSource = async (path: string, context: TreeContext): Promise<st
  * その前に --language を置く。混在するリポジトリで、英語の契約書を日本語として読まないため。
  */
 export const treeLanguage = (path: string, source: string, argv: readonly string[], context: TreeContext): string =>
-  context.flag(argv, "--language") ??
-  applyByPath(context.config.byPath, context.config.baseDir, path).language ??
-  context.config.language ??
-  guessLanguage(source).language;
+  context.flag(argv, "--language") ?? documentLanguage(path, source, context.config);
 
 export type SourceTree = { readonly source: string; readonly tree: StructureNode };
 
+/** A text's tree of addresses, read as `chaff tree` reads a file; undefined when the language package cannot read structure. */
+export const treeFromSource = async (path: string, source: string, language: string, genre: string, config: Config): Promise<StructureNode | undefined> => {
+  const adapter = await loadAdapter(language);
+  if (adapter.structure === undefined) return undefined;
+  // 日本語は形態素で数量と日付を読む。解析器が無ければ単位の表で読むので、木は作れる。
+  await adapter.prepare?.({ pos: true });
+  const profile = profileFor(config, path, source, language, genre);
+  return buildStructure({ path, source, language, markdown: isMarkdownPath(path), profile, lexicons: adapter.lexicons }, adapter.structure);
+};
+
 /**
  * 1 ファイルを読んで木にする。読めない・言語パッケージが構造を読めないときは、黙らずに言って undefined を返す。
  * chaff tree と chaff cite が同じ木を見るように、ここを一つにしておく。
@@ -78,15 +85,15 @@ export const readTree = async (path: string, argv: readonly string[], context: T
   const source = await readSource(path, context);
   if (source === undefined) return undefined;
   const language = treeLanguage(path, source, argv, context);
-  const adapter = await loadAdapter(language);
-  if (adapter.structure === undefined) {
+  const genre = resolveGenre(path, source, context.config, context.flag(argv, "--genre")).genre;
+  // A YAML file's tree is read from its values alone, as a check reads it.
+  const text = structureText(path, source);
+  const tree = await treeFromSource(path, text, language, genre, context.config);
+  if (tree === undefined) {
     console.error(treeText(context).noStructure(path, language));
     return undefined;
   }
-  // 日本語は形態素で数量と日付を読む。解析器が無ければ単位の表で読むので、木は作れる。
-  await adapter.prepare?.({ pos: true });
-  const profile = profileFor(context.config, path, source, language, resolveGenre(path, source, context.config, context.flag(argv, "--genre")).genre);
-  return { source, tree: buildStructure({ path, source, language, markdown: isMarkdownPath(path), profile, lexicons: adapter.lexicons }, adapter.structure) };
+  return { source: text, tree };
 };
 
 /**

package/src/compare/distinct.ts

@@ -1,6 +1,13 @@
 import type { Atom } from "./atom.ts";
 import { identity } from "./match.ts";
 
+/**
+ * What makes two facts the same when only whether a fact is stated counts. A Markdown heading's key is only its level,
+ * so the level alone would let any heading at that level stand for a cut one; its wording is part of it here, as it is
+ * when facts are counted, where headings first pair by wording.
+ */
+const statedIdentity = (atom: Atom): string => (atom.kind === "heading" ? `${identity(atom)}\u0000${atom.text}` : identity(atom));
+
 /**
  * The changes left when facts are compared as sets (--distinct): a fact the other document states at least once is
  * kept, however many times either states it. A summary that repeated the body can be cut without its repeats reading
@@ -8,6 +15,6 @@ import { identity } from "./match.ts";
  * names are counted.
  */
 export const unstatedChanges = (changes: readonly Atom[], other: readonly Atom[], otherNameText: string): Atom[] => {
-  const stated = new Set(other.map(identity));
-  return changes.filter((atom) => !stated.has(identity(atom)) && !(atom.kind === "name" && otherNameText.includes(atom.key)));
+  const stated = new Set(other.map(statedIdentity));
+  return changes.filter((atom) => !stated.has(statedIdentity(atom)) && !(atom.kind === "name" && otherNameText.includes(atom.key)));
 };

package/src/compare/proper-nouns.ts

@@ -54,12 +54,16 @@ export const readsProperNouns = (doc: ProseDocument): boolean => doc.sentences.l
  */
 export const properNouns = (input: NounInput): Atom[] => {
   const { source } = input.doc;
-  const lowerCase = lowerCaseWords(source);
-  return input.doc.sentences.flatMap((sentence) =>
-    runsOf(sentence.tokens ?? [], source).flatMap((run): Atom[] => {
-      const text = source.slice(run.start, run.end);
-      if (overlapsAny(input.taken, run) || isCommonWord(run, text, lowerCase)) return [];
-      return [{ kind: "name", key: factKey(source, run, input.unseen), text, line: input.lineOf(run.start) }];
-    }),
+  return nameSpans(input.doc).flatMap((run): Atom[] => {
+    if (overlapsAny(input.taken, run)) return [];
+    return [{ kind: "name", key: factKey(source, run, input.unseen), text: source.slice(run.start, run.end), line: input.lineOf(run.start) }];
+  });
+};
+
+/** Where the tagger's proper nouns are written, each run of them one name, without the common words that began a sentence. */
+export const nameSpans = (doc: ProseDocument): Span[] => {
+  const lowerCase = lowerCaseWords(doc.source);
+  return doc.sentences.flatMap((sentence) =>
+    runsOf(sentence.tokens ?? [], doc.source).filter((run) => !isCommonWord(run, doc.source.slice(run.start, run.end), lowerCase)),
   );
 };

package/src/config/load.ts

@@ -1,6 +1,5 @@
-import { readFileSync } from "node:fs";
 import { dirname } from "node:path";
-import { parse } from "yaml";
+import { readYamlFile } from "./yaml-file.ts";
 import { isLevel } from "../levels.ts";
 import { defaultModel } from "../judge.ts";
 import { isBackend, type BackendName } from "../backends/types.ts";
@@ -36,6 +35,8 @@ export type Config = {
   readonly names: readonly string[];
   /** names に書かれていたが名前として読めなかった値。黙って捨てると、並べたつもりの名前が効いていないことに気づけない。 */
   readonly unreadableNames: readonly string[];
+  /** File-name globs (*.yaml) a directory walk checks besides Markdown. --include adds to them. */
+  readonly include?: readonly string[];
   /** パスごとの上書き。設定ファイルのある場所からの相対で照合する。 */
   readonly byPath: readonly PathRule[];
   readonly baseDir: string;
@@ -49,6 +50,10 @@ export type Config = {
   readonly applied?: AppliedStyle | undefined;
   /** custom_rules as written: the team's own rules. custom/parse.ts reads and checks them. */
   readonly customRules?: unknown;
+  /** grade as written: the rubric `chaff grade` reads (grade/rubric.ts). */
+  readonly grade?: unknown;
+  /** fix_plan as written: the depth chaff fix-plan rewrites to (fix-plan/chosen-depth.ts reads and checks it). */
+  readonly fixPlan?: unknown;
   /** plugins as written: package names and paths. extension/plugin-load.ts reads and checks them. */
   readonly plugins?: unknown;
   /** The code chaff.yaml names, once loaded (extension/load.ts). Reading chaff.yaml does not load it. */
@@ -163,7 +168,7 @@ const byPathOf = (raw: unknown): PathRule[] => (Array.isArray(raw) ? raw.map(toP
 
 /** 設定ファイルが無くても動く。あっても、既定から変えたものだけが書かれている。spec §18。 */
 export const loadConfig = (path: string): Config => {
-  const raw: unknown = parse(readFileSync(path, "utf8"));
+  const raw: unknown = readYamlFile(path);
   if (!isRecord(raw)) return { ...EMPTY, path };
   const declared: unknown = raw["ai_backend"];
   const backend: BackendName = isBackend(declared) ? declared : DEFAULT_BACKEND;
@@ -186,12 +191,15 @@ export const loadConfig = (path: string): Config => {
     requiredSections: wordsOf(raw["required_sections"]),
     names: names.names,
     unreadableNames: names.unreadable,
+    include: globsOf(raw["include"]),
     byPath: byPathOf(raw["by_path"]),
     baseDir: dirname(path),
     options: isRecord(options) ? options : {},
     unreadableOptions: options === undefined || options === null || isRecord(options) ? undefined : printed(options),
     style: raw["style"] === undefined || raw["style"] === null ? undefined : (str(raw["style"]) ?? printed(raw["style"])),
     customRules: raw["custom_rules"],
+    grade: raw["grade"],
+    fixPlan: raw["fix_plan"],
     plugins: raw["plugins"],
   };
 };

package/src/config/option-problems.ts

@@ -36,7 +36,7 @@ const TEXT: Texts<ProblemText> = {
   ja: {
     notAMap: (where, value) => `${where}: options の ${value} は読めません。ルールの名前の下に、オプションの名前と値を並べてください`,
     problem: (where, problem) => {
-      if (problem.kind === "unknown-rule") return `${where}: options の ${problem.rule} というルールはありません（npx chaff rules --json で一覧が出ます）`;
+      if (problem.kind === "unknown-rule") return `${where}: options の ${problem.rule} というルールはありません（npx chaffjs rules --json で一覧が出ます）`;
       if (problem.kind === "no-options") return `${where}: ${problem.rule} にはオプションがありません。options に書いても何も変わりません`;
       if (problem.kind === "not-a-map") return `${where}: options の ${problem.rule} の下には、オプションの名前と値を並べてください`;
       if (problem.kind === "unknown-option")
@@ -47,7 +47,7 @@ const TEXT: Texts<ProblemText> = {
   en: {
     notAMap: (where, value) => `${where}: cannot read ${value} under options. Under each rule's name, list option names and values`,
     problem: (where, problem) => {
-      if (problem.kind === "unknown-rule") return `${where}: there is no rule named ${problem.rule} under options (npx chaff rules --json lists them)`;
+      if (problem.kind === "unknown-rule") return `${where}: there is no rule named ${problem.rule} under options (npx chaffjs rules --json lists them)`;
       if (problem.kind === "no-options") return `${where}: ${problem.rule} takes no options, so writing some changes nothing`;
       if (problem.kind === "not-a-map") return `${where}: under options, ${problem.rule} needs option names and values`;
       if (problem.kind === "unknown-option") return `${where}: ${problem.rule} has no option ${problem.option} (it takes ${problem.known.join(" / ")})`;

package/src/config/rule-problems.ts

@@ -9,7 +9,7 @@ const TEXT: Texts<{
   readonly numberOnSeverity: (where: string, id: string) => string;
 }> = {
   ja: {
-    unknown: (where, id) => `${where}: ${id} というルールはありません（npx chaff rules --json で一覧が出ます）`,
+    unknown: (where, id) => `${where}: ${id} というルールはありません（npx chaffjs rules --json で一覧が出ます）`,
     unreadable: (where, id, value) => `${where}: ${id} の値 ${value} は読めません（strict / normal / relaxed / off か、正の数）`,
     numberOnSemantic: (where, id) =>
       `${where}: ${id} は意味を読む検査なので数値の上限はありません。normal として動きます（strict / normal / relaxed / off で書いてください）`,
@@ -17,7 +17,7 @@ const TEXT: Texts<{
       `${where}: ${id} には数の上限がありません。normal として動きます（段階は指摘の重さを変えます。relaxed で一段軽く、off で止まります）`,
   },
   en: {
-    unknown: (where, id) => `${where}: there is no rule named ${id} (npx chaff rules --json lists them)`,
+    unknown: (where, id) => `${where}: there is no rule named ${id} (npx chaffjs rules --json lists them)`,
     unreadable: (where, id, value) => `${where}: cannot read ${value} as the level of ${id} (strict / normal / relaxed / off, or a positive number)`,
     numberOnSemantic: (where, id) => `${where}: ${id} reads meaning and has no numeric limit; it runs as normal (write strict / normal / relaxed / off)`,
     numberOnSeverity: (where, id) =>

package/src/config/yaml-file.ts

@@ -0,0 +1,65 @@
+import { readFileSync } from "node:fs";
+import { parse, YAMLParseError } from "yaml";
+import { relative } from "node:path";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+/** Where a settings file stops being YAML: 1-based line and column, and the parser's own sentence without its position. */
+export type YamlSyntax = { readonly line: number; readonly column: number; readonly detail: string };
+
+/** The parser appends " at line 3, column 1:" and, on the lines below, a picture of the line; chaff says the position itself. */
+const POSITION_TAIL = / at line \d+, column \d+:?$/u;
+
+/** A YAML syntax error as a position and a sentence, or undefined for anything else (a missing file is not a syntax error). */
+export const yamlSyntaxOf = (error: unknown): YamlSyntax | undefined => {
+  if (!(error instanceof YAMLParseError)) return undefined;
+  const start = error.linePos?.[0];
+  return {
+    line: start?.line ?? 1,
+    column: start?.col ?? 1,
+    detail: (error.message.split("\n")[0] ?? "").replace(POSITION_TAIL, "").trim(),
+  };
+};
+
+/** A settings file the person wrote that is not YAML. The command line says where and stops; no stack trace. */
+export class YamlFileError extends Error {
+  readonly path: string;
+  readonly syntax: YamlSyntax;
+
+  constructor(path: string, syntax: YamlSyntax, cause: unknown) {
+    super(`${path}:${syntax.line}:${syntax.column}: ${syntax.detail}`, { cause });
+    this.name = "YamlFileError";
+    this.path = path;
+    this.syntax = syntax;
+  }
+}
+
+/** A settings file read as YAML. A syntax error becomes a YamlFileError naming the file; other failures pass through. */
+export const readYamlFile = (path: string): unknown => {
+  const text = readFileSync(path, "utf8");
+  try {
+    return parse(text);
+  } catch (error) {
+    const syntax = yamlSyntaxOf(error);
+    if (syntax === undefined) throw error;
+    throw new YamlFileError(path, syntax, error);
+  }
+};
+
+const TEXT: Texts<(path: string, syntax: YamlSyntax) => string> = {
+  ja: (path, { line, column, detail }) => `chaff: ${path} の ${line} 行目 ${column} 桁目が YAML として読めません: ${detail}`,
+  en: (path, { line, column, detail }) => `chaff: ${path}, line ${line}, column ${column}, is not valid YAML: ${detail}`,
+};
+
+/** The sentence the command line prints for a settings file that is not YAML. path: as the person would type it. */
+export const yamlFileProblem = (path: string, syntax: YamlSyntax, ui: UiLanguage): string => TEXT[ui](path, syntax);
+
+/** Runs a command, and turns a settings file that is not YAML into its sentence and exit code 1. cwd: what the path is printed relative to. */
+export const stoppingOnYamlFileError = async (run: () => Promise<number>, cwd: string, ui: UiLanguage): Promise<number> => {
+  try {
+    return await run();
+  } catch (error) {
+    if (!(error instanceof YamlFileError)) throw error;
+    console.error(yamlFileProblem(relative(cwd, error.path) || error.path, error.syntax, ui));
+    return 1;
+  }
+};

package/src/correction-edit.ts

@@ -0,0 +1,43 @@
+// 誤った形と正しい形の組から、書いた語のどこをどう直すかを決める。純粋な関数だけを置く。
+
+/** wrong の上の [start, end) を replacement にすると right になる。前後の同じ字は含めない。 */
+export type Edit = { readonly start: number; readonly end: number; readonly replacement: string };
+
+const commonPrefix = (left: string, right: string): number => {
+  const limit = Math.min(left.length, right.length);
+  const differs = [...Array(limit).keys()].find((at) => left[at] !== right[at]);
+  return differs ?? limit;
+};
+
+/** 二つの形の違う所。前の同じ字を先に除き、残りから後ろの同じ字を除く（「ですす」と「です」は、後ろの「す」を足した所）。 */
+export const editBetween = (wrong: string, right: string): Edit => {
+  const start = commonPrefix(wrong, right);
+  const tail = commonPrefix(Array.from(wrong.slice(start)).reverse().join(""), Array.from(right.slice(start)).reverse().join(""));
+  return { start, end: wrong.length - tail, replacement: right.slice(start, right.length - tail) };
+};
+
+/** 指す字と、そこに入る正しい形。指す字は、書いた字の頭から。 */
+export type Correction = { readonly matched: string; readonly suggestion: string };
+
+const capitalised = (word: string): string => `${word.charAt(0).toUpperCase()}${word.slice(1)}`;
+
+const isAllCapitals = (word: string): boolean => /\p{Lu}.*\p{Lu}/u.test(word) && !/\p{Ll}/u.test(word);
+
+/** 書いた語の大文字に合わせる（文頭の "Teh" には "The"、"TEH" には "THE"）。 */
+const casedLike = (written: string, suggestion: string): string => {
+  if (isAllCapitals(written)) return suggestion.toUpperCase();
+  return /^\p{Lu}/u.test(written) && /^\p{Ll}/u.test(suggestion) ? capitalised(suggestion) : suggestion;
+};
+
+/**
+ * 書いた字（written）に、語彙表の組の違い（edit）を当てる。boundaries は written の中の語の終わりの位置で、written.length を含む。
+ * 指すのは written の頭から、違う所を含む語の終わりまで。後ろに続く前後の語は言わない（「以外と簡単」は「以外」を「意外」に、
+ * 活用した「始めて会った」は「始めて」を「初めて」に）。written の頭が誤った形の違う所まで同じでなければ（活用で字が変わった）undefined。
+ */
+export const correctionIn = (written: string, wrong: string, edit: Edit, boundaries: readonly number[]): Correction | undefined => {
+  if (written.slice(0, edit.end).toLowerCase() !== wrong.slice(0, edit.end).toLowerCase()) return undefined;
+  const end = Math.min(written.length, ...boundaries.filter((at) => at >= edit.end));
+  const matched = written.slice(0, end);
+  const suggestion = `${matched.slice(0, edit.start)}${edit.replacement}${matched.slice(edit.end)}`;
+  return { matched, suggestion: casedLike(matched, suggestion) };
+};

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/checked.ts

@@ -0,0 +1,8 @@
+import type { CustomProblem } from "./parse.ts";
+
+/** One field of one rule, read: its value when it can be used, and what is wrong with it otherwise. */
+export type Checked<T> = { readonly value: T | undefined; readonly problems: readonly CustomProblem[] };
+
+export const ok = <T>(value: T): Checked<T> => ({ value, problems: [] });
+
+export const failed = <T>(...problems: CustomProblem[]): Checked<T> => ({ value: undefined, problems });