chaffjs 0.27.1 → 0.28.0

package/rules/summary-fact-mismatch.yaml

@@ -11,8 +11,8 @@ name:
   en: A summary value that differs from the body
 
 why:
-  ja: 冒頭や「概要」の節は、本文を読まない人も読みます。そこに書いた値が本文と違うと、要約だけを読んだ人が間違った値を持ち帰ります。本文を直したあとに、要約を直し忘れると起きます。最初の見出しより前の文と、概要・要約・まとめの節の「項目：値」「項目は値です」を、本文の同じ項目の値と比べます。本文の値が一通りに揃っていて、要約の値がそれと違うときだけ指します。
-  en: 'The opening and the summary are read by people who never read the body. A value there that differs from the body sends them away with the wrong one. It happens when the body is corrected and the summary is not. Values written as "Item: value" or "The item is value" before the first heading, or in a section headed Summary, Abstract or Overview, are compared with the body''s values for the same item; it is pointed out only when the body gives one value throughout and the summary gives another.'
+  ja: 冒頭や「概要」の節は、本文を読まない人も読みます。そこに書いた値が本文と違うと、要約だけを読んだ人が間違った値を持ち帰ります。本文を直したあとに、要約を直し忘れると起きます。最初の見出しより前の文と、概要・要約・まとめの節の「項目：値」「項目は値です」を、本文の同じ項目の値と比べます。英語の文書では、名前の無い数も、数える動詞と数えるもの（We gained 52 new customers）が同じ本文の数と比べます。本文の値が一通りに揃っていて、要約の値がそれと違うときだけ指します。
+  en: 'The opening and the summary are read by people who never read the body. A value there that differs from the body sends them away with the wrong one. It happens when the body is corrected and the summary is not. Values written as "Item: value" or "The item is value" before the first heading, or in a section headed Summary, Abstract or Overview, are compared with the body''s values for the same item, and so is a count with no label, by the verb and the words of what it counts ("We gained 52 new customers"); it is pointed out only when the body gives one value throughout and the summary gives another.'
 
 message:
   ja: 冒頭・要約の「{label}」 {value} が、本文の {other} と違います

package/src/cli-text.ts

@@ -43,9 +43,10 @@ const USAGE_JA = `chaff — 文章の読みにくいところを見つけます
   chaff facts <file>                     compare が照合する事実を、書き直す前の控えとして一覧にする
   chaff outline <file> [<後>]            見出しの構成と形（見出しの数・節の平均の長さ・箇条書きの割合・太字）を測る。2 つなら前と後を並べる
   chaff ai-score <file>... [--format json]  AI らしさの簡易判定（低・中・高）。生成文に多い目印を、同じジャンルの人の文書と比べる（書いたのが AI かは判定しない）
-  chaff grade <items.jsonl> [--out <results.jsonl>] [--json]
+  chaff grade <items.jsonl> [--out <results.jsonl>] [--baseline <前の results.jsonl>] [--compact] [--json]
                                  AI の出力を JSONL でまとめて採点する（指摘の率・事実・引用・合否。何も送らない）
-  chaff fix-plan <file> [--json]         指摘をルールごとにまとめ、直す方向と確かめのコマンドを、書き直す人や AI 向けの計画にする（何も送らない）
+  chaff fix-plan <file> [--depth light|structure|register] [--json]
+                                 指摘をルールごとにまとめ、直す方向と確かめのコマンドを、書き直す人や AI 向けの計画にする（何も送らない）
   chaff rules                    ルールの一覧を、グループごとに表で出す（いまの段階つき）
   chaff rules --json             いまの設定とルールの説明を JSON で出す（AI に渡す用）
   chaff baseline <dir>           いまある指摘を棚上げする（既存の repo に入れるとき）
@@ -90,9 +91,10 @@ const USAGE_EN = `chaff — finds what makes writing hard to read. It never rewr
   chaff facts <file>                      list the facts compare checks, as an inventory to keep before a rewrite
   chaff outline <file> [<after>]          measure the outline and its shape (headings, average section length, text in lists, bold); two files side by side
   chaff ai-score <file>... [--format json]  quick AI-likeness score (low, medium, high): signs common in generated text against human documents of the genre (not a verdict on who wrote it)
-  chaff grade <items.jsonl> [--out <results.jsonl>] [--json]
+  chaff grade <items.jsonl> [--out <results.jsonl>] [--baseline <earlier results.jsonl>] [--compact] [--json]
                                  grade a JSONL file of model outputs (finding rates, facts, quotations, pass or fail; sends nothing)
-  chaff fix-plan <file> [--json]          a plan for whoever rewrites the file, a person or an AI: findings by rule, how to rewrite each, the checks to run after (sends nothing)
+  chaff fix-plan <file> [--depth light|structure|register] [--json]
+                                 a plan for whoever rewrites the file, a person or an AI: findings by rule, how to rewrite each, the checks to run after (sends nothing)
   chaff rules                    the rules as a table, by group, with the level each runs at now
   chaff rules --json             the current settings and what each rule is, as JSON (to give to an AI)
   chaff baseline <dir>           shelve today's findings (when adding chaff to an existing repository)

package/src/derived/number-word-counts.ts

@@ -0,0 +1,28 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+// A count written as a word before its unit ("twelve years", "Ten years"), which the tree does not read as a quantity.
+// Pure: the number words come in order from one (the lexicon count-number, the position is the number).
+
+export type WordCount = Span & { readonly amount: number };
+
+const alternation = (words: readonly string[]): string =>
+  words
+    .filter((word) => word !== "")
+    .map(escapeRegExp)
+    .join("|");
+
+/**
+ * Each number word standing as a word of its own, followed by one of the units after a space. A word joined to letters,
+ * digits or a dash on either side is the tail of a larger number (二十年's 十, "twenty-one years", "fortyten").
+ */
+export const numberWordCounts = (source: string, numberWords: readonly string[], units: readonly string[]): WordCount[] => {
+  const [words, unitWords] = [alternation(numberWords), alternation(units)];
+  if (words === "" || unitWords === "") return [];
+  const pattern = new RegExp(`(?<![\\p{L}\\p{N}\\p{Pd}])(${words})\\s+(?:${unitWords})(?![\\p{L}\\p{N}])`, "giu");
+  const lowered = numberWords.map((word) => word.toLowerCase());
+  return [...source.matchAll(pattern)].flatMap((match) => {
+    const position = lowered.indexOf((match[1] ?? "").toLowerCase());
+    return position < 0 ? [] : [{ start: match.index, end: match.index + match[0].length, amount: position + 1 }];
+  });
+};

package/src/detectors/amount-scale.ts

@@ -0,0 +1,63 @@
+// amount-scale-consistency: the reading half. The amounts are currency-notation's (the lexicon currency-notation says
+// how a currency is written); the words of scale and their values are the lexicon amount-multiplier (weight).
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { amountValue, scaleMixes, type ScaleWord, type ScaledAmount } from "../structure/amount-scale.ts";
+import { AMOUNT, amountsIn, formsOf, type WrittenAmount } from "./currency-notation.ts";
+import { quoteAround } from "./quote-around.ts";
+
+/** How far back a larger part of one amount may start (1億2,000万円 is read from 2,000万円). */
+const LEADING_REACH = 40;
+
+const scaleWordsOf = (doc: ProseDocument): ScaleWord[] =>
+  (doc.lexicons["amount-multiplier"] ?? []).flatMap((entry) => (entry.weight === undefined ? [] : [{ word: entry.pattern, value: entry.weight }]));
+
+/** The larger parts written right before an amount the currency notation read from its last part (1億 before 2,000万円). */
+const leadingParts = (text: string, offset: number, words: readonly ScaleWord[]): string => {
+  if (words.length === 0) return "";
+  const scales = words.map((word) => escapeRegExp(word.word)).join("|");
+  const before = text.slice(Math.max(0, offset - LEADING_REACH), offset);
+  return new RegExp(`(?<![0-9０-９.,，])(?:${AMOUNT}(?:${scales}))+$`, "u").exec(before)?.[0] ?? "";
+};
+
+/** The written amount without its currency mark, which is on the side its form says. */
+const numberPart = (amount: WrittenAmount): string => {
+  const [position = "", ...mark] = amount.form.split(":");
+  const pattern = mark.join(":");
+  return position === "before" ? amount.written.trimStart().slice(pattern.length) : amount.written.trimEnd().slice(0, -pattern.length);
+};
+
+/** The largest word of scale written in the number (万 in 1億2,000万 is smaller than 億), undefined when there is none. */
+const unitOf = (number: string, words: readonly ScaleWord[]): number | undefined => {
+  const lower = number.toLowerCase();
+  const values = words.filter((word) => lower.includes(word.word.toLowerCase())).map((word) => word.value);
+  return values.length === 0 ? undefined : Math.max(...values);
+};
+
+const scaledAmountsOf = (text: string, amounts: readonly WrittenAmount[], words: readonly ScaleWord[]): ScaledAmount[] =>
+  amounts.flatMap((amount) => {
+    const leading = amount.form.startsWith("after:") ? leadingParts(text, amount.offset, words) : "";
+    const written = `${leading}${amount.written}`;
+    const number = `${leading}${numberPart(amount)}`;
+    const value = amountValue(number, words);
+    if (value === undefined) return [];
+    return [{ offset: amount.offset - leading.length, written, currency: amount.currency, value, unit: unitOf(number, words) }];
+  });
+
+export const amountScale: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const words = scaleWordsOf(doc);
+  const amounts = amountsIn(
+    text,
+    formsOf(doc),
+    words.map((word) => word.word),
+  );
+  return scaleMixes(scaledAmountsOf(text, amounts, words)).map(({ odd, usual }) => ({
+    rule: "amount-scale-consistency",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, odd.offset, odd.offset + odd.written.length),
+    values: { written: odd.written.trim(), usual: usual.written.trim(), offset: odd.offset },
+  }));
+};

package/src/detectors/change-rate.ts

@@ -1,8 +1,9 @@
 // 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 type { Detector, Finding, LexiconEntry, ProseDocument, Span, StructureNode, Token } from "../plugin.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
+import { startsOtherSubject } from "../structure/subject-change.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";
@@ -99,12 +100,24 @@ const directionsOf = (doc: ProseDocument): Direction[] =>
     return sign === undefined ? [] : [{ start, end, sign }];
   });
 
+/** The sentence's tokens, and the index of the token that starts at offset (-1 when none does). */
+const tokenAt = (doc: ProseDocument, offset: number): { readonly tokens: readonly Token[]; readonly index: number } => {
+  const tokens = doc.sentences.find((sentence) => sentence.span.start <= offset && offset < sentence.span.end)?.tokens ?? [];
+  return { tokens, index: tokens.findIndex((token) => token.span.start === offset) };
+};
+
+/** A word that may join two values ("and") does not when another subject follows it ("and costs were"). */
+const joinsTwoValues = (doc: ProseDocument, start: number): boolean => {
+  const { tokens, index } = tokenAt(doc, start);
+  return index < 0 || !startsOtherSubject(tokens, index);
+};
+
 /** 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",
+    beforeRateOnly: entry.group === "rate" && joinsTwoValues(doc, start),
   }));
 
 /** A calendar year written alone or with a unit of calendar year (2025, 2025年, 2025年度), and not part of an amount ($2025). */

package/src/detectors/currency-notation.ts

@@ -14,7 +14,7 @@ export type WrittenAmount = { readonly offset: number; readonly written: string;
 /** 少ないほうの書き方の金額と、多いほうの書き方の例、その通貨の金額の数。 */
 export type CurrencyMinority = { readonly odd: WrittenAmount; readonly usual: string; readonly count: number; readonly of: number };
 
-const AMOUNT = "[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?";
+export const AMOUNT = "[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?";
 
 const alternation = (words: readonly string[]): string => words.map(escapeRegExp).join("|");
 
@@ -71,7 +71,7 @@ export const currencyMinorities = (amounts: readonly WrittenAmount[], limit: num
     )
     .toSorted((left, right) => left.odd.offset - right.odd.offset);
 
-const formsOf = (doc: ProseDocument): CurrencyForm[] =>
+export const formsOf = (doc: ProseDocument): CurrencyForm[] =>
   (doc.lexicons["currency-notation"] ?? []).flatMap((entry) =>
     entry.position === undefined || entry.group === undefined ? [] : [{ pattern: entry.pattern, position: entry.position, currency: entry.group }],
   );

package/src/detectors/derived-numbers.ts

@@ -5,6 +5,7 @@ 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";
 import { elapsedMismatches, type Elapsed, type OriginWord, type Year } from "../derived/elapsed.ts";
+import { numberWordCounts } from "../derived/number-word-counts.ts";
 import { quoteAt } from "./structure-tree.ts";
 
 /** 期間の単位の語彙表。木の数量の単位がどれかに入れば、その単位の期間。 */
@@ -122,8 +123,14 @@ const isAge = (doc: ProseDocument, quantity: Quantity): boolean =>
   positioned(doc, "age-marker", "before").some((word) => textBefore(doc, quantity).endsWith(word)) ||
   positioned(doc, "age-marker", "after").some((word) => textAfter(doc, quantity).startsWith(word));
 
-const elapsedOf = (doc: ProseDocument, quantities: readonly Quantity[]): Elapsed[] =>
-  quantities.filter((quantity) => !isAge(doc, quantity) && patternsOf(doc, "elapsed-unit").some((unit) => unit.normalize("NFKC") === quantity.unit));
+/** 年数: 単位が年数の語の数量（10 years、創業10年）と、木が読まない語で書いた数（ten years）。 */
+const elapsedOf = (doc: ProseDocument, quantities: readonly Quantity[]): Elapsed[] => {
+  const units = patternsOf(doc, "elapsed-unit");
+  const counted = quantities.filter((quantity) => !isAge(doc, quantity) && units.some((unit) => unit.normalize("NFKC") === quantity.unit));
+  const taken = spanIndex(quantities);
+  const worded = numberWordCounts(doc.source, patternsOf(doc, "count-number"), units).filter((count) => !overlapsAny(taken, count));
+  return [...counted, ...worded].toSorted((left, right) => left.start - right.start);
+};
 
 /** 「aged 45」の 45: 英語の木は単位の無い数を読まないので、年齢の印のすぐ後ろの数を読む。 */
 const AGE_NUMBER = /^\s*(\d{1,3})(?!\d)/u;

package/src/detectors/fact-consistency.ts

@@ -1,4 +1,5 @@
 import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.ts";
+import { countedFacts, countedPhraseAt, type CountedPhrase } from "../facts/counted-facts.ts";
 import { nameSpans } from "../compare/proper-nouns.ts";
 import { factValues, type FactValue } from "../facts/fact-values.ts";
 import { labelledFacts, type AttributePhrase, type FactWords } from "../facts/labelled-facts.ts";
@@ -50,5 +51,20 @@ const findingOf =
 /** 同じ節で、同じ名前に二通りの値（締切：10月5日 と 締切：10月7日）。 */
 export const factConflict: Detector = (doc): Finding[] => scopeConflicts(factsOf(doc)).map(findingOf("fact-conflict", doc));
 
+const countedPhrasesOf = (doc: ProseDocument): CountedPhrase[] =>
+  doc.sentences.flatMap((sentence) => {
+    const tokens = sentence.tokens ?? [];
+    return tokens.flatMap((token, index) => (token.pos === "NUM" ? countedPhraseAt(tokens, index) : []));
+  });
+
+/** The values named by what they count, scoped like the labelled ones. Only the summary is compared with them. */
+const countedFactsOf = (doc: ProseDocument): ScopedFact[] => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const values = factValues(tree, doc.source, nameSpans(doc));
+  return scopedFacts(countedFacts(doc.source, values, countedPhrasesOf(doc)), tree, doc.source, patternsOf(doc, "summary-heading"));
+};
+
 /** 冒頭や要約の値が、本文の同じ名前の値と違う。 */
-export const summaryFactMismatch: Detector = (doc): Finding[] => summaryConflicts(factsOf(doc)).map(findingOf("summary-fact-mismatch", doc));
+export const summaryFactMismatch: Detector = (doc): Finding[] =>
+  summaryConflicts([...factsOf(doc), ...countedFactsOf(doc)]).map(findingOf("summary-fact-mismatch", doc));

package/src/detectors/name-variant.ts

@@ -1,10 +1,19 @@
-import type { Detector, Finding } from "../plugin.ts";
-import { mentionsIn, nameVariants } from "../name-variants.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { mentionsIn, nameVariants, suffixedNamesIn, type VariantChars } from "../name-variants.ts";
 import { quoteAt } from "./structure-tree.ts";
 
+// 人の名前と読ませる敬称（様、さん）は語彙表 person-suffix、字体の違う同じ字（斎・斉・齋）は name-variant-char が組（group）ごとに言う。
+
+const variantCharsOf = (doc: ProseDocument): VariantChars =>
+  new Map((doc.lexicons["name-variant-char"] ?? []).flatMap((entry): [string, string][] => (entry.group === undefined ? [] : [[entry.pattern, entry.group]])));
+
 /** 同じ名前を、文書の中で少しだけ違う形に書いた所（GitHub と Github、山田太郎 と 山田太朗）。少ないほうを指す。 */
-export const nameVariant: Detector = (doc): Finding[] =>
-  nameVariants(doc.sentences.flatMap((sentence) => mentionsIn(sentence.tokens ?? [], doc.source))).map(({ mention, usual, kind }) => ({
+export const nameVariant: Detector = (doc): Finding[] => {
+  const suffixes = (doc.lexicons["person-suffix"] ?? []).map((entry) => entry.pattern);
+  const chars = variantCharsOf(doc);
+  const tagged = doc.sentences.flatMap((sentence) => mentionsIn(sentence.tokens ?? [], doc.source, suffixes));
+  const mentions = [...tagged, ...suffixedNamesIn(doc.prose ?? doc.source, suffixes, chars, tagged)].toSorted((left, right) => left.offset - right.offset);
+  return nameVariants(mentions, chars).map(({ mention, usual, kind }) => ({
     rule: "",
     severity: "warning",
     line: 0,
@@ -13,3 +22,4 @@ export const nameVariant: Detector = (doc): Finding[] =>
     values: { name: mention.surface, usual, offset: mention.offset },
     variant: kind,
   }));
+};

package/src/detectors/registry/amount-scale.ts

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

package/src/facts/counted-facts.ts

@@ -0,0 +1,59 @@
+import type { Span, Token } from "../plugin.ts";
+import type { FactValue } from "./fact-values.ts";
+import type { Fact } from "./labelled-facts.ts";
+
+// A value with no label, named by who counts, the verb that counts and what is counted ("We gained 52 new customers": we
+// + gain + new customer). A summary that states such a value is compared with the body's value for the same three. Pure:
+// reads the tagger's parts of speech and lemmas.
+
+/** The words right after a number that say what it counts, and the key of who counts it with which verb. */
+export type CountedPhrase = Span & { readonly label: string; readonly key: string };
+
+/** How many words after a number may name what it counts ("new enterprise customers"). */
+const MAX_COUNTED_WORDS = 3;
+const COUNTED_WORD: ReadonlySet<string> = new Set(["ADJ", "NOUN"]);
+const SUBJECT_WORD: ReadonlySet<string> = new Set(["NOUN", "PROPN", "PRON"]);
+/** A number right after a preposition is part of something larger: the pool in "1 of 3 proposals". */
+const NOT_A_COUNT_AFTER: ReadonlySet<string> = new Set(["ADP", "NUM"]);
+
+/** The number is the end of a range ("between 10 and 12 customers") or of a pair ("1 of 3"). */
+const isPartOfLarger = (tokens: readonly Token[], index: number): boolean => {
+  const [twoBefore, before] = [tokens[index - 2], tokens[index - 1]];
+  return NOT_A_COUNT_AFTER.has(before?.pos ?? "") || (before?.pos === "CCONJ" && twoBefore?.pos === "NUM");
+};
+
+const wordOf = (token: Token): string => (token.lemma ?? token.surface).toLowerCase();
+
+/** The adjectives and nouns right after the number at index, up to the last noun ("new customers"). */
+const countedWords = (tokens: readonly Token[], index: number): Token[] => {
+  const after = tokens.slice(index + 1, index + 1 + MAX_COUNTED_WORDS);
+  const stop = after.findIndex((token) => !COUNTED_WORD.has(token.pos));
+  const run = stop < 0 ? after : after.slice(0, stop);
+  return run.slice(0, run.findLastIndex((token) => token.pos === "NOUN") + 1);
+};
+
+/**
+ * What the number at index in a sentence's tokens counts: the words after it, the nearest verb before it, and the nearest
+ * noun or pronoun before that verb (who counts). None when one of the three is missing or the number is part of a larger one.
+ */
+export const countedPhraseAt = (tokens: readonly Token[], index: number): CountedPhrase[] => {
+  if (isPartOfLarger(tokens, index)) return [];
+  const words = countedWords(tokens, index);
+  const verbAt = tokens.slice(0, index).findLastIndex((token) => token.pos === "VERB");
+  const subject = tokens.slice(0, Math.max(0, verbAt)).findLast((token) => SUBJECT_WORD.has(token.pos));
+  const [first, last, verb] = [words[0], words.at(-1), tokens[verbAt]];
+  if (first === undefined || last === undefined || verb === undefined || subject === undefined) return [];
+  const key = ["counted", wordOf(subject), wordOf(verb), ...words.map(wordOf)].join("\u0000");
+  return [{ start: first.span.start, end: last.span.end, label: words.map((token) => token.surface).join(" "), key }];
+};
+
+/** A calendar year ("2026 revenue") is a point in time, not a count. */
+const YEAR = /^(?:1[89]|2[01])\d{2}$/u;
+
+/** The fact of each number with no unit that a counted phrase follows after one character (the space). */
+export const countedFacts = (source: string, values: readonly FactValue[], phrases: readonly CountedPhrase[]): Fact[] =>
+  values.flatMap((value) => {
+    if (value.kind !== "quantity" || value.unit !== "" || YEAR.test(source.slice(value.start, value.end))) return [];
+    const phrase = phrases.find((candidate) => candidate.start === value.end + 1);
+    return phrase === undefined ? [] : [{ label: phrase.label, key: phrase.key, value }];
+  });

package/src/name-variants.ts

@@ -1,13 +1,26 @@
 import type { Token } from "./plugin.ts";
+import { escapeRegExp } from "./orthography.ts";
 
 // 同じ名前（人・会社・製品）を、文書の中で少しだけ違う形に書いた所。どの形が正しいかは決めず、少ないほうを指す。
 // 三通りで同じ名前と見る。書き方の違いだけ（GitHub と Github、Mac OS と macOS）、読みが同じ（山田太郎 と 山田太朗）、
 // 英字の一字違い（Microsoft と Microsft）。一字違いは別の名前でもありうるので、多いほうが二度以上、少ないほうが一度だけのときに限る。
 
-/** words は名前の語（記号を除く）。読みが同じ二つの名前が、どの語で違うかを見るため。 */
-export type NameMention = { readonly surface: string; readonly offset: number; readonly reading: string | undefined; readonly words: readonly string[] };
+/**
+ * words は名前の語（記号を除く）。読みが同じ二つの名前が、どの語で違うかを見るため。person は人の名前と読めるもの（解析器が
+ * 人名と読むか、敬称が付く）。
+ */
+export type NameMention = {
+  readonly surface: string;
+  readonly offset: number;
+  readonly reading: string | undefined;
+  readonly words: readonly string[];
+  readonly person?: boolean;
+};
+
+export type NameVariant = { readonly mention: NameMention; readonly usual: string; readonly kind: "spelling" | "reading" | "near" | "character" };
 
-export type NameVariant = { readonly mention: NameMention; readonly usual: string; readonly kind: "spelling" | "reading" | "near" };
+/** 字体の違う同じ字（斎・斉・齋）。字から、その組の代表の字へ。 */
+export type VariantChars = ReadonlyMap<string, string>;
 
 const NAME = "PROPN";
 /**
@@ -58,11 +71,18 @@ const withoutEdgeQuotes = (text: string): string => {
  */
 const NOT_COMPARED = /@|(?:^|\s)\p{L}(?:\s|$)/u;
 
+/** 人名と読む解析器の印（UD の NameType: 姓 Sur、名 Giv、どちらとも言えない人名 Prs）。 */
+const PERSON_TYPES: ReadonlySet<string> = new Set(["Sur", "Giv", "Prs"]);
+
+/** 人の名前か。解析器が人名と読む語を含むか、すぐ後ろに敬称（様、さん、氏）が付く。 */
+const isPerson = (run: readonly Token[], next: Token | undefined, suffixes: readonly string[]): boolean =>
+  run.some((token) => PERSON_TYPES.has(token.features?.["NameType"] ?? "")) || (next !== undefined && suffixes.includes(next.surface));
+
 /**
  * 文の語から、名前の現れ。surface は source の上の書いたまま（折り返しの空白は一つにまとめる）。
  * 大文字だけの名前（ACME INC、NASA）は外す。契約書の署名欄や略語で、ふつうの書き方の別の形ではない。小文字の英字だけの語も外す。
  */
-export const mentionsIn = (tokens: readonly Token[], source: string): NameMention[] =>
+export const mentionsIn = (tokens: readonly Token[], source: string, personSuffixes: readonly string[] = []): NameMention[] =>
   runsOf(tokens).flatMap((run) => {
     const first = run[0];
     const last = run.at(-1);
@@ -73,9 +93,39 @@ export const mentionsIn = (tokens: readonly Token[], source: string): NameMentio
     const words = run.filter((token) => !JOINERS.has(token.surface));
     const readings = words.map((token) => token.reading);
     const reading = readings.every((value) => value !== undefined && value !== "") ? readings.join("") : undefined;
-    return [{ surface, offset: first.span.start, reading, words: words.map((token) => token.surface) }];
+    const person = isPerson(run, tokens[tokens.indexOf(last) + 1], personSuffixes);
+    return [{ surface, offset: first.span.start, reading, words: words.map((token) => token.surface), person }];
   });
 
+/** 敬称の前の名前の字数（髙橋、髙橋太郎）。長い漢字の連なり（株式会社髙橋）は名前だけを切り出せない。 */
+const MAX_SUFFIXED_NAME = 4;
+const MIN_SUFFIXED_NAME = 2;
+/** 敬称の前を読む範囲（UTF-16 の単位）。名前より長い漢字の連なりを、長いまま見るため。 */
+const SUFFIX_LOOKBACK = 20;
+const HAN = /^\p{Script=Han}$/u;
+
+/** 文字列の終わりの漢字の連なり。 */
+const trailingHan = (text: string): string => {
+  const letters = [...text];
+  return letters.slice(letters.findLastIndex((letter) => !HAN.test(letter)) + 1).join("");
+};
+
+/**
+ * 解析器が名前と読めなかった、字体の違う字を含む人の名前（髙橋様、𠮷田様、﨑山様）。敬称のすぐ前の漢字の連なりで、語彙表の字を
+ * 含み、ほかの名前の現れと重ならないもの。
+ */
+export const suffixedNamesIn = (source: string, suffixes: readonly string[], chars: VariantChars, taken: readonly NameMention[]): NameMention[] =>
+  suffixes.flatMap((suffix) =>
+    [...source.matchAll(new RegExp(escapeRegExp(suffix), "gu"))].flatMap((match) => {
+      const run = trailingHan(source.slice(Math.max(0, match.index - SUFFIX_LOOKBACK), match.index));
+      const length = [...run].length;
+      if (length < MIN_SUFFIXED_NAME || length > MAX_SUFFIXED_NAME || ![...run].some((letter) => chars.has(letter))) return [];
+      const offset = match.index - run.length;
+      if (taken.some((mention) => mention.offset < match.index && offset < mention.offset + mention.surface.length)) return [];
+      return [{ surface: run, offset, reading: undefined, words: [run], person: true }];
+    }),
+  );
+
 /** 比べる形。幅（ＡＷＳ と AWS）、大文字小文字、空白と記号は名前を変えない。 */
 export const nameKey = (surface: string): string =>
   surface
@@ -83,14 +133,19 @@ export const nameKey = (surface: string): string =>
     .toLowerCase()
     .replaceAll(/[\s\p{P}\p{S}]/gu, "");
 
-type Tally = { readonly surface: string; readonly first: NameMention; readonly count: number };
+/** person: どれかの現れが人の名前と読める。 */
+type Tally = { readonly surface: string; readonly first: NameMention; readonly count: number; readonly person: boolean };
 
 const talliesOf = (mentions: readonly NameMention[]): Tally[] => {
-  const tallies = new Map<string, { surface: string; first: NameMention; count: number }>();
+  const tallies = new Map<string, { surface: string; first: NameMention; count: number; person: boolean }>();
   mentions.forEach((mention) => {
     const tally = tallies.get(mention.surface);
-    if (tally === undefined) tallies.set(mention.surface, { surface: mention.surface, first: mention, count: 1 });
-    else tally.count += 1;
+    const person = mention.person === true;
+    if (tally === undefined) tallies.set(mention.surface, { surface: mention.surface, first: mention, count: 1, person });
+    else {
+      tally.count += 1;
+      tally.person ||= person;
+    }
   });
   return [...tallies.values()];
 };
@@ -191,8 +246,46 @@ const isSlipOf = (tally: Tally, other: Tally): boolean => {
 
 const nearVariants = (tallies: readonly Tally[]): NameVariant[] => variantsIn(groupBy(tallies, maskedKeys), "near", isSlipOf);
 
-/** 同じ名前の、少ないほうの書き方。書き方ごとに最初の現れを一つ。同じ現れを二つの見方が言えば、先の見方だけ。 */
-export const nameVariants = (mentions: readonly NameMention[]): NameVariant[] => {
+/** 字体の違う字（斎と斉）を組の代表の字に寄せた形。 */
+const characterKey = (tally: Tally, chars: VariantChars): string => [...tally.surface].map((letter) => chars.get(letter) ?? letter).join("");
+
+/** 人の名前を、字体の違う同じ字（斎藤 と 斉藤、渡辺 と 渡邊）で書き分けた所。 */
+const characterVariants = (tallies: readonly Tally[], chars: VariantChars): NameVariant[] =>
+  variantsIn(
+    groupBy(
+      tallies.filter((tally) => tally.person),
+      (tally) => [characterKey(tally, chars)],
+    ),
+    "character",
+  );
+
+/** 字数が同じで、一字だけが違う（松本 と 松元）。 */
+const oneCharApart = (left: string, right: string): boolean => {
+  const [leftChars, rightChars] = [[...left], [...right]];
+  return leftChars.length === rightChars.length && leftChars.filter((char, index) => char !== rightChars[index]).length === 1;
+};
+
+/**
+ * 読みが同じ人の名前が、一字だけ違う（松本 と 松元）。読みの同じ別の姓（伊藤 と 伊東）もあるので、多いほうが二度以上、
+ * 少ないほうが一度だけのときに限る。
+ */
+const isPersonSlipOf = (tally: Tally, other: Tally): boolean => tally.count === 1 && other.count >= 2 && oneCharApart(tally.surface, other.surface);
+
+const personReadingVariants = (tallies: readonly Tally[]): NameVariant[] =>
+  variantsIn(
+    groupBy(
+      tallies.filter((tally) => tally.person),
+      (tally) => (tally.first.reading === undefined ? [] : [tally.first.reading]),
+    ),
+    "reading",
+    isPersonSlipOf,
+  );
+
+/**
+ * 同じ名前の、少ないほうの書き方。書き方ごとに最初の現れを一つ。同じ現れを二つの見方が言えば、先の見方だけ。chars は字体の
+ * 違う同じ字の組（語彙表 name-variant-char）。
+ */
+export const nameVariants = (mentions: readonly NameMention[], chars: VariantChars = new Map()): NameVariant[] => {
   const tallies = talliesOf(mentions);
   const found = [
     ...variantsIn(
@@ -205,6 +298,8 @@ export const nameVariants = (mentions: readonly NameMention[]): NameVariant[] =>
       oneWordApart,
     ),
     ...nearVariants(tallies),
+    ...characterVariants(tallies, chars),
+    ...personReadingVariants(tallies),
   ];
   const reported = new Set<string>();
   return found

package/src/structure/amount-scale.ts

@@ -0,0 +1,97 @@
+// An amount written in digits where the document writes amounts of that size with a word of scale, or the other way
+// round (250,000円 beside 30万円; $2,500,000 beside $1.5 million). Small amounts in digits and large ones with 万 or
+// million is one way of writing, not a mix, so only amounts of the same order of magnitude are compared. Pure.
+
+/**
+ * One amount: where it is, as written, its currency, its value, and the largest word of scale it was written with (unit:
+ * 10000 for 30万円, 1000000 for $1.5 million), undefined when it was written in digits only.
+ */
+export type ScaledAmount = {
+  readonly offset: number;
+  readonly written: string;
+  readonly currency: string;
+  readonly value: number;
+  readonly unit: number | undefined;
+};
+
+/** The amount written the other way, and the first one of its size written the usual way. */
+export type ScaleMix = { readonly odd: ScaledAmount; readonly usual: ScaledAmount };
+
+/** A digit amount with more significant digits than this (1,234,567円) is a precise figure no word of scale would write. */
+const MAX_SIGNIFICANT_DIGITS = 3;
+
+const significantDigits = (value: number): number => {
+  const digits = [...String(value).replace(".", "")];
+  const first = digits.findIndex((digit) => digit !== "0");
+  return first < 0 ? 0 : digits.findLastIndex((digit) => digit !== "0") - first + 1;
+};
+
+const isScaled = (amount: ScaledAmount): boolean => amount.unit !== undefined;
+
+/**
+ * Whether the amount could be written the other way. A digit one when it is round (250,000, not 250,500); a scaled one when
+ * it is at least one of its unit: "£0.2 million" is written to line up with larger amounts beside it, not to give a size.
+ */
+const comparable = (amount: ScaledAmount): boolean =>
+  amount.value > 0 && (amount.unit === undefined ? significantDigits(amount.value) <= MAX_SIGNIFICANT_DIGITS : amount.value >= amount.unit);
+
+/** The order of magnitude, from the digits of the whole part (Math.log10 is not exact at every power of ten). */
+const magnitudeOf = (value: number): number => String(Math.floor(value)).length - 1;
+
+const countScaled = (amounts: readonly ScaledAmount[]): number => amounts.filter(isScaled).length;
+
+/** Whether the scaled way is the odd one in a size: the fewer there, then the fewer at that size and above, then the later. */
+const oddIsScaled = (band: readonly ScaledAmount[], larger: readonly ScaledAmount[]): boolean => {
+  const scaledInBand = countScaled(band);
+  if (scaledInBand * 2 !== band.length) return scaledInBand * 2 < band.length;
+  const scaledLarger = countScaled(larger);
+  if (scaledLarger * 2 !== larger.length) return scaledLarger * 2 < larger.length;
+  const firstScaled = band.findIndex(isScaled);
+  const firstDigits = band.findIndex((amount) => !isScaled(amount));
+  return firstScaled > firstDigits;
+};
+
+const mixesOfCurrency = (amounts: readonly ScaledAmount[]): ScaleMix[] => {
+  const magnitudes = [...new Set(amounts.map((amount) => magnitudeOf(amount.value)))];
+  return magnitudes.flatMap((magnitude) => {
+    const band = amounts.filter((amount) => magnitudeOf(amount.value) === magnitude);
+    const scaledIsOdd = oddIsScaled(
+      band,
+      amounts.filter((amount) => magnitudeOf(amount.value) >= magnitude),
+    );
+    const usual = band.find((amount) => isScaled(amount) !== scaledIsOdd);
+    if (usual === undefined) return [];
+    return band.filter((amount) => isScaled(amount) === scaledIsOdd).map((amount) => ({ odd: amount, usual }));
+  });
+};
+
+/** For each currency, the amounts written the other way from the rest of their order of magnitude, in document order. */
+export const scaleMixes = (amounts: readonly ScaledAmount[]): ScaleMix[] => {
+  const ordered = amounts.filter(comparable).toSorted((left, right) => left.offset - right.offset);
+  return [...new Set(ordered.map((amount) => amount.currency))]
+    .flatMap((currency) => mixesOfCurrency(ordered.filter((amount) => amount.currency === currency)))
+    .toSorted((left, right) => left.odd.offset - right.odd.offset);
+};
+
+/** A word of scale and the value it multiplies by (万 10000, million 1000000). */
+export type ScaleWord = { readonly word: string; readonly value: number };
+
+const NUMBER_THEN_WORD = /(\d+(?:,\d{3})*(?:\.\d+)?)\s?([^\s\d.,]*)/gu;
+
+/**
+ * The value of an amount as written, without its currency: 1億2,000万 is 120000000, 1.5 million is 1500000. Undefined when a
+ * part is followed by a word that is not one of scale, or nothing is read.
+ */
+export const amountValue = (written: string, words: readonly ScaleWord[]): number | undefined => {
+  const parts = [...written.normalize("NFKC").matchAll(NUMBER_THEN_WORD)];
+  if (parts.length === 0) return undefined;
+  const values = parts.map((part) => {
+    const number = Number((part[1] ?? "").replaceAll(",", ""));
+    const word = (part[2] ?? "").toLowerCase();
+    if (word === "") return number;
+    const scale = words.find((entry) => entry.word.toLowerCase() === word);
+    return scale === undefined ? Number.NaN : number * scale.value;
+  });
+  const total = values.reduce((sum, value) => sum + value, 0);
+  return Number.isFinite(total) ? total : undefined;
+};