chaffjs 0.26.0 → 0.27.1

package/src/ai-score/human-shares.ts

@@ -4,47 +4,47 @@ import type { HumanShares } from "./score.ts";
 /** On how many human documents of each genre group each AI-shape rule reported, at the genre's level. */
 export const HUMAN_SHARES: HumanShares = {
   "ai-tell": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    business: { documents: 78, fired: 0 },
-    docs: { documents: 20, fired: 0 },
+    business: { documents: 80, fired: 0 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 0 },
     literature: { documents: 13, fired: 0 },
     speech: { documents: 7, fired: 0 },
     technical: { documents: 26, fired: 0 },
   },
   "announcing-opener": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    business: { documents: 78, fired: 0 },
-    docs: { documents: 20, fired: 0 },
+    business: { documents: 80, fired: 0 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 0 },
     literature: { documents: 13, fired: 0 },
     speech: { documents: 7, fired: 0 },
     technical: { documents: 26, fired: 0 },
   },
   "assistant-residue": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    business: { documents: 78, fired: 0 },
-    docs: { documents: 20, fired: 0 },
+    business: { documents: 80, fired: 0 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 0 },
     literature: { documents: 13, fired: 0 },
     speech: { documents: 7, fired: 0 },
-    technical: { documents: 48, fired: 0 },
+    technical: { documents: 49, fired: 0 },
   },
   "bold-density": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    business: { documents: 78, fired: 1 },
-    docs: { documents: 20, fired: 0 },
+    business: { documents: 80, fired: 1 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 0 },
     literature: { documents: 13, fired: 0 },
     speech: { documents: 7, fired: 0 },
-    technical: { documents: 48, fired: 2 },
+    technical: { documents: 49, fired: 2 },
   },
   "bold-label-list": {
-    academic: { documents: 1, fired: 0 },
+    academic: { documents: 5, fired: 0 },
     blog: { documents: 14, fired: 0 },
     business: { documents: 39, fired: 0 },
     docs: { documents: 10, fired: 0 },
@@ -54,25 +54,25 @@ export const HUMAN_SHARES: HumanShares = {
     technical: { documents: 13, fired: 1 },
   },
   "chat-citation-residue": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    business: { documents: 78, fired: 0 },
-    docs: { documents: 20, fired: 0 },
+    business: { documents: 80, fired: 0 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 0 },
     literature: { documents: 13, fired: 0 },
     speech: { documents: 7, fired: 0 },
-    technical: { documents: 48, fired: 0 },
+    technical: { documents: 49, fired: 0 },
   },
   "closing-cliche": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    docs: { documents: 20, fired: 0 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 1 },
     literature: { documents: 13, fired: 0 },
     speech: { documents: 7, fired: 0 },
   },
   "colon-lead-in": {
-    academic: { documents: 1, fired: 0 },
+    academic: { documents: 5, fired: 0 },
     blog: { documents: 14, fired: 0 },
     business: { documents: 39, fired: 0 },
     docs: { documents: 10, fired: 0 },
@@ -82,110 +82,110 @@ export const HUMAN_SHARES: HumanShares = {
     technical: { documents: 13, fired: 1 },
   },
   "contrast-framing": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    business: { documents: 78, fired: 0 },
-    docs: { documents: 20, fired: 0 },
+    business: { documents: 80, fired: 0 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 0 },
     literature: { documents: 13, fired: 0 },
     speech: { documents: 7, fired: 0 },
     technical: { documents: 26, fired: 0 },
   },
   "emoji-density": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    business: { documents: 78, fired: 0 },
-    docs: { documents: 20, fired: 0 },
+    business: { documents: 80, fired: 0 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 0 },
     literature: { documents: 13, fired: 0 },
     speech: { documents: 7, fired: 0 },
-    technical: { documents: 48, fired: 0 },
+    technical: { documents: 49, fired: 0 },
   },
   "emoji-heading": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    business: { documents: 77, fired: 1 },
-    docs: { documents: 20, fired: 0 },
+    business: { documents: 78, fired: 1 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 28, fired: 0 },
     literature: { documents: 4, fired: 0 },
     speech: { documents: 7, fired: 0 },
   },
   "figurative-density": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    business: { documents: 78, fired: 0 },
-    docs: { documents: 20, fired: 0 },
+    business: { documents: 80, fired: 0 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 0 },
     literature: { documents: 13, fired: 0 },
     speech: { documents: 7, fired: 0 },
-    technical: { documents: 48, fired: 0 },
+    technical: { documents: 49, fired: 0 },
   },
   "no-em-dash": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    business: { documents: 78, fired: 2 },
-    docs: { documents: 20, fired: 0 },
+    business: { documents: 80, fired: 2 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 2 },
     literature: { documents: 13, fired: 2 },
     speech: { documents: 7, fired: 0 },
-    technical: { documents: 48, fired: 0 },
+    technical: { documents: 49, fired: 0 },
   },
   "padded-intro": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    business: { documents: 46, fired: 1 },
-    docs: { documents: 20, fired: 0 },
+    business: { documents: 47, fired: 1 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 0 },
     literature: { documents: 13, fired: 0 },
     speech: { documents: 7, fired: 0 },
   },
   "paragraph-length-variance": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    docs: { documents: 20, fired: 0 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 0 },
     literature: { documents: 13, fired: 1 },
     speech: { documents: 7, fired: 0 },
   },
   "rule-of-three": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    docs: { documents: 20, fired: 0 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 0 },
     literature: { documents: 13, fired: 0 },
     speech: { documents: 7, fired: 0 },
     technical: { documents: 26, fired: 0 },
   },
   "section-length-uniformity": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    docs: { documents: 20, fired: 0 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 0 },
     literature: { documents: 13, fired: 1 },
     speech: { documents: 7, fired: 0 },
     technical: { documents: 26, fired: 0 },
   },
   "sentence-rhythm": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    docs: { documents: 20, fired: 0 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 0 },
     literature: { documents: 13, fired: 1 },
     speech: { documents: 7, fired: 0 },
     technical: { documents: 26, fired: 1 },
   },
   "stock-transition": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    business: { documents: 78, fired: 0 },
-    docs: { documents: 20, fired: 0 },
+    business: { documents: 80, fired: 0 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 0 },
     literature: { documents: 13, fired: 0 },
     speech: { documents: 7, fired: 0 },
     technical: { documents: 26, fired: 0 },
   },
   "translationese-density": {
-    academic: { documents: 1, fired: 0 },
+    academic: { documents: 5, fired: 0 },
     blog: { documents: 14, fired: 0 },
     business: { documents: 39, fired: 0 },
     docs: { documents: 10, fired: 0 },
@@ -195,13 +195,13 @@ export const HUMAN_SHARES: HumanShares = {
     technical: { documents: 22, fired: 0 },
   },
   "unfilled-placeholder": {
-    academic: { documents: 6, fired: 0 },
+    academic: { documents: 10, fired: 0 },
     blog: { documents: 23, fired: 0 },
-    business: { documents: 78, fired: 1 },
-    docs: { documents: 20, fired: 0 },
+    business: { documents: 80, fired: 1 },
+    docs: { documents: 21, fired: 0 },
     legal: { documents: 35, fired: 0 },
     literature: { documents: 13, fired: 0 },
     speech: { documents: 7, fired: 0 },
-    technical: { documents: 48, fired: 0 },
+    technical: { documents: 49, fired: 0 },
   },
 };

package/src/capitals-with-small.ts

@@ -0,0 +1,23 @@
+// Words that start with two capitals or more and go on in small letters, where the capitals are not a spelling of the
+// plain word: a name in capitals with an English ending (SENDs, OPENed), or the letters of an acronym picked out in its
+// expansion (CLImatology and PERsistence for CLIPER: part of a longer acronym). A name written that way (HBase, RSpec,
+// SCIMple beside SCIM) is a spelling, and stays one.
+
+const CAPITALS_THEN_SMALL = /^(\p{Lu}{2,})\p{Ll}+$/u;
+const CAPITALS_WITH_ENDING = /^\p{Lu}{2,}(?:s|es|d|ed|ing)$/u;
+const CAPITALS_ONLY = /^\p{Lu}[\p{Lu}\d]+$/u;
+const LATIN_RUN = /[\p{L}\d]+/gu;
+
+/** The words of a stretch of text written in capitals only (CLIPER, CAMEX), which a picked-out expansion spells. */
+export const acronymsIn = (text: string): string[] => [...text.matchAll(LATIN_RUN)].map((match) => match[0]).filter((word) => CAPITALS_ONLY.test(word));
+
+const isPickedOut = (word: string, acronyms: readonly string[]): boolean => {
+  const capitals = CAPITALS_THEN_SMALL.exec(word)?.[1];
+  return capitals !== undefined && acronyms.some((acronym) => acronym.length > capitals.length && acronym.includes(capitals));
+};
+
+/**
+ * Whether a word is capitals with an ending, or the letters of an acronym among acronyms. A hyphenated word is compared
+ * as written: leaving it out for one part would hide a variant in another (GitHub-SENDs, Github-SENDs).
+ */
+export const isCapitalsNotSpelling = (word: string, acronyms: readonly string[]): boolean => CAPITALS_WITH_ENDING.test(word) || isPickedOut(word, acronyms);

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

@@ -0,0 +1,153 @@
+// 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"), the calendar years, and the lexicons change-direction,
+// change-base, change-target, change-break, percent-unit and amount-multiplier.
+import type { Detector, Finding, LexiconEntry, ProseDocument, Span, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { changeRateMismatches, type BaseMark, type Break, type Direction, type Figure, type Period, 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 };
+
+/** Where the words of a lexicon stand, less those inside a phrase of its "-not" lexicon ("up to 25%" is a ceiling). */
+const spansWithout = (doc: ProseDocument, entries: readonly LexiconEntry[], notLexicon: string): (Span & { readonly entry: LexiconEntry })[] => {
+  const not = patternsOf(doc, notLexicon).flatMap((phrase) => spansOf(doc.source, phrase));
+  return entries.flatMap((entry) =>
+    spansOf(doc.source, entry.pattern)
+      .filter((span) => !not.some((phrase) => phrase.start <= span.start && span.end <= phrase.end))
+      .map((span) => ({ ...span, entry })),
+  );
+};
+
+/** Lexicon change-direction, less the phrases of change-direction-not. */
+const directionsOf = (doc: ProseDocument): Direction[] =>
+  spansWithout(doc, doc.lexicons["change-direction"] ?? [], "change-direction-not").flatMap(({ start, end, entry }) => {
+    const sign = SIGNS[entry.group ?? ""];
+    return sign === undefined ? [] : [{ start, end, sign }];
+  });
+
+/** Lexicon change-break (「は」, "and"), less the phrases of change-break-not (「上がり」 holds が but starts no subject). */
+const breaksOf = (doc: ProseDocument): Break[] =>
+  spansWithout(doc, doc.lexicons["change-break"] ?? [], "change-break-not").map(({ start, end, entry }) => ({
+    start,
+    end,
+    beforeRateOnly: entry.group === "rate",
+  }));
+
+/** A calendar year written alone or with a unit of calendar year (2025, 2025年, 2025年度), and not part of an amount ($2025). */
+const CALENDAR_YEAR = /(?<!\d|\d[.,])(?:1[89]|2[01])\d{2}(?!\d|[.,]\d)/gu;
+
+const periodsOf = (doc: ProseDocument, figures: readonly Figure[]): Period[] => {
+  const yearUnits = new Set(patternsOf(doc, "calendar-year-unit").map((unit) => `${unit}|`));
+  const amounts = figures.filter((figure) => !yearUnits.has(figure.unit));
+  return [...doc.source.matchAll(CALENDAR_YEAR)].flatMap((match) => {
+    const span = { start: match.index, end: match.index + match[0].length };
+    return amounts.some((figure) => figure.start < span.end && span.start < figure.end) ? [] : [{ ...span, year: Number(match[0]) }];
+  });
+};
+
+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 figures = [...treeFigures(doc, nodes, units, multipliers), ...countedFigures(doc, taken, multipliers)];
+  const text = {
+    sentences: doc.sentences.map((sentence) => sentence.span),
+    figures,
+    rates: ratesOf(doc, nodes, units),
+    directions: directionsOf(doc),
+    marks: marksOf(doc, "change-base"),
+    targets: marksOf(doc, "change-target"),
+    periods: periodsOf(doc, figures),
+    breaks: breaksOf(doc),
+    source: doc.source,
+  };
+  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/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;
+};

package/src/detectors/orthographic-variant.ts

@@ -5,6 +5,7 @@ import { isKatakanaWord, stemOf } from "../long-vowel.ts";
 import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { nameSpans, touchesAny } from "../team-names.ts";
 import { furiganaSpans } from "../furigana.ts";
+import { acronymsIn, isCapitalsNotSpelling } from "../capitals-with-small.ts";
 
 /** A word found in the document: where it is, which sentence it is in, its key and spelling, and how it is written when that differs. */
 type Placed = KeyedWord & { readonly sentence: Sentence; readonly offset: number; readonly shown?: string };
@@ -150,17 +151,20 @@ const isPartOfAddress = (text: string, start: number, end: number): boolean =>
 
 /**
  * Latin words keyed without hyphens and case (e-mail and email, GitHub and Github). A word in capitals only (TEAMS, MAY) is
- * emphasis or an acronym, not a spelling of the word, and is left out.
+ * emphasis or an acronym, not a spelling of the word, and is left out; so are a name in capitals with an ending (SENDs) and
+ * the letters of an acronym of the sentence picked out (CLImatology for CLIPER).
  */
-const latinWords = (sentence: Sentence, isOpen: IsOpen, skip: ReadonlySet<string>): Placed[] =>
-  [...sentence.text.matchAll(LATIN_WORD)].flatMap((match): Placed[] => {
+const latinWords = (sentence: Sentence, isOpen: IsOpen, skip: ReadonlySet<string>): Placed[] => {
+  const acronyms = acronymsIn(sentence.text);
+  return [...sentence.text.matchAll(LATIN_WORD)].flatMap((match): Placed[] => {
     const word = match[0];
     const plain = word.toLowerCase().replaceAll("-", "");
     const end = match.index + word.length;
-    if (plain.length < MIN_LATIN_KEY || !LOWER.test(word) || skip.has(word.toLowerCase())) return [];
+    if (plain.length < MIN_LATIN_KEY || !LOWER.test(word) || isCapitalsNotSpelling(word, acronyms) || skip.has(word.toLowerCase())) return [];
     if (isPartOfAddress(sentence.text, match.index, end) || !isOpen(match.index, end)) return [];
     return [{ key: `latin|${plain}`, spelling: latinSpelling(word), shown: word, sentence, offset: sentence.span.start + match.index }];
   });
+};
 
 /** How the usual spelling is written where it first appears (gitHub is shown GitHub). */
 const shownUsual = (words: readonly Placed[], { word, usual }: OddSpelling<Placed>): string =>

package/src/detectors/registry/change-rate.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { changeRate } from "../change-rate.ts";
+
+export const detector: Detector = changeRate;

package/src/detectors/registry/version-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { versionMismatch } from "../version-mismatch.ts";
+
+export const detector: Detector = versionMismatch;

package/src/detectors/relative-dates.ts

@@ -4,6 +4,7 @@ import { overlapsAny, spanIndex } from "../compare/spans.ts";
 import type { DurationUnit } from "../derived/date-arithmetic.ts";
 import { relativeMismatches, type DatedValue, type Relative } from "../derived/relative-dates.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { dayWordFindings } from "./relative-day-words.ts";
 
 /** 期間の単位の語彙表。relative-year-unit は、向きの語が付くときだけ期間になる単位（「1年前」の年）。 */
 const DURATION_LEXICONS: readonly (readonly [string, DurationUnit])[] = [
@@ -96,7 +97,7 @@ export const relativeDateMismatch: Detector = (doc): Finding[] => {
     relatives: relativesOf(doc, amounts),
     links: patternsOf(doc, "relative-link"),
   };
-  return relativeMismatches(input).map((mismatch) => ({
+  const counted = relativeMismatches(input).map((mismatch): Finding => ({
     rule: "relative-date-mismatch",
     severity: "warning",
     line: 0,
@@ -110,4 +111,5 @@ export const relativeDateMismatch: Detector = (doc): Finding[] => {
       offset: mismatch.target.start,
     },
   }));
+  return [...counted, ...dayWordFindings(doc, dates)];
 };