chaffjs 0.25.0 → 0.26.0

package/src/config/load.ts

@@ -1,7 +1,7 @@
 import { dirname } from "node:path";
-import { readYamlFile } from "./yaml-file.ts";
+import { workingDir } from "./working-dir.ts";
 import { isLevel } from "../levels.ts";
-import { defaultModel } from "../judge.ts";
+import { defaultModel } from "../backends/default-model.ts";
 import { isBackend, type BackendName } from "../backends/types.ts";
 import type { Level } from "../plugin.ts";
 import type { PathRule } from "./by-path.ts";
@@ -40,6 +40,8 @@ export type Config = {
   readonly include?: readonly string[];
   /** パスごとの上書き。設定ファイルのある場所からの相対で照合する。 */
   readonly byPath: readonly PathRule[];
+  /** by_path entries that could not be read (a map instead of a list, an entry without files), as written. */
+  readonly unreadableByPath?: readonly string[];
   readonly baseDir: string;
   /** Options set on rules that take them: { rule id: { option: value } }, as written. rule-options.ts checks them against the rules. */
   readonly options?: Readonly<Record<string, unknown>>;
@@ -95,7 +97,7 @@ export const EMPTY: Config = {
   names: [],
   unreadableNames: [],
   byPath: [],
-  baseDir: process.cwd(),
+  baseDir: workingDir(),
 };
 
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -169,15 +171,25 @@ const namesOf = (raw: unknown): { readonly names: string[]; readonly unreadable:
   };
 };
 
-const byPathOf = (raw: unknown): PathRule[] => (Array.isArray(raw) ? raw.map(toPathRule).filter((rule) => rule !== undefined) : []);
+/** by_path は files を持つ項目の並び。並びでない値と、読めない項目は読めないものとして返す。黙って捨てると、書いた人は効いたつもりでいる。 */
+export const byPathOf = (raw: unknown): { readonly rules: PathRule[]; readonly unreadable: string[] } => {
+  if (raw === undefined || raw === null) return { rules: [], unreadable: [] };
+  if (!Array.isArray(raw)) return { rules: [], unreadable: [printed(raw)] };
+  const entries: unknown[] = raw;
+  const read = entries.map((entry) => ({ entry, rule: toPathRule(entry) }));
+  return {
+    rules: read.flatMap(({ rule }) => (rule === undefined ? [] : [rule])),
+    unreadable: read.filter(({ rule }) => rule === undefined).map(({ entry }) => printed(entry)),
+  };
+};
 
-/** 設定ファイルが無くても動く。あっても、既定から変えたものだけが書かれている。spec §18。 */
-export const loadConfig = (path: string): Config => {
-  const raw: unknown = readYamlFile(path);
+/** 読んだ chaff.yaml の中身（raw）を設定にする。ファイルは読まない。path は raw を読んだ場所。 */
+export const configOf = (raw: unknown, path: string): Config => {
   if (!isRecord(raw)) return { ...EMPTY, path };
   const declared: unknown = raw["ai_backend"];
   const backend: BackendName = isBackend(declared) ? declared : DEFAULT_BACKEND;
   const names = namesOf(raw["names"]);
+  const byPath = byPathOf(raw["by_path"]);
   const options: unknown = raw["options"];
   return {
     genre: str(raw["genre"]),
@@ -197,7 +209,8 @@ export const loadConfig = (path: string): Config => {
     names: names.names,
     unreadableNames: names.unreadable,
     include: globsOf(raw["include"]),
-    byPath: byPathOf(raw["by_path"]),
+    byPath: byPath.rules,
+    unreadableByPath: byPath.unreadable,
     baseDir: dirname(path),
     options: isRecord(options) ? options : {},
     unreadableOptions: options === undefined || options === null || isRecord(options) ? undefined : printed(options),

package/src/config/read.ts

@@ -1,8 +1,12 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { CONFIG_FILE, EMPTY, loadConfig, type Config } from "./load.ts";
+import { CONFIG_FILE, EMPTY, configOf, type Config } from "./load.ts";
 import { withStyle } from "./style.ts";
+import { readYamlFile } from "./yaml-file.ts";
 import { loadStyles } from "../style-load.ts";
 
+/** 設定ファイルが無くても動く。あっても、既定から変えたものだけが書かれている。spec §18。 */
+export const loadConfig = (path: string): Config => configOf(readYamlFile(path), path);
+
 /** The chaff.yaml in dir with its style applied, or the defaults when there is none. */
 export const readConfigIn = (dir: string): Config => (existsSync(join(dir, CONFIG_FILE)) ? withStyle(loadConfig(join(dir, CONFIG_FILE)), loadStyles()) : EMPTY);

package/src/config/warnings.ts

@@ -3,13 +3,15 @@ import type { RuleDefinition } from "../plugin.ts";
 import type { UiLanguage } from "../ui.ts";
 import { ruleProblems } from "./rule-problems.ts";
 import { nameProblems } from "./name-problems.ts";
+import { byPathProblems } from "./by-path-problems.ts";
 import { configOptionProblems } from "./option-problems.ts";
 import { configGuideProblems } from "../genre-guide/of-config.ts";
 
-/** Everything in chaff.yaml that has no effect: unknown rules or levels, unreadable names, options that do not apply, guides that cannot be read. Said before the results. */
+/** Everything in chaff.yaml that has no effect: unknown rules or levels, unreadable names or by_path entries, options that do not apply, guides that cannot be read. Said before the results. */
 export const settingWarnings = (config: Config, rules: readonly RuleDefinition[], ui: UiLanguage): string[] => [
   ...ruleProblems(config, rules, ui),
   ...nameProblems(config, ui),
+  ...byPathProblems(config, ui),
   ...configOptionProblems(config, rules, ui),
   ...configGuideProblems(config, ui),
 ];

package/src/config/working-dir.ts

@@ -0,0 +1,3 @@
+// The folder chaff runs in, where a run without chaff.yaml resolves paths. A build without a process puts its own module in this one's place.
+
+export const workingDir = (): string => process.cwd();

package/src/custom/bounded-match.ts

@@ -1,25 +1,10 @@
 import { createContext, Script } from "node:vm";
+import { PATTERN_BUDGET_MS, PatternTimeout, type TextMatches } from "./pattern-timeout.ts";
 
 // A team's regular expression, run with a time limit. regex-safety.ts refuses the shapes known to run away before a pattern
 // is used; no reading of the pattern can prove every shape safe, so this is the backstop. V8 can interrupt a regular
 // expression only through vm's timeout, so the matching runs in a vm context.
 
-/** How long one rule's pattern may take over one document. Far above what a sane pattern needs on any real document. */
-export const PATTERN_BUDGET_MS = 1000;
-
-/** A pattern that did not finish within its budget. run.ts lists the rule as not run, with this as the reason. */
-export class PatternTimeout extends Error {
-  readonly budget_ms: number;
-  constructor(budgetMs: number) {
-    super(`the pattern did not finish within ${String(budgetMs)} ms`);
-    this.name = "PatternTimeout";
-    this.budget_ms = budgetMs;
-  }
-}
-
-/** Each text's matches: where it starts and what it matched. Empty matches are left out. */
-export type TextMatches = readonly (readonly { readonly index: number; readonly text: string }[])[];
-
 const SCRIPT = new Script(
   `texts.map((text) => [...text.matchAll(new RegExp(source, flags))].filter((m) => m[0] !== "").map((m) => ({ index: m.index, text: m[0] })))`,
 );

package/src/custom/pattern-timeout.ts

@@ -0,0 +1,17 @@
+// What a team's pattern may take, and what it is when it takes longer: the same wherever the pattern runs.
+
+/** How long one rule's pattern may take over one document. Far above what a sane pattern needs on any real document. */
+export const PATTERN_BUDGET_MS = 1000;
+
+/** A pattern that did not finish within its budget. run.ts lists the rule as not run, with this as the reason. */
+export class PatternTimeout extends Error {
+  readonly budget_ms: number;
+  constructor(budgetMs: number) {
+    super(`the pattern did not finish within ${String(budgetMs)} ms`);
+    this.name = "PatternTimeout";
+    this.budget_ms = budgetMs;
+  }
+}
+
+/** Each text's matches: where it starts and what it matched. Empty matches are left out. */
+export type TextMatches = readonly (readonly { readonly index: number; readonly text: string }[])[];

package/src/detect.ts

@@ -1,11 +1,10 @@
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import { parse } from "yaml";
 import { japaneseRatio, latinRatio } from "./detect-language.ts";
 import { referenceListSpans } from "./reference-lists.ts";
 import { withoutSpans } from "./soft-break.ts";
 import { languageSample } from "./language-sample.ts";
+import { PACKAGE_DIR, readText } from "./package-files.ts";
 
 export type LanguageGuess = { readonly language: string; readonly confidence: number; readonly from: string };
 
@@ -15,12 +14,12 @@ export type LanguageGuess = { readonly language: string; readonly confidence: nu
  */
 const JAPANESE_FLOOR = 0.15;
 
-const HEADINGS_FILE = join(dirname(fileURLToPath(import.meta.url)), "..", "reference-headings.yaml");
+const HEADINGS_FILE = join(PACKAGE_DIR, "reference-headings.yaml");
 
 const isStringList = (value: unknown): value is string[] => Array.isArray(value) && value.every((entry) => typeof entry === "string");
 
 const readHeadings = (): string[] => {
-  const raw: unknown = parse(readFileSync(HEADINGS_FILE, "utf8"));
+  const raw: unknown = parse(readText(HEADINGS_FILE));
   const headings: unknown = typeof raw === "object" && raw !== null && "headings" in raw ? raw.headings : undefined;
   if (!isStringList(headings)) throw new Error(`${HEADINGS_FILE}: headings は文字列の並びであること`);
   return headings;

package/src/detectors/date-year.ts

@@ -1,6 +1,6 @@
 // A date written without its year where the document's other dates carry one, or where the year cannot be read off
 // because the document's dates cross the turn of a year. Pure; reads the date nodes of the structure tree.
-import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument, StructureNode } from "../plugin.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
 import { quoteAt } from "./structure-tree.ts";
 
@@ -9,11 +9,19 @@ export type DatePoint = { readonly offset: number; readonly end: number; readonl
 
 export type YearGap = { readonly point: DatePoint; readonly kind: "minority" | "boundary"; readonly dated: number };
 
-/** The words just before a date that give its year in words (その年の, 同年, 毎年): the date has a year, or means every year. */
+/**
+ * The words beside a date that give its year in words (その年の, 同年, 毎年; "of each year"): the date has a year, or means
+ * every year. An entry stands before the date unless it says `position: after`.
+ */
 export const YEAR_REFERENCE_LEXICON = "year-reference";
 
+/** A year word as the lexicon gives it. `before`: the word ends within the reach before the date ("annually, by"). */
+export type YearWord = { readonly word: string; readonly position?: "before" | "after" | undefined };
+
 const FULL = /^\d{4}-(\d{2})-\d{2}$/u;
 const MONTH_DAY = /^(\d{2})-\d{2}$/u;
+/** The month of any date with one: 2026-12-01, 2026-12 or 12-01. */
+const ANY_MONTH = /^(?:\d{4}-(\d{2})(?:-\d{2})?|(\d{2})-\d{2})$/u;
 
 /** How far before a date a year word may stand (「同年12月」「その年の12月」). */
 const YEAR_WORD_REACH = 6;
@@ -33,24 +41,53 @@ const sideOf = (month: number | undefined): "end" | "start" | undefined => {
   return YEAR_START.has(month) ? "start" : undefined;
 };
 
-/** A yearless date at one turn of the year while a dated one sits at the other: 1月15日 beside 2026年12月1日. */
-const crossesYear = (point: DatePoint, datedSides: ReadonlySet<string>): boolean => {
+const anyMonthOf = (value: string): number | undefined => {
+  const found = ANY_MONTH.exec(value);
+  const month = found?.[1] ?? found?.[2];
+  return month === undefined ? undefined : Number(month);
+};
+
+const opposite = (side: "end" | "start"): "end" | "start" => (side === "end" ? "start" : "end");
+
+/**
+ * A yearless date where the dates turn over the year: it sits at one turn, the date just before it at the other
+ * (12月10日 then 1月15日), and a dated one sits at that other turn too (2026年12月1日). A 2月15日 far from any 12月 is a
+ * day of the year, not a crossing.
+ */
+const crossesYear = (point: DatePoint, previous: DatePoint | undefined, datedSides: ReadonlySet<string>): boolean => {
   const side = sideOf(monthOf(MONTH_DAY, point.value));
-  return side !== undefined && datedSides.has(side === "end" ? "start" : "end");
+  if (side === undefined || !datedSides.has(opposite(side))) return false;
+  return previous !== undefined && sideOf(anyMonthOf(previous.value)) === opposite(side);
 };
 
 const lineStart = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
 
-const hasYearWord = (point: DatePoint, source: string, yearWords: readonly string[]): boolean => {
-  const before = source.slice(Math.max(lineStart(source, point.offset), point.offset - YEAR_WORD_REACH), point.offset);
-  return yearWords.some((word) => word !== "" && before.includes(word));
+const lineEnd = (source: string, offset: number): number => {
+  const end = source.indexOf("\n", offset);
+  return end === -1 ? source.length : end;
+};
+
+/**
+ * A word without a position is found anywhere in the reach before the date (「同年12月」). One that says `before` may end
+ * there and start further back ("annually, by June 30"); one that says `after` starts within the reach after the date
+ * ("June 30 of each year").
+ */
+const hasYearWord = (point: DatePoint, source: string, yearWords: readonly YearWord[]): boolean => {
+  const start = lineStart(source, point.offset);
+  const near = source.slice(Math.max(start, point.offset - YEAR_WORD_REACH), point.offset);
+  return yearWords.some(({ word, position }) => {
+    if (word === "") return false;
+    if (position === "after") return source.slice(point.end, Math.min(lineEnd(source, point.end), point.end + YEAR_WORD_REACH + word.length)).includes(word);
+    if (position === "before") return source.slice(Math.max(start, point.offset - YEAR_WORD_REACH - word.length), point.offset).includes(word);
+    return near.includes(word);
+  });
 };
 
 /**
  * A yearless date whose year the text gives anyway: a year word just before it (「同年12月28日」「その年の12月31日」), or,
  * earlier on the same line, a date with a year or with a year word (「2026年9月25日から10月7日まで」「その年の1月1日から12月31日まで」).
  */
-const yearGiven = (point: DatePoint, anchors: readonly DatePoint[], source: string, yearWords: readonly string[]): boolean => {
+const yearGiven = (point: DatePoint, anchors: readonly DatePoint[], source: string, yearWords: readonly YearWord[]): boolean => {
   const start = lineStart(source, point.offset);
   return hasYearWord(point, source, yearWords) || anchors.some((other) => other.offset >= start && other.offset < point.offset);
 };
@@ -60,22 +97,24 @@ const yearGiven = (point: DatePoint, anchors: readonly DatePoint[], source: stri
  * one is the odd one out. Otherwise writing the year once is the document's style, and only a date across the turn of a
  * year is reported. A date whose year the text gives in words or earlier on its line is never reported, nor counted.
  */
-export const yearGaps = (points: readonly DatePoint[], source = "", yearWords: readonly string[] = []): YearGap[] => {
+export const yearGaps = (points: readonly DatePoint[], source = "", yearWords: readonly YearWord[] = []): YearGap[] => {
   const dated = points.filter((point) => FULL.test(point.value));
   const anchors = [...dated, ...points.filter((point) => hasYearWord(point, source, yearWords))];
   const yearless = points.filter((point) => MONTH_DAY.test(point.value) && !yearGiven(point, anchors, source, yearWords));
   const minority = dated.length >= 2 && yearless.length < dated.length;
   const datedSides = new Set(dated.flatMap((point) => sideOf(monthOf(FULL, point.value)) ?? []));
+  const previousOf = new Map(points.map((point, index) => [point, points[index - 1]]));
   return yearless.flatMap((point): YearGap[] => {
     if (minority) return [{ point, kind: "minority", dated: dated.length }];
-    return crossesYear(point, datedSides) ? [{ point, kind: "boundary", dated: dated.length }] : [];
+    return crossesYear(point, previousOf.get(point), datedSides) ? [{ point, kind: "boundary", dated: dated.length }] : [];
   });
 };
 
 export const datePoints = (tree: StructureNode): DatePoint[] =>
   inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
 
-const yearWordsOf = (doc: ProseDocument): string[] => (doc.lexicons[YEAR_REFERENCE_LEXICON] ?? []).map((entry) => entry.pattern);
+const yearWordsOf = (doc: ProseDocument): YearWord[] =>
+  (doc.lexicons[YEAR_REFERENCE_LEXICON] ?? []).map((entry: LexiconEntry) => ({ word: entry.pattern, position: entry.position }));
 
 export const dateWithoutYear: Detector = (doc: ProseDocument): Finding[] =>
   doc.structure === undefined

package/src/detectors/defined-term-form.ts

@@ -3,6 +3,7 @@
 // name is read from the tokens' parts of speech.
 import { definedTerms, usesOf, type BodyText, type DefinedTerm } from "../structure/definition-use.ts";
 import { escapeRegExp } from "../orthography.ts";
+import { prefixGroupsOf, prefixVariants, variantUses } from "../structure/term-prefix.ts";
 import { quoteAt } from "./structure-tree.ts";
 import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 
@@ -91,10 +92,22 @@ const isVerbAt = (doc: ProseDocument, offset: number): boolean => {
   return VERBAL.has(token.pos) || afterSubject;
 };
 
+/** The term written with another prefix of its group (本件業務 where 本業務 is defined), after the sentence that defines it. */
+const prefixFindings = (doc: ProseDocument, texts: readonly BodyText[], term: DefinedTerm, definingEnd: number, defined: readonly string[]): Finding[] =>
+  prefixVariants(term.term, prefixGroupsOf(doc.lexicons["defined-term-prefix"] ?? [])).flatMap((variant) =>
+    defined.includes(variant)
+      ? []
+      : variantUses(doc.source, texts, variant, definingEnd, defined).map((offset) =>
+          finding(doc, "defined-term-form", offset, "prefix", { term: term.term, written: variant, line: term.line }),
+        ),
+  );
+
 export const definedTermForm: Detector = (doc, options): Finding[] => {
   if (doc.structure === undefined) return [];
   const texts = bodyOf(doc);
-  return firstDefinitions(definedTerms(doc.structure)).flatMap(({ term, spans }) => {
+  const terms = definedTerms(doc.structure);
+  const defined = terms.map((term) => term.term);
+  return firstDefinitions(terms).flatMap(({ term, spans }) => {
     const uses = usesOf(term.term, texts, spans, "loose");
     const definingEnd = definingSentenceEnd(doc, term.span);
     const quoted = quotedUses(doc.source, term.term, uses, definingEnd).map((offset) =>
@@ -104,7 +117,7 @@ export const definedTermForm: Detector = (doc, options): Finding[] => {
     const lower = lowerCaseUses(doc.source, term.term, nounUses, definingEnd, options.limit).map((offset) =>
       finding(doc, "defined-term-form", offset, "case", { term: term.term, line: term.line }),
     );
-    return [...quoted, ...lower];
+    return [...quoted, ...lower, ...prefixFindings(doc, texts, term, definingEnd, defined)];
   });
 };
 
@@ -162,13 +175,21 @@ const isNameLine = (source: string, offset: number, name: string, term: string):
   const end = source.indexOf("\n", offset);
   const line = source.slice(start, end === -1 ? source.length : end).trim();
   const SLACK = 12;
-  return line.includes(term) || [...line].length <= [...name].length + SLACK;
+  // The short name inside the long one ("Pinecone" in "Pinecone Software Ltd") is not the short name written beside it.
+  return line.replaceAll(name, "").includes(term) || [...line].length <= [...name].length + SLACK;
 };
 
 /** A name inside a longer word (東京大学 in 東京大学大学院, Acme in Acmeware) is part of another name. */
 const WORD_CHAR = /[\p{Script=Han}\p{Script=Katakana}\p{Script=Latin}\p{N}ー]/u;
-const standsAlone = (source: string, offset: number, name: string): boolean =>
-  !WORD_CHAR.test(source.charAt(offset - 1)) && !WORD_CHAR.test(source.charAt(offset + name.length));
+/**
+ * A name inside a longer word (東京大学 in 東京大学大学院, Acme in Acmeware) is part of another name. A joining word right after
+ * it (北浜精機株式会社及び乙) starts the next item of a list, and the name stands alone.
+ */
+export const standsAlone = (source: string, offset: number, name: string, joiners: readonly string[] = []): boolean => {
+  const after = offset + name.length;
+  const joined = joiners.some((joiner) => joiner !== "" && source.startsWith(joiner, after));
+  return !WORD_CHAR.test(source.charAt(offset - 1)) && (joined || !WORD_CHAR.test(source.charAt(after)));
+};
 
 /**
  * Each use of a long name after the definition gave it a short name, outside a signature line. A name that is itself a
@@ -176,6 +197,7 @@ const standsAlone = (source: string, offset: number, name: string): boolean =>
  */
 export const repeatedNames = (doc: ProseDocument, terms: readonly DefinedTerm[]): RepeatedName[] => {
   const defined = new Set(terms.map((term) => term.term));
+  const joiners = (doc.lexicons["enumeration-joiner"] ?? []).map((entry) => entry.pattern);
   return terms
     .filter((term) => term.inline)
     .flatMap((term) => {
@@ -187,7 +209,7 @@ export const repeatedNames = (doc: ProseDocument, terms: readonly DefinedTerm[])
       return doc.sentences
         .filter((later) => later.span.start > term.span.end)
         .flatMap((later) => [...later.text.matchAll(pattern)].map((match) => later.span.start + match.index))
-        .filter((offset) => standsAlone(doc.source, offset, name) && !isNameLine(doc.source, offset, name, term.term))
+        .filter((offset) => standsAlone(doc.source, offset, name, joiners) && !isNameLine(doc.source, offset, name, term.term))
         .map((offset) => ({ offset, name, term: term.term, line: term.line }));
     });
 };

package/src/detectors/orthographic-variant.ts

@@ -4,6 +4,7 @@ import { kanjiSkeleton, katakanaKey, lemmaReading } from "../kana-spelling.ts";
 import { isKatakanaWord, stemOf } from "../long-vowel.ts";
 import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { nameSpans, touchesAny } from "../team-names.ts";
+import { furiganaSpans } from "../furigana.ts";
 
 /** A word found in the document: where it is, which sentence it is in, its key and spelling, and how it is written when that differs. */
 type Placed = KeyedWord & { readonly sentence: Sentence; readonly offset: number; readonly shown?: string };
@@ -22,42 +23,82 @@ const MIN_LATIN_KEY = 3;
 /** Lexicons: readings and spellings whose kanji and kana forms mean different things (成る and なる, 者 and もの), and adverbs hiragana-fukushi reads. */
 const DISTINCT = "orthographic-variant-distinct";
 const FUKUSHI = "hiragana-fukushi";
+/** Lexicon: idioms written as noun, particle and verb (気をつける). The verb there is compared apart from the verb on its own. */
+const IDIOM = "orthographic-variant-idiom";
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
-/** Whether a stretch of the sentence is outside a quotation and outside the team's names, both of which keep their own spelling. */
+/**
+ * Whether a stretch of the sentence is outside a quotation, the team's names and a reading in brackets (HTTP（えいちてぃーてぃーぴー）):
+ * the first two keep their own spelling, and a reading is not a spelling at all.
+ */
 const isOpenIn = (sentence: Sentence, names: readonly string[]): IsOpen => {
-  const quoted = quotedSpans(sentence.text, QUOTATION_MARKS);
+  const closed = [...quotedSpans(sentence.text, QUOTATION_MARKS), ...furiganaSpans(sentence.text)];
   const named = nameSpans(sentence.text, names);
-  return (start, end) => !isWithinAny(quoted, { start, end }) && !touchesAny(named, start, end);
+  return (start, end) => !isWithinAny(closed, { start, end }) && !touchesAny(named, start, end);
 };
 
-const isHelper = (token: Token, previous: Token | undefined): boolean =>
-  token.features?.["Bound"] === "Yes" || (previous?.pos === "SCONJ" && (previous.surface === "て" || previous.surface === "で"));
+/** A word and the two words before it, in its sentence. */
+type InContext = { readonly token: Token; readonly previous: Token | undefined; readonly before: Token | undefined };
+
+/** A verb's て-form the tokenizer read as a conjunction (追って at the head of a sentence): a kanji stem and て or で. Connectives (そして, それで) are kana. */
+const TE_FORM_CONJUNCTION = /^\p{Script=Han}.*[てで]$/u;
+
+/** After a て-form (見てみる). The tokenizer reads the て as a joining word, or the whole て-form as a conjunction (追って / みる). */
+const followsTeForm = (previous: Token | undefined): boolean =>
+  (previous?.pos === "SCONJ" && (previous.surface === "て" || previous.surface === "で")) ||
+  (previous?.pos === "CCONJ" && TE_FORM_CONJUNCTION.test(previous.surface));
+
+const isHelper = ({ token, previous }: InContext): boolean => token.features?.["Bound"] === "Yes" || followsTeForm(previous);
+
+const isTouching = (left: Token | undefined, right: Token): boolean => left !== undefined && left.span.end === right.span.start;
+
+const HIRAGANA_ONLY = /^[ぁ-ゖー]+$/u;
+
+/** A kana noun written onto a noun (全員ぶん): a suffix, which may not be the free noun of the same reading (文). */
+const isKanaSuffix = ({ token, previous }: InContext): boolean =>
+  token.pos === "NOUN" && previous?.pos === "NOUN" && isTouching(previous, token) && HIRAGANA_ONLY.test(token.surface);
+
+/** The verb of an idiom (気をつける): the noun, the particle and the verb's dictionary form are in the idiom lexicon. */
+const isIdiomVerb = ({ token, previous, before }: InContext, idioms: ReadonlySet<string>): boolean =>
+  token.pos === "VERB" && previous?.pos === "ADP" && before !== undefined && idioms.has(`${before.surface}${previous.surface}${token.lemma ?? token.surface}`);
 
 /**
  * A helper verb or a dependent noun (見て下さい, その事) is written kana by many guides while the full word keeps its kanji (資料を下さい).
- * The two uses are compared apart, so a document that follows that convention is consistent. A suffix (業務用) is a third use:
- * it is not the dependent noun of the same reading (このように).
+ * The two uses are compared apart, so a document that follows that convention is consistent. A suffix (業務用, 全員ぶん) is a third use:
+ * it is not the dependent noun of the same reading (このように). The verb of an idiom (気をつける) is a fourth.
  */
-const useOf = (token: Token, previous: Token | undefined): string => {
-  if (!isHelper(token, previous)) return "free";
-  return token.pos === "NOUN" && token.features?.["NounType"] !== "Dependent" ? "suffix" : "bound";
+const useOf = (word: InContext, idioms: ReadonlySet<string>): string => {
+  if (isIdiomVerb(word, idioms)) return "idiom";
+  if (isKanaSuffix(word)) return "suffix";
+  if (!isHelper(word)) return "free";
+  return word.token.pos === "NOUN" && word.token.features?.["NounType"] !== "Dependent" ? "suffix" : "bound";
 };
 
-const readingKeyOf = (token: Token, previous: Token | undefined, skip: ReadonlySet<string>): string | undefined => {
+/** One katakana and then kana that is not katakana (スる): no verb stem is one katakana long, as サボる and ググる are two. */
+const ONE_KATAKANA_HEAD = /^\p{Script=Katakana}(?!\p{Script=Katakana})/u;
+const KATAKANA_END = /\p{Script=Katakana}$/u;
+
+/** A piece the tokenizer cut out of a katakana run (ミスっ read as ミ and スる): not a word of its own. */
+const isCutFromKatakana = ({ token, previous }: InContext): boolean =>
+  ONE_KATAKANA_HEAD.test(token.surface) && token.surface.length > 1 && isTouching(previous, token) && KATAKANA_END.test(previous?.surface ?? "");
+
+type Skips = { readonly skip: ReadonlySet<string>; readonly idioms: ReadonlySet<string> };
+
+const readingKeyOf = (word: InContext, { skip, idioms }: Skips): string | undefined => {
+  const { token } = word;
   const lemma = token.lemma;
   if (!CONTENT.has(token.pos) || token.reading === undefined || lemma === undefined || !JAPANESE_WORD.test(lemma) || skip.has(lemma)) return undefined;
   const reading = lemmaReading(token.surface, lemma, token.reading);
-  if (reading === undefined || [...reading].length < MIN_READING || skip.has(reading)) return undefined;
-  return `${token.pos}|${useOf(token, previous)}|${reading}`;
+  if (reading === undefined || [...reading].length < MIN_READING || skip.has(reading) || isCutFromKatakana(word)) return undefined;
+  return `${token.pos}|${useOf(word, idioms)}|${reading}`;
 };
 
 /** Japanese words keyed by part of speech, use and the reading of the dictionary form, spelled as the dictionary form. */
-const readingWords = (sentence: Sentence, isOpen: IsOpen, skip: ReadonlySet<string>): Placed[] => {
+const readingWords = (sentence: Sentence, isOpen: IsOpen, skips: Skips): Placed[] => {
   const tokens = sentence.tokens ?? [];
   return tokens.flatMap((token, at): Placed[] => {
-    const key = readingKeyOf(token, tokens[at - 1], skip);
+    const key = readingKeyOf({ token, previous: tokens[at - 1], before: tokens[at - 2] }, skips);
     const local = token.span.start - sentence.span.start;
     if (key === undefined || token.lemma === undefined || !isOpen(local, local + token.surface.length)) return [];
     return [{ key, spelling: token.lemma, sentence, offset: token.span.start }];
@@ -140,11 +181,11 @@ const findingOf = (words: readonly Placed[], odd: OddSpelling<Placed>): Finding
  * document writes less is pointed at. No way is called right; limit is the largest share, in percent, the minority may have.
  */
 export const orthographicVariant: Detector = (doc, options): Finding[] => {
-  const skip = new Set([...patternsOf(doc, DISTINCT), ...patternsOf(doc, FUKUSHI)]);
+  const skips: Skips = { skip: new Set([...patternsOf(doc, DISTINCT), ...patternsOf(doc, FUKUSHI)]), idioms: new Set(patternsOf(doc, IDIOM)) };
   const placed = doc.sentences.map((sentence) => ({ sentence, isOpen: isOpenIn(sentence, doc.names ?? []) }));
-  const reading = byKanji(placed.flatMap(({ sentence, isOpen }) => readingWords(sentence, isOpen, skip)));
+  const reading = byKanji(placed.flatMap(({ sentence, isOpen }) => readingWords(sentence, isOpen, skips)));
   const katakana = placed.flatMap(({ sentence, isOpen }) => katakanaWords(sentence, isOpen));
-  const latin = placed.flatMap(({ sentence, isOpen }) => latinWords(sentence, isOpen, skip));
+  const latin = placed.flatMap(({ sentence, isOpen }) => latinWords(sentence, isOpen, skips.skip));
   const odd = [reading, katakana, latin].flatMap((words) => oddSpellings(words, options.limit));
   const all = [...reading, ...katakana, ...latin];
   // A word can be odd by its reading and by its katakana key at once; one place is said once.

package/src/detectors/party-role-name.ts

@@ -0,0 +1,44 @@
+// A party called by a role word (受託者, the Vendor) after the contract gave it a short name (乙, the "Supplier"). The
+// definitions come from the document's structure tree; the role words, short names and company forms from the language
+// package's word lists (party-role, party-short-name, company-form).
+import { definedTerms } from "../structure/definition-use.ts";
+import { partiesOf, roleUses } from "../structure/party-role.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+/** The sentence holding a definition: the role words in the sentences that name the parties are part of naming them. */
+const sentenceAt = (doc: ProseDocument, offset: number): { readonly start: number; readonly end: number } =>
+  doc.sentences.find((sentence) => sentence.span.start <= offset && offset < sentence.span.end)?.span ?? { start: offset, end: offset };
+
+const NAME_SEPARATOR: Readonly<Record<string, string>> = { ja: "、" };
+
+export const partyRoleName: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const terms = definedTerms(doc.structure);
+  const words = { roles: patternsOf(doc, "party-role"), shortNames: patternsOf(doc, "party-short-name"), companyForms: patternsOf(doc, "company-form") };
+  const parties = partiesOf(doc.source, terms, words);
+  if (parties.length === 0) return [];
+  // From the sentence that names the first party: a party named later (a subcontractor ("Recipient")) does not hide the role words before it.
+  const naming = parties.map((party) => sentenceAt(doc, party.end - 1));
+  const after = Math.min(...naming.map((sentence) => sentence.end));
+  const names = [...new Set(parties.map((party) => party.term))].join(NAME_SEPARATOR[doc.language] ?? ", ");
+  const texts = doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text }));
+  return roleUses(
+    doc.source,
+    texts,
+    words.roles,
+    terms.map((term) => term.term),
+    after,
+  )
+    .filter((use) => !naming.some((sentence) => sentence.start <= use.offset && use.offset < sentence.end))
+    .map((use) => ({
+      rule: "party-role-name",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, use.offset),
+      values: { role: use.role, names, offset: use.offset },
+    }));
+};