chaffjs 0.24.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/connective-hierarchy.ts

@@ -0,0 +1,99 @@
+import type { Detector, Finding, LexiconEntry, Sentence, Span, Token } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quotedSpans } from "../quoted-span.ts";
+
+// A connective that joins only the outer level of a two-level list, in a sentence with no inner level under it. The
+// lexicon holds both levels: an entry with a rewrite is an outer-level word (rewrite is the word a one-level list uses),
+// and an entry with instead_of is an inner-level word that stands under that outer-level word.
+
+/** One outer-level connective with nothing to stand above, and where it is in the document. */
+export type LoneConnective = { readonly offset: number; readonly written: string; readonly usual: string };
+
+const CONJUNCTION = "CCONJ";
+
+/** The word lists the detector reads: the connectives, and the phrases that hold one's letters without being one (歯並びに). */
+export type ConnectiveLists = { readonly connectives: readonly LexiconEntry[]; readonly lookalikes: readonly LexiconEntry[] };
+
+/**
+ * The tagger does not always tell a connective from a noun and a particle: it reads 申請書並びに as 並び + に and
+ * 文字の並びに as the conjunction. After の, a determiner or an adjective (の並びに, この並びに, 正しい並びに) the word is
+ * a noun of its own. Where the tagger splits it, it is a connective only between two nouns: a noun, a number or a mark
+ * before it, and no verb right after it (一列並びに座る).
+ */
+const MODIFIES_NOUN: ReadonlySet<string> = new Set(["DET", "ADJ"]);
+const GENITIVE = "の";
+const JOINS_AFTER: ReadonlySet<string> = new Set(["NOUN", "PROPN", "NUM", "PUNCT", "SYM"]);
+const ENDS_CLAUSE: ReadonlySet<string> = new Set(["VERB", "AUX"]);
+
+const modifiesNoun = (token: Token | undefined): boolean =>
+  token !== undefined && (MODIFIES_NOUN.has(token.pos) || (token.pos === "ADP" && token.surface === GENITIVE));
+
+const joinsNouns = (previous: Token | undefined, next: Token | undefined): boolean =>
+  previous !== undefined && JOINS_AFTER.has(previous.pos) && next !== undefined && !ENDS_CLAUSE.has(next.pos);
+
+/** A sentence's tokens by where they start and end, and the letters a connective there would not be read in. */
+type Reading = { readonly byStart: ReadonlyMap<number, Token>; readonly byEnd: ReadonlyMap<number, Token>; readonly hidden: readonly boolean[] };
+
+const placesOf = (text: string, word: string): number[] => [...text.matchAll(new RegExp(escapeRegExp(word), "gu"))].map((match) => match.index);
+
+/** Inside 「」 or 『』 (a quoted phrase holds half a list) or inside a lookalike (歯並びに), by the sentence's own offsets. */
+const hiddenLetters = (text: string, lookalikes: readonly LexiconEntry[]): boolean[] => {
+  const hidden = Array.from({ length: text.length }, () => false);
+  const hide = (start: number, end: number): boolean[] => hidden.fill(true, start, end);
+  quotedSpans(text).forEach((span) => hide(span.start, span.end));
+  lookalikes.forEach(({ pattern }) => placesOf(text, pattern).forEach((at) => hide(at, at + pattern.length)));
+  return hidden;
+};
+
+const readingOf = (sentence: Sentence, lookalikes: readonly LexiconEntry[]): Reading => {
+  const tokens = sentence.tokens ?? [];
+  return {
+    byStart: new Map(tokens.map((token) => [token.span.start, token])),
+    byEnd: new Map(tokens.map((token) => [token.span.end, token])),
+    hidden: hiddenLetters(sentence.text, lookalikes),
+  };
+};
+
+const standsAsConnective = (reading: Reading, span: Span): boolean => {
+  const previous = reading.byEnd.get(span.start);
+  if (modifiesNoun(previous)) return false;
+  const own = reading.byStart.get(span.start);
+  const tagged = own !== undefined && own.pos === CONJUNCTION && own.span.end === span.end;
+  return tagged || joinsNouns(previous, reading.byStart.get(span.end));
+};
+
+const hasInnerLevel = (sentence: Sentence, outer: LexiconEntry, connectives: readonly LexiconEntry[]): boolean =>
+  connectives.some((entry) => entry.instead_of === outer.pattern && sentence.text.includes(entry.pattern));
+
+/** Where one outer-level word stands as a connective in the sentence. */
+const connectiveSpans = (sentence: Sentence, outer: LexiconEntry, reading: Reading): Span[] =>
+  placesOf(sentence.text, outer.pattern)
+    .filter((at) => reading.hidden[at] !== true)
+    .map((at) => ({ start: sentence.span.start + at, end: sentence.span.start + at + outer.pattern.length }))
+    .filter((span) => standsAsConnective(reading, span));
+
+/** The outer-level connectives of a sentence that stand over no inner level. */
+export const loneConnectivesIn = (sentence: Sentence, lists: ConnectiveLists): LoneConnective[] => {
+  const lone = lists.connectives.filter(
+    (entry) => entry.rewrite !== undefined && sentence.text.includes(entry.pattern) && !hasInnerLevel(sentence, entry, lists.connectives),
+  );
+  if (lone.length === 0) return [];
+  const reading = readingOf(sentence, lists.lookalikes);
+  return lone
+    .flatMap((entry) => connectiveSpans(sentence, entry, reading).map((span) => ({ offset: span.start, written: entry.pattern, usual: entry.rewrite ?? "" })))
+    .sort((a, b) => a.offset - b.offset);
+};
+
+export const connectiveHierarchy: Detector = (doc, options): Finding[] => {
+  const lists = { connectives: options.lexicon ?? [], lookalikes: doc.lexicons["connective-lookalike"] ?? [] };
+  return doc.sentences.flatMap((sentence) =>
+    loneConnectivesIn(sentence, lists).map((lone) => ({
+      rule: "",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { written: lone.written, usual: lone.usual, offset: lone.offset },
+    })),
+  );
+};

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/missing-final-period.ts

@@ -0,0 +1,79 @@
+import type { Detector, Finding, LexiconEntry, Paragraph, ProseDocument, Token } from "../plugin.ts";
+import { formMinority } from "./form-minority.ts";
+
+// A paragraph whose last sentence stops without its closing mark, in a document whose other paragraphs end with one. It
+// takes no side: a document that ends none of its paragraphs with the mark (slides, labels) is not reported. The marks
+// come from the language's lexicon "final-period": group "end" is the period, group "other-end" closes a sentence another
+// way (？, ！) so the paragraph is not counted, and group "note" opens a note line. The
+// lexicon is read directly rather than as the rule's word list, since its marks are what a fixed paragraph ends with.
+
+/** A paragraph's end, and whether it closes with a sentence-ending mark. form is "closed" or "open". */
+export type ParagraphEnd = { readonly offset: number; readonly form: string; readonly text: string };
+
+/** The marks the detector reads, from the lexicon. */
+export type PeriodMarks = { readonly ends: readonly string[]; readonly otherEnds: readonly string[]; readonly notes: readonly string[] };
+
+/** Brackets and quotes that may follow a closing mark (〜です。」). */
+const CLOSERS = '」』）)"”’';
+/** A line that is itself a quotation closes like a sentence. */
+const QUOTE_CLOSERS = "」』";
+/** A paragraph ending in a colon leads into a list or a block; it is not a sentence left open. */
+const LEAD_IN = /[：:]$/u;
+/** Two spaces in a row, half- or full-width, lay a line out like a table (an ingredient, then its amount), so it is not a sentence. */
+const LAYOUT = /[ \u3000]{2}/u;
+/** Fewer characters than this is a label or a caption, not a sentence. */
+const MIN_SENTENCE_CHARS = 15;
+/** Words that end a clause: a verb, an adjective or an auxiliary in its dictionary form ends the sentence. */
+const PREDICATE: ReadonlySet<string> = new Set(["VERB", "ADJ", "AUX"]);
+
+/** The line's last mark before any closing brackets and quotes is one of these. */
+const endsWithMark = (line: string, marks: readonly string[]): boolean => {
+  const chars = Array.from(line);
+  return marks.includes(chars[chars.findLastIndex((char) => !CLOSERS.includes(char))] ?? "");
+};
+
+const isClosed = (line: string, ends: readonly string[]): boolean => endsWithMark(line, ends) || QUOTE_CLOSERS.includes(line.at(-1) ?? "\0");
+
+/** A note, a laid-out row, or a question or exclamation: not a sentence that could take the period. */
+const isAside = (line: string, marks: PeriodMarks): boolean =>
+  marks.notes.some((note) => line.startsWith(note)) || LAYOUT.test(line) || endsWithMark(line, marks.otherEnds);
+
+/** The paragraph's last word ends a sentence: a predicate written in its dictionary form (〜します, 〜である, 望ましい). */
+const endsInPredicate = (paragraph: Paragraph): boolean => {
+  const last = (paragraph.sentences.at(-1)?.tokens ?? []).filter((token: Token) => token.surface.trim() !== "").at(-1);
+  return last !== undefined && PREDICATE.has(last.pos) && last.lemma === last.surface;
+};
+
+/** How a paragraph ends, or undefined when its last line is not a sentence (a label, a lead-in, a note, a laid-out row). */
+export const paragraphEnd = (text: string, paragraph: Paragraph, marks: PeriodMarks): ParagraphEnd | undefined => {
+  const body = text.slice(paragraph.span.start, paragraph.span.end).trimEnd();
+  const last = body.split("\n").at(-1)?.trim() ?? "";
+  if (Array.from(last).length < MIN_SENTENCE_CHARS || LEAD_IN.test(last)) return undefined;
+  const offset = paragraph.span.start + body.length - 1;
+  if (isAside(last, marks)) return undefined;
+  if (isClosed(last, marks.ends)) return { offset, form: "closed", text: last };
+  // A closing parenthetical after the sentence (〜します（別紙を参照する）) is not where the period goes.
+  return !CLOSERS.includes(last.at(-1) ?? "\0") && endsInPredicate(paragraph) ? { offset, form: "open", text: last } : undefined;
+};
+
+const marksOf = (lexicon: readonly LexiconEntry[]): PeriodMarks => ({
+  ends: lexicon.filter((entry) => entry.group === "end").map((entry) => entry.pattern),
+  otherEnds: lexicon.filter((entry) => entry.group === "other-end").map((entry) => entry.pattern),
+  notes: lexicon.filter((entry) => entry.group === "note").map((entry) => entry.pattern),
+});
+
+export const missingFinalPeriod: Detector = (doc: ProseDocument, options): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const marks = marksOf(doc.lexicons["final-period"] ?? []);
+  const ends = doc.paragraphs.flatMap((paragraph) => paragraphEnd(text, paragraph, marks) ?? []);
+  const minority = formMinority(ends, options.limit);
+  if (minority === undefined || minority.usual.form !== "closed") return [];
+  return minority.odd.map((end) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: end.text,
+    values: { count: minority.odd.length, of: ends.length, offset: end.offset },
+  }));
+};

package/src/detectors/missing-space-after-comma.ts

@@ -0,0 +1,54 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// A comma between two words with no space after it ("address,and"): a slip in English prose. A run of values joined by
+// commas ("blue,black,brown"), and anything inside an address, a path or an assignment, is data, not prose.
+
+/** One comma with no space after it, where it is, and the two words it joins as written. */
+export type TightComma = { readonly offset: number; readonly written: string };
+
+/** A word of three letters or more (a possessive 's may follow), a comma, and a lower-case word of three letters or more. */
+const JOINED = /(?<![\p{L}\p{N}])[A-Za-z]{3,}(?:['’]s)?,[a-z]{3,}(?![\p{L}\p{N}])/u;
+/** Characters that make a run of text an address, a path, a parameter or data (a=b, a/b, a.b, @a, #a, a_b, 3,abc). */
+const DATA_MARK = /[/\\=@#:.&?_|+*~$%^<>{}[\]\p{N}]/u;
+/** Opening and closing marks a word of prose may carry ("(and,then)"), and the sentence's own end ("and,then."). */
+const OPENERS = "(\"'“‘[";
+const CLOSERS = ")\"'”’].,;!?";
+/** A run quoted whole, inside brackets or not ("true,false", ("true,false")): a value written out, not two words of the sentence. */
+const QUOTED_WHOLE = /^[([]*["'“‘].*["'”’][)\].,;!?]*$/u;
+/** A run of text between whitespace. */
+const RUN = /\S+/gu;
+const COMMA = ",";
+
+/** The run without the marks around it, trimmed by scanning rather than by a pattern that could backtrack. */
+const bareOf = (run: string): string => {
+  const chars = run.split("");
+  const start = chars.findIndex((char) => !OPENERS.includes(char));
+  const end = chars.findLastIndex((char) => !CLOSERS.includes(char));
+  return start === -1 || end < start ? "" : run.slice(start, end + 1);
+};
+
+/** A run holding one comma and nothing that marks it as data. */
+const isProseRun = (run: string): boolean => {
+  const bare = bareOf(run);
+  return bare.split(COMMA).length === 2 && !DATA_MARK.test(bare) && !QUOTED_WHOLE.test(run);
+};
+
+/** Each run is read once, so a long line of values costs one pass. */
+export const tightCommasIn = (text: string): TightComma[] =>
+  [...text.matchAll(RUN)].flatMap((run) => {
+    const joined = isProseRun(run[0]) ? JOINED.exec(run[0]) : null;
+    return joined === null ? [] : [{ offset: run.index + joined.index + joined[0].indexOf(COMMA), written: joined[0] }];
+  });
+
+export const missingSpaceAfterComma: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  return tightCommasIn(text).map((comma) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, comma.offset, comma.offset + 1),
+    values: { written: comma.written, offset: comma.offset },
+  }));
+};