chaffjs 0.19.0 → 0.20.0

package/src/cross-run.ts

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

package/src/cross-variants.ts

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

package/src/cross-votes.ts

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

package/src/date-format.ts

@@ -0,0 +1,123 @@
+// 日付の書き方（2026-10-02、2026年10月2日、Oct 2, 2026）を読む。純粋な関数だけを置く。
+// 月の名前と元号は言語パッケージの語彙表が渡す。年・月・日のそろった日付だけを読む（年だけ、月日だけは書き方を比べられない）。
+
+/** 見つけた日付 1 つ。offset は渡した文字列の中の位置、style は書き方の名前。 */
+export type WrittenDate = { readonly offset: number; readonly written: string; readonly style: string };
+
+/** 書き方を読むのに要る語。months は月の名前（January、Jan）、eras は元号（令和）。 */
+export type DateWords = { readonly months: readonly string[]; readonly eras: readonly string[] };
+
+const DIGIT = "[0-9０-９]";
+/** 日付の前に来ない字。URL や版（v1.2.2026.10）の中の数を日付と読まない。 */
+const NOT_AFTER = "(?<![\\w/.\\-])";
+
+const escaped = (word: string): string => word.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+type Shape = readonly [string, RegExp];
+
+/** 日付の後ろに来ない字。時刻の付いた日時（2026-10-02T12:00）とファイルの名前（2026-10-02.pdf）は日付の書き方ではない。 */
+const NOT_BEFORE = "(?![\\w/／\\-]|\\.\\w)";
+
+const Y = `(?<y>${DIGIT}{4})`;
+const M = `(?<m>${DIGIT}{1,2})`;
+const D = `(?<d>${DIGIT}{1,2})`;
+
+/** 書き方の名前と、それを読む形。数字の組は月と日の範囲を後で確かめる。全角の数字も読む。 */
+const numericShapes = (): Shape[] => [
+  ["iso", new RegExp(`${NOT_AFTER}${Y}-${M}-${D}${NOT_BEFORE}`, "gu")],
+  ["year-slash", new RegExp(`${NOT_AFTER}${Y}[/／]${M}[/／]${D}${NOT_BEFORE}`, "gu")],
+  ["year-dot", new RegExp(`${NOT_AFTER}${Y}\\.${M}\\.${D}(?!\\.?[\\d０-９])`, "gu")],
+  ["slash-year-last", new RegExp(`${NOT_AFTER}${M}[/／]${D}[/／]${Y}${NOT_BEFORE}`, "gu")],
+  ["nen-gappi", new RegExp(`${Y}年\\s?${M}月\\s?${D}日`, "gu")],
+];
+
+const monthShapes = (months: string): Shape[] =>
+  months === ""
+    ? []
+    : [
+        ["month-day-year", new RegExp(`\\b(?:${months})\\.?\\s+(?<d>\\d{1,2})(?:st|nd|rd|th)?,?\\s+\\d{4}\\b`, "gu")],
+        ["day-month-year", new RegExp(`\\b(?<d>\\d{1,2})(?:st|nd|rd|th)?\\s+(?:${months})\\.?,?\\s+\\d{4}\\b`, "gu")],
+      ];
+
+const eraShapes = (eras: string): Shape[] => (eras === "" ? [] : [["era", new RegExp(`(?:${eras})\\s?(?:${DIGIT}{1,2}|元)年\\s?${M}月\\s?${D}日`, "gu")]]);
+
+/** 語彙表の語を使う形。月の名前は書いたとおりに照らす（小文字の may は月ではない）。 */
+const namedShapes = (words: DateWords): Shape[] => [...monthShapes(words.months.map(escaped).join("|")), ...eraShapes(words.eras.map(escaped).join("|"))];
+
+const FULLWIDTH_OFFSET = 0xfee0;
+const halfWidth = (text: string): string => text.replace(/[０-９]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - FULLWIDTH_OFFSET));
+
+const MONTHS_IN_YEAR = 12;
+const PERCENT = 100;
+const DAYS_IN_MONTH = 31;
+
+type Groups = Readonly<Record<string, string | undefined>> | undefined;
+
+const numberIn = (groups: Groups, name: string): number => Number(halfWidth(groups?.[name] ?? ""));
+
+const isMonthDay = (month: number, day: number): boolean => month >= 1 && month <= MONTHS_IN_YEAR && day >= 1 && day <= DAYS_IN_MONTH;
+
+/** 数字の組が月と日として読めるか。読めなければ版や番号（2026.10.45）。 */
+const isCalendar = (groups: Groups): boolean => isMonthDay(numberIn(groups, "m"), numberIn(groups, "d"));
+
+/** 月の名前で書いた日付の日。月は名前で決まる。 */
+const isDay = (groups: Groups): boolean => isMonthDay(1, numberIn(groups, "d"));
+
+/** 年が後ろの数字の組（10/2/2026、25/12/2026）。月日の順は国で違うので、どちらの順でも読めればよい。 */
+const isEitherOrder = (groups: Groups): boolean =>
+  isMonthDay(numberIn(groups, "m"), numberIn(groups, "d")) || isMonthDay(numberIn(groups, "d"), numberIn(groups, "m"));
+
+/** 書き方ごとの、数が月と日として読めるかの確かめ。 */
+const CHECKS: Readonly<Record<string, (groups: Groups) => boolean>> = {
+  iso: isCalendar,
+  "year-slash": isCalendar,
+  "year-dot": isCalendar,
+  "nen-gappi": isCalendar,
+  "slash-year-last": isEitherOrder,
+  era: isCalendar,
+  "month-day-year": isDay,
+  "day-month-year": isDay,
+};
+
+const found = (style: string, pattern: RegExp, text: string): WrittenDate[] => {
+  const check = CHECKS[style];
+  return [...text.matchAll(pattern)].flatMap((match) => (check?.(match.groups) === true ? [{ offset: match.index, written: match[0], style }] : []));
+};
+
+/** 文字列の中の日付と、その書き方。形どうしは同じ所に当たらない（区切りの字と、前後に来ない字が違う）。 */
+export const datesIn = (text: string, words: DateWords): WrittenDate[] =>
+  [
+    ...numericShapes().flatMap(([style, pattern]) => found(style, pattern, text)),
+    ...namedShapes(words).flatMap(([style, pattern]) => found(style, pattern, text)),
+  ].toSorted((left, right) => left.offset - right.offset);
+
+/** 少ないほうの書き方の日付と、多いほうの書き方の数と例。 */
+export type DateMinority = { readonly odd: readonly WrittenDate[]; readonly majority: WrittenDate; readonly count: number; readonly total: number };
+
+/**
+ * 書き方の多いほうと、それ以外の日付。ほかの書き方の日付の割合が limit パーセント以下のときだけ。
+ * それより多ければ、二つの書き方を使い分けている文書と読む（表は 2026-10-02、本文は 2026年10月2日）。いちばん多い書き方が同じ数で並べば言わない。
+ */
+export const dateMinority = (dates: readonly WrittenDate[], limit: number): DateMinority | undefined => {
+  const counts = new Map<string, number>();
+  dates.forEach((date) => counts.set(date.style, (counts.get(date.style) ?? 0) + 1));
+  const [top, second] = [...counts].toSorted((left, right) => right[1] - left[1]);
+  if (top === undefined || second === undefined || top[1] === second[1]) return undefined;
+  const odd = dates.filter((date) => date.style !== top[0]);
+  const majority = dates.find((date) => date.style === top[0]);
+  if (majority === undefined || odd.length * PERCENT > dates.length * limit) return undefined;
+  return { odd, majority, count: top[1], total: dates.length };
+};
+
+/** 行の頭から日付までが、箇条書きの印・表の区切り・強調の印と空白だけ。予定表の行の頭の日付（- 2026-10-16: …、| 2026-10-16 |）。 */
+const LINE_HEAD = /(?:^|\|)[\s>*_+-]*(?:\d+[.)]\s+)?$/u;
+
+/** 日付が行の頭（箇条書きの項目や表の升の頭）にあるか。 */
+export const opensLine = (text: string, offset: number): boolean => LINE_HEAD.test(text.slice(text.lastIndexOf("\n", offset - 1) + 1, offset));
+
+/**
+ * 行の頭の日付と、文の中の日付を分ける。予定表を 2026-10-16 で並べ、文では 14 October 2026 と書くのは使い分けで、混ざりではない。
+ * 書き方はそれぞれの組の中でだけ比べる。
+ */
+export const dateGroups = (text: string, dates: readonly WrittenDate[]): WrittenDate[][] =>
+  [true, false].map((head) => dates.filter((date) => opensLine(text, date.offset) === head)).filter((group) => group.length > 0);

package/src/derived/date-arithmetic.ts

@@ -0,0 +1,63 @@
+/**
+ * 木の日付の値（2026-04-01、04-01、2026-04、2026）に期間を足す。年の無い月日は、同じ年の中で数える（年をまたげば翌年）。
+ * 暦は先発グレゴリオ暦。月を足して月末を越えるとき（1月31日の1か月後）は、その月の末日にする。
+ */
+export type DurationUnit = "day" | "week" | "month" | "year";
+
+export type CalendarDate = { readonly year: number | undefined; readonly month: number; readonly day: number };
+
+const FULL = /^(\d{4})-(\d{2})-(\d{2})$/u;
+const MONTH_DAY = /^(\d{2})-(\d{2})$/u;
+const YEAR_ONLY = /^(\d{4})$/u;
+const FULL_YEAR = /^(\d{4})-\d{2}(?:-\d{2})?$/u;
+
+/** 年がわからない月日を数えるときの年。うるう年でない年にすると 2月29日 が読めないので、うるう年を使う。 */
+const LEAP_YEAR = 2000;
+const DAYS_IN_WEEK = 7;
+const MONTHS_IN_YEAR = 12;
+const PADDED = 2;
+
+/** 年月日か月日の値。それ以外（年月、年だけ）は undefined。 */
+export const calendarDateOf = (value: string): CalendarDate | undefined => {
+  const full = FULL.exec(value);
+  if (full !== null) return { year: Number(full[1]), month: Number(full[2]), day: Number(full[3]) };
+  const monthDay = MONTH_DAY.exec(value);
+  return monthDay === null ? undefined : { year: undefined, month: Number(monthDay[1]), day: Number(monthDay[2]) };
+};
+
+/** 年を書いた値（2015、2015-04、2015-04-01）の年。 */
+export const yearOf = (value: string): number | undefined => {
+  const year = YEAR_ONLY.exec(value) ?? FULL_YEAR.exec(value);
+  return year === null ? undefined : Number(year[1]);
+};
+
+const utcOf = (year: number, month: number, day: number): Date => new Date(Date.UTC(year, month - 1, day));
+
+const lastDayOf = (year: number, month: number): number => utcOf(year, month + 1, 0).getUTCDate();
+
+const addMonths = (date: Date, months: number): Date => {
+  const target = utcOf(date.getUTCFullYear(), date.getUTCMonth() + 1 + months, 1);
+  const day = Math.min(date.getUTCDate(), lastDayOf(target.getUTCFullYear(), target.getUTCMonth() + 1));
+  return utcOf(target.getUTCFullYear(), target.getUTCMonth() + 1, day);
+};
+
+const addDays = (date: Date, days: number): Date => utcOf(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate() + days);
+
+/** 日付に期間を足す（負なら引く）。 */
+export const shifted = (date: Date, amount: number, unit: DurationUnit): Date => {
+  if (unit === "day") return addDays(date, amount);
+  if (unit === "week") return addDays(date, amount * DAYS_IN_WEEK);
+  return addMonths(date, unit === "month" ? amount : amount * MONTHS_IN_YEAR);
+};
+
+/** 年の無い月日には仮の年を付ける。 */
+export const dateOf = (date: CalendarDate): Date => utcOf(date.year ?? LEAP_YEAR, date.month, date.day);
+
+export const sameDay = (left: Date, right: Date): boolean => left.getTime() === right.getTime();
+
+/** 日付を、元の値と同じ細かさの値（年が無ければ月日だけ）にする。 */
+export const valueOf = (date: Date, withYear: boolean): string => {
+  const month = String(date.getUTCMonth() + 1).padStart(PADDED, "0");
+  const day = String(date.getUTCDate()).padStart(PADDED, "0");
+  return withYear ? `${String(date.getUTCFullYear())}-${month}-${day}` : `${month}-${day}`;
+};

package/src/derived/durations.ts

@@ -0,0 +1,52 @@
+import type { Span } from "../plugin.ts";
+import { bySentence } from "./sentence-buckets.ts";
+import { calendarDateOf, dateOf, shifted, valueOf, type DurationUnit } from "./date-arithmetic.ts";
+
+/**
+ * 始まりと期間と終わりを一つの文に書いたもの（「4月1日から3か月間（6月30日まで）」"for 3 months from April 1, 2026 (until
+ * June 30, 2026)"）。始まりに期間を足した日が終わりと合わなければ言う。期間の数え方は三通りある。終わりの日を含めて数える
+ * （4月1日から3か月間は6月30日まで）か、含めずに数える（7月1日まで）か、初日を数えずに期間が過ぎた日（「到達日から2週間が経過した日
+ * （4月16日）」）。どれとも合わないときだけ言う。
+ * 文に日付がちょうど二つ、期間がちょうど一つのときだけ読む。それより多い文は、どの日付とどの期間が組なのか決まらない。
+ */
+export type DatedValue = Span & { readonly value: string };
+
+export type Duration = Span & { readonly amount: number; readonly unit: DurationUnit };
+
+export type DurationMismatch = { readonly start: DatedValue; readonly duration: Duration; readonly end: DatedValue; readonly expected: string };
+
+/** 期間を足した日と、その前の日（終わりを含めて数える）と、次の日（初日を数えずに期間が過ぎた日）。 */
+const expectedEnds = (start: Date, duration: Duration): Date[] => {
+  const exclusive = shifted(start, duration.amount, duration.unit);
+  return [shifted(exclusive, -1, "day"), exclusive, shifted(exclusive, 1, "day")];
+};
+
+/** 年まで書いた二つの日付は、早いほうを始まりにする（「7月1日まで、4月1日から3か月」）。月日だけなら書いた順（年をまたぐことがある）。 */
+const ordered = (first: DatedValue, second: DatedValue, withYear: boolean): [DatedValue, DatedValue] =>
+  withYear && second.value < first.value ? [second, first] : [first, second];
+
+const mismatchOf = (written: readonly [DatedValue, DatedValue], duration: Duration): DurationMismatch | undefined => {
+  const [firstDate, secondDate] = [calendarDateOf(written[0].value), calendarDateOf(written[1].value)];
+  if (firstDate === undefined || secondDate === undefined || (firstDate.year === undefined) !== (secondDate.year === undefined)) return undefined;
+  const withYear = firstDate.year !== undefined;
+  const [start, end] = ordered(written[0], written[1], withYear);
+  const startDate = calendarDateOf(start.value);
+  if (startDate === undefined) return undefined;
+  const ends = expectedEnds(dateOf(startDate), duration);
+  const [inclusive] = ends;
+  if (inclusive === undefined || ends.some((candidate) => valueOf(candidate, withYear) === end.value)) return undefined;
+  return { start, duration, end, expected: valueOf(inclusive, withYear) };
+};
+
+/** 一つの文の中の、始まり・期間・終わり。 */
+export const durationMismatches = (sentences: readonly Span[], dates: readonly DatedValue[], durations: readonly Duration[]): DurationMismatch[] => {
+  const datesIn = bySentence(sentences, dates);
+  return [...bySentence(sentences, durations).entries()].flatMap(([index, inDurations]) => {
+    const inDates = datesIn.get(index) ?? [];
+    const [first, second] = inDates;
+    const [duration] = inDurations;
+    if (inDates.length !== 2 || inDurations.length !== 1 || first === undefined || second === undefined || duration === undefined) return [];
+    const mismatch = mismatchOf([first, second], duration);
+    return mismatch === undefined ? [] : [mismatch];
+  });
+};

package/src/derived/elapsed.ts

@@ -0,0 +1,125 @@
+import type { Span } from "../plugin.ts";
+import { bySentence } from "./sentence-buckets.ts";
+
+/**
+ * 起点の年から数えた年数（「2015年創業」と「創業10年」、「1980年生まれ」と「45歳」）を、文書の日付の年と比べる。
+ * 年数は、文書の年から起点の年を引いた数と、前後一年まで合えばよい（誕生日の前後、「10年目」の数え方）。それより離れていれば言う。
+ * 創業の年数は、起点の語のすぐ後ろか前に、つなぎの語（から、以来、since）だけを挟んで書いたもの（「創業10年」「設立から10年」）。
+ * 起点の年は同じ文の中で起点の語に一番近い年、無ければ文書の中で起点の語に付いた年（一通りのときだけ）。
+ * 年齢は、生まれた年と同じ文の年齢だけを比べる（文に生まれた年と年齢が一つずつのとき）。別の人の年齢と組にしないため。
+ */
+export type Year = Span & { readonly year: number };
+
+export type Elapsed = Span & { readonly amount: number };
+
+export type OriginWord = Span & { readonly pattern: string };
+
+export type ElapsedInput = {
+  readonly source: string;
+  readonly sentences: readonly Span[];
+  readonly years: readonly Year[];
+  /** 創業・設立・founded など、年数を数え始める語。 */
+  readonly foundings: readonly OriginWord[];
+  /** 生まれ・born など。 */
+  readonly births: readonly OriginWord[];
+  /** 年数（10年、20周年、10 years）。 */
+  readonly elapsed: readonly Elapsed[];
+  /** 年齢（45歳、aged 45）。 */
+  readonly ages: readonly Elapsed[];
+  /** 起点の語と年数のあいだに書いてよい語（から、以来、since）。何も挟まないのもよい。 */
+  readonly links: readonly string[];
+  /** 文書の日付の年。 */
+  readonly reference: number;
+};
+
+export type ElapsedMismatch = { readonly elapsed: Elapsed; readonly origin: Year; readonly expected: number };
+
+const TOLERANCE = 1;
+
+const distance = (left: Span, right: Span): number => Math.max(0, left.start - right.end, right.start - left.end);
+
+const nearest = <T extends Span>(spans: readonly T[], to: Span): T | undefined =>
+  spans.reduce<T | undefined>((best, span) => (best === undefined || distance(span, to) < distance(best, to) ? span : best), undefined);
+
+/** 起点の語と年数のあいだが、空か、つなぎの語だけ。 */
+const attached = (input: ElapsedInput, word: Span, amount: Span): boolean => {
+  const between = (word.end <= amount.start ? input.source.slice(word.end, amount.start) : input.source.slice(amount.end, word.start)).trim().toLowerCase();
+  return between === "" || input.links.some((link) => link.toLowerCase() === between);
+};
+
+const mismatchOf = (input: ElapsedInput, elapsed: Elapsed, origin: Year): ElapsedMismatch[] => {
+  const expected = input.reference - origin.year;
+  return expected >= 0 && Math.abs(elapsed.amount - expected) > TOLERANCE ? [{ elapsed, origin, expected }] : [];
+};
+
+/** 起点の年は、起点の語のすぐ近く（「2015年に創業」「founded in 2015」）に書いたものだけ。同じ文の遠い数（Model 2015）は年と読まない。 */
+const MAX_YEAR_DISTANCE = 6;
+
+/** 一つの文の中の、読んだものすべて。 */
+type InSentence = {
+  readonly years: readonly Year[];
+  readonly foundings: readonly OriginWord[];
+  readonly births: readonly OriginWord[];
+  readonly elapsed: readonly Elapsed[];
+  readonly ages: readonly Elapsed[];
+};
+
+const yearAt = (years: readonly Year[], word: Span): Year | undefined => {
+  const year = nearest(years, word);
+  return year !== undefined && distance(year, word) <= MAX_YEAR_DISTANCE ? year : undefined;
+};
+
+/** 文書の中で、起点の語（創業、設立、founded）に付いた年。一通りに決まらなければ undefined。 */
+const documentYear = (sentences: readonly InSentence[]): Year | undefined => {
+  const found = sentences.flatMap((sentence) =>
+    sentence.foundings.flatMap((word) => {
+      const year = yearAt(sentence.years, word);
+      return year === undefined ? [] : [year];
+    }),
+  );
+  return new Set(found.map((year) => year.year)).size === 1 ? found[0] : undefined;
+};
+
+const foundingMismatches = (input: ElapsedInput, sentence: InSentence, fallback: Year | undefined): ElapsedMismatch[] =>
+  sentence.elapsed.flatMap((elapsed) => {
+    const word = sentence.foundings.find((candidate) => attached(input, candidate, elapsed));
+    if (word === undefined) return [];
+    const origin = yearAt(sentence.years, word) ?? fallback;
+    return origin === undefined ? [] : mismatchOf(input, elapsed, origin);
+  });
+
+const ageMismatches = (input: ElapsedInput, sentence: InSentence): ElapsedMismatch[] => {
+  const [word] = sentence.births;
+  const [age] = sentence.ages;
+  if (sentence.births.length !== 1 || sentence.ages.length !== 1 || word === undefined || age === undefined) return [];
+  const origin = sentence.years.length === 1 ? sentence.years[0] : undefined;
+  return origin === undefined ? [] : mismatchOf(input, age, origin);
+};
+
+/** 文書の年より前の年だけを起点にする。文書の日付そのもの（「2026年4月1日現在、創業10年」）は起点ではない。 */
+const sentencesOf = (input: ElapsedInput): InSentence[] => {
+  const groups = {
+    years: bySentence(
+      input.sentences,
+      input.years.filter((year) => year.year < input.reference),
+    ),
+    foundings: bySentence(input.sentences, input.foundings),
+    births: bySentence(input.sentences, input.births),
+    elapsed: bySentence(input.sentences, input.elapsed),
+    ages: bySentence(input.sentences, input.ages),
+  };
+  const indexes = [...new Set([...groups.foundings.keys(), ...groups.births.keys()])].toSorted((left, right) => left - right);
+  return indexes.map((index) => ({
+    years: groups.years.get(index) ?? [],
+    foundings: groups.foundings.get(index) ?? [],
+    births: groups.births.get(index) ?? [],
+    elapsed: groups.elapsed.get(index) ?? [],
+    ages: groups.ages.get(index) ?? [],
+  }));
+};
+
+export const elapsedMismatches = (input: ElapsedInput): ElapsedMismatch[] => {
+  const sentences = sentencesOf(input);
+  const fallback = documentYear(sentences);
+  return sentences.flatMap((sentence) => [...foundingMismatches(input, sentence, fallback), ...ageMismatches(input, sentence)]);
+};

package/src/derived/relative-dates.ts

@@ -0,0 +1,96 @@
+import type { Span } from "../plugin.ts";
+import { calendarDateOf, dateOf, shifted, valueOf, type CalendarDate, type DurationUnit } from "./date-arithmetic.ts";
+
+/**
+ * 基準の日付からの相対で書いた日付（「10月2日に申し込み、3日後の10月5日に通知」"Applications open on May 1, 2026. Two weeks
+ * later, on May 15, 2026, …"）。相対の期間のすぐ後ろに書いた日付を、基準の日付に期間を足した（前なら引いた）日と比べる。
+ * 基準は、同じ文で相対の期間より前にある一番近い日付。文が相対の期間で始まる（「Two weeks later, …」）ときだけ、前の文の日付も
+ * 基準にする。基準と書いた日付の片方にしか年が無ければ、月日だけを比べる。
+ */
+export type DatedValue = Span & { readonly value: string };
+
+/** 「3日後」「two weeks later」: 期間と向き（後なら 1、前なら -1）。 */
+export type Relative = Span & { readonly amount: number; readonly unit: DurationUnit; readonly direction: 1 | -1 };
+
+export type RelativeMismatch = { readonly base: DatedValue; readonly relative: Relative; readonly target: DatedValue; readonly expected: string };
+
+export type RelativeInput = {
+  readonly source: string;
+  /** 文の始まりの昇順。 */
+  readonly sentences: readonly Span[];
+  /** 書いた順の日付。 */
+  readonly dates: readonly DatedValue[];
+  readonly relatives: readonly Relative[];
+  /** 相対の語と日付のあいだに書いてよい語（の、on）。空白と区切りの記号（、, (）は、いつでもよい。 */
+  readonly links: readonly string[];
+};
+
+const SEPARATORS = /[\s,、，(（:：]/gu;
+
+/** start の昇順の列で、start が offset 以上の最初の位置。二分探索で、相対の期間ごとに文書の頭から数え直さない。 */
+const firstAtOrAfter = (spans: readonly Span[], offset: number): number => {
+  let low = 0;
+  let high = spans.length;
+  while (low < high) {
+    const middle = (low + high) >> 1;
+    if ((spans[middle]?.start ?? Infinity) < offset) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+};
+
+const sentenceIndexOf = (sentences: readonly Span[], offset: number): number => {
+  const index = firstAtOrAfter(sentences, offset + 1) - 1;
+  const sentence = sentences[index];
+  return sentence !== undefined && offset < sentence.end ? index : -1;
+};
+
+/** 文の頭から相対の期間までに、空白と記号のほかに何も無い。 */
+const opensSentence = (source: string, sentence: Span, relative: Relative): boolean => !/[\p{L}\p{N}]/u.test(source.slice(sentence.start, relative.start));
+
+/** 相対の語のすぐ後ろの日付。あいだは区切りの記号と、つなぎの語だけ。 */
+const targetOf = (input: RelativeInput, relative: Relative): DatedValue | undefined => {
+  const next = input.dates[firstAtOrAfter(input.dates, relative.end)];
+  if (next === undefined) return undefined;
+  const between = input.source.slice(relative.end, next.start).replace(SEPARATORS, "").toLowerCase();
+  return between === "" || input.links.some((link) => link.replace(SEPARATORS, "").toLowerCase() === between) ? next : undefined;
+};
+
+/** 同じ文で、相対の期間より前にある一番近い日付。文の頭の相対の期間なら、前の文まで見る。 */
+const baseOf = (input: RelativeInput, relative: Relative): DatedValue | undefined => {
+  const index = sentenceIndexOf(input.sentences, relative.start);
+  const sentence = input.sentences[index];
+  if (sentence === undefined) return undefined;
+  const from = opensSentence(input.source, sentence, relative) ? (input.sentences[index - 1]?.start ?? sentence.start) : sentence.start;
+  const before = input.dates[firstAtOrAfter(input.dates, relative.start) - 1];
+  return before !== undefined && before.end <= relative.start && before.start >= from ? before : undefined;
+};
+
+/** 年の無い月日は、年を決めずに数えられない（2月28日の1日後は、うるう年なら2月29日）。考えられる年をすべて試す。 */
+const LEAP_YEAR = 2000;
+const COMMON_YEAR = 2001;
+
+const baseYears = (base: CalendarDate, target: CalendarDate): number[] => {
+  if (base.year !== undefined) return [base.year];
+  return target.year === undefined ? [LEAP_YEAR, COMMON_YEAR] : [target.year - 1, target.year, target.year + 1];
+};
+
+const mismatchOf = (base: DatedValue, relative: Relative, target: DatedValue): RelativeMismatch | undefined => {
+  const [baseDate, targetDate] = [calendarDateOf(base.value), calendarDateOf(target.value)];
+  if (baseDate === undefined || targetDate === undefined) return undefined;
+  const withYear = baseDate.year !== undefined && targetDate.year !== undefined;
+  const written = withYear ? target.value : valueOf(dateOf(targetDate), false);
+  const expected = baseYears(baseDate, targetDate).map((year) =>
+    valueOf(shifted(dateOf({ ...baseDate, year }), relative.amount * relative.direction, relative.unit), withYear),
+  );
+  const [shown] = expected;
+  return shown === undefined || expected.includes(written) ? undefined : { base, relative, target, expected: shown };
+};
+
+export const relativeMismatches = (input: RelativeInput): RelativeMismatch[] =>
+  input.relatives.flatMap((relative) => {
+    const target = targetOf(input, relative);
+    const base = baseOf(input, relative);
+    const mismatch = target === undefined || base === undefined ? undefined : mismatchOf(base, relative, target);
+    return mismatch === undefined ? [] : [mismatch];
+  });