chaffjs 0.25.0 → 0.27.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/derived/relative-weekdays.ts

@@ -0,0 +1,65 @@
+// A date named by a weekday or a day relative to the document's date (「来週月曜（10月12日）」"next Monday (October 12)",
+// 「明日（10月7日）」) that the absolute date beside it contradicts. Pure; the detector finds the words and the dates.
+import type { Span } from "../plugin.ts";
+
+/** 「来週月曜」"next Monday": weeks from the base's week (来週 is 1), and the weekday (Sunday is 0). */
+export type WeekdayRelative = Span & { readonly kind: "weekday"; readonly weeks: number; readonly weekday: number };
+/** 「明日」"tomorrow": days from the base. */
+export type DayRelative = Span & { readonly kind: "day"; readonly days: number };
+export type DayWord = WeekdayRelative | DayRelative;
+
+const DAY_MS = 86_400_000;
+const WEEK = 7;
+const MONDAY = 1;
+const FULL = /^(\d{4})-(\d{2})-(\d{2})$/u;
+const MONTH_DAY = /^(\d{2})-(\d{2})$/u;
+
+const timeOf = (value: string): number | undefined => {
+  const found = FULL.exec(value);
+  if (found === null) return undefined;
+  const [year, month, day] = [Number(found[1]), Number(found[2]), Number(found[3])];
+  const time = Date.UTC(year, month - 1, day);
+  const date = new Date(time);
+  return date.getUTCMonth() === month - 1 && date.getUTCDate() === day ? time : undefined;
+};
+
+const valueOf = (time: number): string => new Date(time).toISOString().slice(0, "2026-10-06".length);
+
+/**
+ * The days a weekday word can mean. Weeks are counted from Monday or from Sunday, and "next Monday" can also mean the
+ * coming Monday: every reading is allowed, so only a date that fits none of them is wrong.
+ */
+const weekdayCandidates = (base: number, relative: WeekdayRelative): number[] => {
+  const baseDay = new Date(base).getUTCDay();
+  const fromMonday = base - ((baseDay - MONDAY + WEEK) % WEEK) * DAY_MS;
+  const fromSunday = base - baseDay * DAY_MS;
+  const inWeek = (weekStart: number, firstDay: number): number => weekStart + (relative.weeks * WEEK + ((relative.weekday - firstDay + WEEK) % WEEK)) * DAY_MS;
+  // "next Monday" and "this Monday" can mean the coming one; "last Monday" the one just past.
+  const coming = base + (((relative.weekday - baseDay + WEEK - 1) % WEEK) + 1) * DAY_MS;
+  const past = base - (((baseDay - relative.weekday + WEEK - 1) % WEEK) + 1) * DAY_MS;
+  const nearest = new Map([
+    [0, [coming]],
+    [1, [coming]],
+    [-1, [past]],
+  ]).get(relative.weeks);
+  return [inWeek(fromMonday, MONDAY), inWeek(fromSunday, 0), ...(nearest ?? [])];
+};
+
+const candidatesOf = (base: number, relative: DayWord): number[] =>
+  relative.kind === "day" ? [base + relative.days * DAY_MS] : weekdayCandidates(base, relative);
+
+/** Whether the written date (2026-10-12, or 10-12 without its year) is one of the days the word can mean. */
+const fits = (written: string, candidates: readonly number[]): boolean => {
+  const monthDay = MONTH_DAY.exec(written);
+  return candidates.some((time) => (monthDay === null ? valueOf(time) === written : valueOf(time).slice("2026-".length) === written));
+};
+
+/** The day the word means, as the message shows it: the first reading, written as the date was (with or without the year). */
+export const relativeDayMismatch = (base: string, relative: DayWord, written: string): string | undefined => {
+  const baseTime = timeOf(base);
+  if (baseTime === undefined || (!FULL.test(written) && !MONTH_DAY.test(written))) return undefined;
+  const candidates = candidatesOf(baseTime, relative);
+  const [first] = candidates;
+  if (first === undefined || fits(written, candidates)) return undefined;
+  return MONTH_DAY.test(written) ? valueOf(first).slice("2026-".length) : valueOf(first);
+};

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/change-rate.ts

@@ -0,0 +1,122 @@
+// change-rate-mismatch: the reading half. Builds the figures, the rates and the words of structure/change-rate.ts from the
+// tree's quantities, the numbers counted with a word ("1,200 companies"), and the lexicons change-direction, change-base,
+// percent-unit and amount-multiplier.
+import type { Detector, Finding, ProseDocument, Span, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { changeRateMismatches, type BaseMark, type Direction, type Figure, type Rate } from "../structure/change-rate.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const DIGITS = /\d[\d,]*(?:\.(\d+))?/u;
+const DECIMAL_BASE = 10;
+const LATIN = /^[A-Za-z]/u;
+
+/** The step a number is written to: its last digit, times the magnitude the tree folded into the value (12億 is 12 × 1億). */
+const stepOf = (written: string, value: number): number | undefined => {
+  const found = DIGITS.exec(written.normalize("NFKC"));
+  const shown = found === null ? Number.NaN : Number(found[0].replaceAll(",", ""));
+  if (!Number.isFinite(shown) || shown === 0) return undefined;
+  return (value / shown) * DECIMAL_BASE ** -(found?.[1]?.length ?? 0);
+};
+
+/** A word of magnitude right after the number ("$12 million"): the values compared must be written to the same one. */
+const WORD_AFTER = /^\s+([A-Za-z]+)/u;
+const WORDS_AFTER = /^\s+([A-Za-z]+)(?:\s+([A-Za-z]+))?/u;
+
+const multiplierAfter = (source: string, end: number, multipliers: readonly string[]): string => {
+  const after = WORD_AFTER.exec(source.slice(end))?.[1]?.toLowerCase() ?? "";
+  return multipliers.includes(after) ? after : "";
+};
+
+const quantityNodes = (tree: StructureNode): StructureNode[] => inDocumentOrder(tree).filter((node) => node.kind === "quantity" || node.kind === "date");
+
+const ratesOf = (doc: ProseDocument, nodes: readonly StructureNode[], units: readonly string[]): Rate[] =>
+  nodes.flatMap((node) => {
+    const unit = String(node.attrs["unit"] ?? "");
+    if (node.kind !== "quantity" || !units.includes(unit)) return [];
+    const decimals = DIGITS.exec(doc.source.slice(node.span.start, node.span.end).normalize("NFKC"))?.[1]?.length ?? 0;
+    return [{ start: node.span.start, end: node.span.end, value: Number(node.attrs["value"]), decimals }];
+  });
+
+const treeFigures = (doc: ProseDocument, nodes: readonly StructureNode[], units: readonly string[], multipliers: readonly string[]): Figure[] =>
+  nodes.flatMap((node) => {
+    const unit = String(node.attrs["unit"] ?? "");
+    const value = Number(node.attrs["value"]);
+    const step = stepOf(doc.source.slice(node.span.start, node.span.end), value);
+    if (node.kind !== "quantity" || units.includes(unit) || step === undefined) return [];
+    return [{ start: node.span.start, end: node.span.end, value, step, unit: `${unit}|${multiplierAfter(doc.source, node.span.end, multipliers)}` }];
+  });
+
+/** A number with no unit the tree reads, counted with the word after it ("1,200 companies", "2.4 million users"). */
+const COUNTED = /(?<![\w.,$€£¥])(\d{1,3}(?:,\d{3})+|\d+)(?:\.(\d+))?(?=\s+[A-Za-z])/gu;
+/** A year written alone ("2024 revenue"): a point in time, not a value. */
+const YEAR = /^(?:1[89]|2[01])\d{2}$/u;
+
+/** The unit a counted number is compared in: the word after it, with a word of magnitude before that word ("million users"). */
+const countedUnit = (source: string, end: number, multipliers: readonly string[]): string | undefined => {
+  const words = WORDS_AFTER.exec(source.slice(end));
+  const first = words?.[1]?.toLowerCase() ?? "";
+  const multiplier = multipliers.includes(first) ? first : "";
+  const noun = multiplier === "" ? first : (words?.[2]?.toLowerCase() ?? "");
+  return LATIN.test(noun) ? `${noun}|${multiplier}` : undefined;
+};
+
+const countedFigures = (doc: ProseDocument, taken: readonly Span[], multipliers: readonly string[]): Figure[] =>
+  [...doc.source.matchAll(COUNTED)].flatMap((match) => {
+    const start = match.index;
+    const end = start + match[0].length;
+    const unit = countedUnit(doc.source, end, multipliers);
+    if (unit === undefined || taken.some((span) => span.start < end && start < span.end) || YEAR.test(match[0])) return [];
+    const decimals = match[2] ?? "";
+    const value = Number([(match[1] ?? "").replaceAll(",", ""), decimals].filter((part) => part !== "").join("."));
+    return [{ start, end, value, step: DECIMAL_BASE ** -decimals.length, unit }];
+  });
+
+/** Where a word of the lexicon stands in the source: a Latin word as a whole word, anything else as written. */
+const spansOf = (source: string, word: string): Span[] => {
+  const pattern = LATIN.test(word) ? new RegExp(`\\b${escapeRegExp(word)}\\b`, "giu") : new RegExp(escapeRegExp(word), "gu");
+  return [...source.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+};
+
+const SIGNS: Readonly<Record<string, 1 | -1>> = { rise: 1, fall: -1 };
+
+/** Phrases that hold a direction word but give no direction ("up to 25%" is a ceiling): lexicon change-direction-not. */
+const directionsOf = (doc: ProseDocument): Direction[] => {
+  const not = patternsOf(doc, "change-direction-not").flatMap((phrase) => spansOf(doc.source, phrase));
+  return (doc.lexicons["change-direction"] ?? []).flatMap((entry) => {
+    const sign = SIGNS[entry.group ?? ""];
+    const spans = spansOf(doc.source, entry.pattern).filter((span) => !not.some((phrase) => phrase.start <= span.start && span.end <= phrase.end));
+    return sign === undefined ? [] : spans.map((span) => ({ ...span, sign }));
+  });
+};
+
+const marksOf = (doc: ProseDocument, lexicon: string): BaseMark[] =>
+  (doc.lexicons[lexicon] ?? []).flatMap((entry) =>
+    entry.position === undefined ? [] : spansOf(doc.source, entry.pattern).map((span) => ({ ...span, position: entry.position ?? "before" })),
+  );
+
+export const changeRate: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const nodes = quantityNodes(doc.structure);
+  const units = patternsOf(doc, "percent-unit");
+  const multipliers = patternsOf(doc, "amount-multiplier").map((word) => word.toLowerCase());
+  const taken = nodes.map((node) => node.span);
+  const text = {
+    sentences: doc.sentences.map((sentence) => sentence.span),
+    figures: [...treeFigures(doc, nodes, units, multipliers), ...countedFigures(doc, taken, multipliers)],
+    rates: ratesOf(doc, nodes, units),
+    directions: directionsOf(doc),
+    marks: marksOf(doc, "change-base"),
+    targets: marksOf(doc, "change-target"),
+  };
+  return changeRateMismatches(text).map((issue) => ({
+    rule: "change-rate-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.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/derived-numbers.ts

@@ -1,6 +1,6 @@
 import type { Detector, Finding, ProseDocument, Span, StructureNode } from "../plugin.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
-import { dateStampIndexes, stampCandidates } from "../date-stamp.ts";
+import { documentDateOf } from "./document-date.ts";
 import { overlapsAny, spanIndex } from "../compare/spans.ts";
 import { yearOf, type DurationUnit } from "../derived/date-arithmetic.ts";
 import { durationMismatches, type DatedValue, type Duration } from "../derived/durations.ts";
@@ -142,16 +142,8 @@ const markedAges = (doc: ProseDocument): Elapsed[] =>
 
 /** 文書の日付の年: 日付だけの段落か「更新日：」の段落（date-stamp）の、最初の日付。 */
 const referenceYear = (doc: ProseDocument, tree: StructureNode): number | undefined => {
-  const dates = datesOf(tree);
-  const candidates = stampCandidates(
-    doc.source,
-    doc.paragraphs.map((paragraph) => paragraph.span),
-    dates,
-  );
-  const stamps = dateStampIndexes(candidates, patternsOf(doc, "date-stamp-label"));
-  const paragraph = doc.paragraphs.find((_, index) => stamps.has(index));
-  const date = paragraph === undefined ? undefined : dates.find((candidate) => candidate.start >= paragraph.span.start && candidate.end <= paragraph.span.end);
-  return date === undefined ? undefined : yearOf(date.value);
+  const date = documentDateOf(doc, tree);
+  return date === undefined ? undefined : yearOf(date);
 };
 
 /** 起点の年から数えた年数が、文書の日付と合わない。 */

package/src/detectors/document-date.ts

@@ -0,0 +1,18 @@
+// The document's own date: the first date of its date-stamp paragraph (a paragraph that is only a date, or 「更新日：」).
+import type { ProseDocument, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { dateStampIndexes, stampCandidates } from "../date-stamp.ts";
+
+/** The date of the document's date stamp as the tree reads it ("2026-10-06", or "2026" for a year alone), when it has one. */
+export const documentDateOf = (doc: ProseDocument, tree: StructureNode): string | undefined => {
+  const dates = inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ ...node.span, value: String(node.attrs["value"]) }] : []));
+  const candidates = stampCandidates(
+    doc.source,
+    doc.paragraphs.map((paragraph) => paragraph.span),
+    dates,
+  );
+  const labels = (doc.lexicons["date-stamp-label"] ?? []).map((entry) => entry.pattern);
+  const stamps = dateStampIndexes(candidates, labels);
+  const paragraph = doc.paragraphs.find((_, index) => stamps.has(index));
+  return paragraph === undefined ? undefined : dates.find((candidate) => candidate.start >= paragraph.span.start && candidate.end <= paragraph.span.end)?.value;
+};