chaffjs 0.32.0 → 0.34.0

package/src/detectors/fact-consistency.ts

@@ -2,7 +2,7 @@ import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.
 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 Fact, type FactWords } from "../facts/labelled-facts.ts";
+import { attributePhrasesOf, labelledFacts, type Fact, type FactWords } from "../facts/labelled-facts.ts";
 import { tableFacts, type TotalColumns } from "../facts/table-facts.ts";
 import { withCellKeys } from "../facts/cell-keys.ts";
 import { verbQuantityFacts, type VerbQuantityWords } from "../facts/verb-quantity-facts.ts";
@@ -21,11 +21,13 @@ import { overlapsAny, spanIndex } from "../compare/spans.ts";
 import { documentTermConflicts, isTermName, termHomes, type TermWord, type TermWords } from "../facts/document-terms.ts";
 import { termValues, type PlacedWord, type TermValueWords } from "../facts/term-values.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
-import { ageValues, type AgeWord, type AgeWords } from "../facts/age-values.ts";
+import { ageValues } from "../facts/age-values.ts";
+import { ageWordsOf } from "./age-words.ts";
 import { qualifiedKeyOf, qualifiedKeys, type QualifierWords } from "../facts/qualified-labels.ts";
 import { rowSentenceFindings } from "./row-sentence-amounts.ts";
 import type { RateWord, RateWords } from "../facts/rate-values.ts";
 import { wholeCountFindings } from "./whole-count-findings.ts";
+import { perUnitsOf, perUnitValues } from "./per-unit-words.ts";
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
@@ -51,7 +53,7 @@ export const factWordsOf = (doc: ProseDocument): FactWords => ({
   leads: patternsOf(doc, "fact-label-lead"),
   rates: rateWordsOf(doc),
   readings: { verbs: patternsOf(doc, "fact-reading-verb"), gauges: patternsOf(doc, "fact-reading-gauge"), clauses: patternsOf(doc, "fact-reading-clause") },
-  attributes: (doc.lexicons["fact-attribute"] ?? []).map((entry): AttributePhrase => ({ pattern: entry.pattern, position: entry.position ?? "before" })),
+  attributes: attributePhrasesOf(doc.lexicons["fact-attribute"] ?? []),
 });
 
 const placedWordsOf = (doc: ProseDocument, id: string): PlacedWord[] =>
@@ -71,6 +73,10 @@ const termValueWordsOf = (doc: ProseDocument): TermValueWords => ({
   selves: placedWordsOf(doc, "fact-term-self"),
   starts: placedWordsOf(doc, "fact-term-start"),
   valueEnds: patternsOf(doc, "fact-value-end"),
+  restating: patternsOf(doc, "fact-term-restating"),
+  frames: patternsOf(doc, "fact-term-frame"),
+  conditions: patternsOf(doc, "fact-amount-condition"),
+  qualifiers: qualifierWordsOf(doc),
 });
 
 const totalColumnsOf = (doc: ProseDocument): TotalColumns => {
@@ -89,15 +95,6 @@ const durationWordsOf = (doc: ProseDocument): DurationWord[] => [
   ),
 ];
 
-const ageWordsAt = (doc: ProseDocument, id: string): AgeWord[] =>
-  (doc.lexicons[id] ?? []).map((entry): AgeWord => ({ pattern: entry.pattern, position: entry.position ?? "before" }));
-
-const ageWordsOf = (doc: ProseDocument): AgeWords => ({
-  marks: ageWordsAt(doc, "fact-age-mark"),
-  limits: ageWordsAt(doc, "fact-age-limit"),
-  joiners: patternsOf(doc, "fact-age-joiner"),
-});
-
 const qualifierWordsOf = (doc: ProseDocument): QualifierWords => ({
   templates: patternsOf(doc, "fact-label-qualifier"),
   determiners: patternsOf(doc, "fact-label-drop"),
@@ -123,6 +120,7 @@ const withQualifiedKeys = <T extends Fact>(doc: ProseDocument, facts: readonly T
 /**
  * 単位の語彙表の量（410 g、1.2 kg）と期間（3 months）と年齢（満70歳まで、aged 20 to 70）も値として読む。木が単位を読まない量は、
  * 数だけでは升や文の値にならない。年齢と重なる期間（30 years old の 30 years）と、期間と重なる量（3 months の 3 m）は読まない。
+ * 数量には何あたりか（1kmあたり15円）を付ける。何あたりの値は、それを掛けた金額とは比べない。
  */
 const readFacts = (doc: ProseDocument, tree: StructureNode): ScopedFact[] => {
   const tagged = factValues(tree, doc.source, nameSpans(doc));
@@ -134,7 +132,7 @@ const readFacts = (doc: ProseDocument, tree: StructureNode): ScopedFact[] => {
     durationWordsOf(doc),
   );
   const taken = spanIndex([...ages, ...durations]);
-  const values = valuesWith(tree, doc, [...measuredOf(doc).filter((value) => !overlapsAny(taken, value)), ...ages, ...durations]);
+  const values = perUnitsOf(doc, valuesWith(tree, doc, [...measuredOf(doc).filter((value) => !overlapsAny(taken, value)), ...ages, ...durations]));
   const terms = termValues(doc.source, values, termValueWordsOf(doc));
   const termed = new Set(terms.map((fact) => fact.value.start));
   const labelled = labelledFacts(doc.source, values, { ...factWordsOf(doc), qualifiers: qualifierWordsOf(doc) }).filter(
@@ -263,8 +261,7 @@ const countedPhrasesOf = (doc: ProseDocument): CountedPhrase[] =>
 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"));
+  return scopedFacts(countedFacts(doc.source, perUnitValues(doc, tree), countedPhrasesOf(doc)), tree, doc.source, patternsOf(doc, "summary-heading"));
 };
 
 const wordsAt = (doc: ProseDocument, id: string): WordAt[] =>
@@ -319,8 +316,7 @@ const pairFinding =
 const conditionPairFindings = (doc: ProseDocument): Finding[] => {
   const tree = doc.structure;
   if (tree === undefined) return [];
-  const values = factValues(tree, doc.source, nameSpans(doc));
-  return conditionPairConflicts(doc.source, changeSentencesOf(doc, tree), values, changeWordsOf(doc)).map(pairFinding(doc));
+  return conditionPairConflicts(doc.source, changeSentencesOf(doc, tree), perUnitValues(doc, tree), changeWordsOf(doc)).map(pairFinding(doc));
 };
 
 const eventWordsOf = (doc: ProseDocument): EventWord[] =>

package/src/detectors/form-line.ts

@@ -0,0 +1,47 @@
+// Lines at the top of a form or a letter that are not sentences: a field ("Invoice number: INV-2026-0318",
+// 「見積番号：RF-731852」) or a name standing alone (a letterhead, 「有限会社つばめ野リフォーム」). Pure.
+import { labelLine } from "./number-unit.ts";
+import type { Token } from "../plugin.ts";
+
+/** Parts of speech a name is made of: no verb, adjective, determiner or particle. */
+const NAME_POS: ReadonlySet<string> = new Set(["NOUN", "PROPN", "NUM", "PUNCT", "SYM", "X"]);
+/** A value with one of these says something ("Note: this page is a sample."); it is a sentence behind a label. */
+const PREDICATE_POS: ReadonlySet<string> = new Set(["VERB", "AUX"]);
+
+const isNameOnly = (tokens: readonly Token[]): boolean => tokens.some((token) => token.pos !== "PUNCT") && tokens.every((token) => NAME_POS.has(token.pos));
+
+/** "Label: value" whose value states nothing: a number, a date, a name. */
+const isField = (line: string, start: number, tokens: readonly Token[]): boolean => {
+  const field = labelLine(line, start);
+  return field !== undefined && !tokens.some((token) => token.span.start >= field.at && PREDICATE_POS.has(token.pos));
+};
+
+type Line = { readonly text: string; readonly start: number };
+
+const linesOf = (text: string, start: number): Line[] =>
+  text.split("\n").reduce<Line[]>((lines, line) => {
+    const last = lines.at(-1);
+    return [...lines, { text: line, start: last === undefined ? start : last.start + last.text.length + 1 }];
+  }, []);
+
+const isFormLine = (line: Line, tokens: readonly Token[]): boolean => {
+  const inLine = tokens.filter((token) => token.span.start >= line.start && token.span.start < line.start + line.text.length);
+  return isNameOnly(inLine) || isField(line.text, line.start, inLine);
+};
+
+/**
+ * Every line of the block gives a field and its value, or only a name: the top of a form or a letterhead, not a sentence.
+ * `start` is where the text starts in the coordinates of the tokens' spans. Without tokens no block is read as a form.
+ */
+export const isFormBlock = (text: string, start: number, tokens: readonly Token[] | undefined): boolean => {
+  const lines = linesOf(text, start).filter((line) => line.text.trim() !== "");
+  return tokens !== undefined && lines.length > 0 && lines.every((line) => isFormLine(line, tokens));
+};
+
+/** What a form block gives: the tokens after each field's label, and every token of a name line. */
+export const formValueTokens = (text: string, start: number, tokens: readonly Token[]): Token[] =>
+  linesOf(text, start).flatMap((line) => {
+    const field = labelLine(line.text, line.start);
+    const from = field?.at ?? line.start;
+    return tokens.filter((token) => token.span.start >= from && token.span.start < line.start + line.text.length);
+  });

package/src/detectors/formula-amount.ts

@@ -0,0 +1,43 @@
+// formula-amount-mismatch: the reading half. The words of a formula come from the lexicon formula-amount-word (name-rate,
+// rate-name, plus, not-included) and percent-unit; the tax words are tax-price-column's, as tax-mismatch reads them, with tax-label and
+// tax-included-word for a tax named as included (消費税8%込み). The amounts are
+// currency-notation's, read with amount-multiplier's words of scale. The profile may give the tax rate a document leaves out.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { formulaAmountMismatches, type FormulaWords } from "../structure/formula-amount.ts";
+import type { TaxPriceRole, TaxPriceWord } from "../structure/tax-price.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAround } from "./quote-around.ts";
+import { statedAmountsOf } from "./stated-amounts.ts";
+
+const TAX_ROLES: readonly string[] = ["excluded", "included", "rate"] satisfies readonly TaxPriceRole[];
+const isTaxRole = (group: string | undefined): group is TaxPriceRole => group !== undefined && TAX_ROLES.includes(group);
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
+
+const taxWordsOf = (doc: ProseDocument): TaxPriceWord[] =>
+  (doc.lexicons["tax-price-column"] ?? []).flatMap((entry) => (isTaxRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : []));
+
+const wordsOf = (doc: ProseDocument): FormulaWords => ({
+  nameRate: patternsOf(doc, "formula-amount-word", "name-rate"),
+  rateName: patternsOf(doc, "formula-amount-word", "rate-name"),
+  plus: patternsOf(doc, "formula-amount-word", "plus"),
+  percent: patternsOf(doc, "percent-unit"),
+  tax: taxWordsOf(doc),
+  taxNames: patternsOf(doc, "tax-label"),
+  includedWords: patternsOf(doc, "tax-included-word"),
+  notIncluded: patternsOf(doc, "formula-amount-word", "not-included"),
+});
+
+export const formulaAmount: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  const input = { text, amounts: statedAmountsOf(text, doc), defaultTaxRate: doc.profile?.taxRate };
+  return formulaAmountMismatches(input, wordsOf(doc)).map((issue) => ({
+    rule: "formula-amount-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/heading-claim.ts

@@ -0,0 +1,76 @@
+// Whether a first sentence says something about its heading's subject, rather than announcing or restating it. Pure;
+// heading-echo reads it. The words that only announce or point (covers, below, 説明, 以下), the copulas and the
+// negations come from the language package's heading-announcer lexicon.
+import { isContent } from "./content-morphemes.ts";
+import type { LexiconEntry, Token } from "../plugin.ts";
+
+type Side = "before" | "after";
+
+export type AnnouncerWords = {
+  /** Words that announce the section or point at it: they carry no claim of their own. */
+  readonly announcing: ReadonlySet<string>;
+  /** Copulas (be, です), each with the side its complement stands on. */
+  readonly copulas: ReadonlyMap<string, Side>;
+  /** Words that deny what a copula links (There are no issues, is not in the manual): the denial is the claim. */
+  readonly negations: ReadonlySet<string>;
+};
+
+const patternsOf = (entries: readonly LexiconEntry[], group: string | undefined): Set<string> =>
+  new Set(entries.filter((entry) => entry.group === group).map((entry) => entry.pattern.toLowerCase()));
+
+export const announcerWords = (entries: readonly LexiconEntry[]): AnnouncerWords => ({
+  announcing: patternsOf(entries, undefined),
+  copulas: new Map(entries.flatMap((entry): [string, Side][] => (entry.group === "copula" ? [[entry.pattern.toLowerCase(), entry.position ?? "after"]] : []))),
+  negations: patternsOf(entries, "negation"),
+});
+
+const baseForm = (token: Token): string => (token.lemma ?? token.surface).toLowerCase();
+
+/** Between a copula and its complement: not, very, the (is not the, are very). */
+const BRIDGING_POS = new Set(["ADV", "PART", "DET"]);
+
+/** What a copula at `at` links to, on its complement's side: the bridging words, then the complement when there is one. */
+const linkedBy = (tokens: readonly Token[], at: number, side: Side): Token[] => {
+  const outward = side === "after" ? tokens.slice(at + 1) : tokens.slice(0, at).reverse();
+  const complementAt = outward.findIndex((token) => !BRIDGING_POS.has(token.pos));
+  return complementAt === -1 ? outward : outward.slice(0, complementAt + 1);
+};
+
+/** An -ing form or a past participle names or modifies (Moving through the process, An object representing a server); it predicates only after a copula. */
+const NON_FINITE = new Set(["Ger", "Part"]);
+
+const isFiniteVerb = (token: Token): boolean => token.pos === "VERB" && !NON_FINITE.has(token.features?.["VerbForm"] ?? "");
+
+type Predicate = { readonly words: readonly Token[]; readonly negations: readonly Token[] };
+
+const copulaPredicate = (tokens: readonly Token[], at: number, side: Side, words: AnnouncerWords): Predicate => {
+  const linked = linkedBy(tokens, at, side);
+  return { words: linked.filter((word) => !BRIDGING_POS.has(word.pos)), negations: linked.filter((word) => words.negations.has(baseForm(word))) };
+};
+
+/** A finite verb that is no copula, a word turned into a verb by a light verb (変更し), or a copula's complement. */
+const predicatesOf = (tokens: readonly Token[], words: AnnouncerWords): Predicate[] =>
+  tokens.flatMap((token, index): Predicate[] => {
+    const side = words.copulas.get(baseForm(token));
+    if (side !== undefined) return [copulaPredicate(tokens, index, side, words)];
+    const lightVerbNext = tokens[index + 1]?.features?.["VerbType"] === "Light";
+    return isFiniteVerb(token) || lightVerbNext ? [{ words: [token], negations: [] }] : [];
+  });
+
+/**
+ * The sentence has a predicate of its own: a word that is not one of the heading's words and does not only announce or
+ * point (covers, below, 説明, 以下), or a denial the heading does not make. "All charges include sales tax." says
+ * something about charges; "This section covers installation." and "The full reference is in the manual." do not.
+ */
+/** A code name in a heading holds words of its own (restoreFixtures, cache_key, dry-run): the sentence that spells them out repeats them. */
+const CODE_NAME_PART = /\p{Lu}?[\p{Ll}\p{Nd}]+|\p{Lu}+(?!\p{Ll})/gu;
+
+const headingWords = (heading: readonly Token[]): Set<string> =>
+  new Set(heading.flatMap((token) => [baseForm(token), ...(token.surface.match(CODE_NAME_PART) ?? []).map((part) => part.toLowerCase())]));
+
+export const makesClaim = (heading: readonly Token[], sentence: readonly Token[], words: AnnouncerWords): boolean => {
+  const said = headingWords(heading);
+  const unsaid = (token: Token): boolean => !said.has(baseForm(token));
+  const ownWord = (token: Token): boolean => isContent(token) && unsaid(token) && !words.announcing.has(baseForm(token)) && !words.copulas.has(baseForm(token));
+  return predicatesOf(sentence, words).some((predicate) => predicate.negations.some(unsaid) || predicate.words.some(ownWord));
+};

package/src/detectors/heading-echo.ts

@@ -1,7 +1,9 @@
 import { lengthOf, proseText } from "../measure.ts";
 import { newContentMorphemes } from "./content-morphemes.ts";
 import { echoedHeadingUnits, trigrams } from "./heading-overlap.ts";
+import { formValueTokens, isFormBlock } from "./form-line.ts";
 import { titleTokens } from "../heading-label.ts";
+import { announcerWords, makesClaim } from "./heading-claim.ts";
 import { handsOver } from "./lead-in.ts";
 import { holdsLink, namesLocation } from "./location-pointer.ts";
 import { withoutQuotedVariants } from "./quoted-variant.ts";
@@ -65,6 +67,17 @@ const pointsElsewhere = (doc: ProseDocument, section: Section): boolean => {
   return first !== undefined && (holdsLink(doc.source, first.span, doc.links) || namesLocation(doc.source.slice(first.span.start, first.span.end)));
 };
 
+/**
+ * 最初の文が、見出しに無い述語で見出しの主題について何かを述べている（## Charges → All charges include sales tax.）。
+ * 予告や指示の語（covers, below, 説明, 以下）だけを述語にする文は、見出しを言い直しているだけで繰り返し。
+ */
+const statesClaim = (doc: ProseDocument, section: Section): boolean => {
+  const first = section.firstSentence;
+  if (first?.tokens === undefined || section.headingTokens === undefined) return false;
+  const heading = titleTokens(section.heading, measuredHeading(section), section.headingTokens);
+  return makesClaim(heading, first.tokens, announcerWords(doc.lexicons["heading-announcer"] ?? []));
+};
+
 /** A figure, with its thousands separators (1,320,000), compared without them. */
 const FIGURE = /\p{Nd}+(?:[,，]\p{Nd}{3})*/gu;
 /** Note marks are not figures: [^1], ※1, <sup>1</sup>. */
@@ -81,6 +94,17 @@ export const statesFigure = (heading: string, sentence: string): boolean => {
   return figuresOf(sentence).some((figure) => !inHeading.has(figure));
 };
 
+/**
+ * 最初の文が、見出しに無い名前や値を書いた、名前だけの行（レターヘッド）か項目と値の行（Customer: Laura Pennington）。
+ * 書式の頭で、見出しを言い直す文ではない。見出しをそのまま写した行（### 環境情報学研究科 → 環境情報学研究科、詳細：〈見出し〉）は繰り返し。
+ */
+const opensForm = (section: Section): boolean => {
+  const first = section.firstSentence;
+  if (first?.tokens === undefined || section.headingTokens === undefined || !isFormBlock(first.text, first.span.start, first.tokens)) return false;
+  const heading = titleTokens(section.heading, measuredHeading(section), section.headingTokens);
+  return newContentMorphemes(heading, formValueTokens(first.text, first.span.start, first.tokens)) > 0;
+};
+
 /** 見出しとの重なりを測る文。用語集や表記の手引きは見出しの語の別の書き方を引用する（Not “datacentre”）ので、それは数えない。 */
 const echoedText = (section: Section): string => withoutQuotedVariants(section.firstSentence?.text ?? "", measuredHeading(section));
 
@@ -88,9 +112,16 @@ export const headingEcho: Detector = (doc, options): Finding[] => {
   const leadIns = (doc.lexicons["lead-in"] ?? []).map((entry) => entry.pattern);
   return doc.sections
     .filter((section) => section.heading.length > 0 && section.firstSentence !== undefined && addsLittle(section, doc.lengthUnit))
-    .filter((section) => !leadsIn(doc, section, leadIns) && !pointsElsewhere(doc, section) && !statesFigure(section.heading, section.firstSentence?.text ?? ""))
+    .filter(
+      (section) =>
+        !leadsIn(doc, section, leadIns) &&
+        !pointsElsewhere(doc, section) &&
+        !statesFigure(section.heading, section.firstSentence?.text ?? "") &&
+        !opensForm(section),
+    )
     .map((section) => ({ section, overlap: Math.round(containment(trigrams(measuredHeading(section)), trigrams(echoedText(section))) * 100) }))
     .filter(({ overlap }) => overlap >= options.limit)
+    .filter(({ section }) => !statesClaim(doc, section))
     .map(({ section, overlap }) => ({
       rule: "heading-echo",
       severity: "warning",

package/src/detectors/installment-total-mismatch.ts

@@ -3,11 +3,12 @@
 // labels are installment-label, the other words installment-word, approximate-marker, number-word (digit), range-connector
 // and amount-range-word.
 import type { Detector, Finding, Lexicon, ProseDocument } from "../plugin.ts";
-import { installmentTotalMismatches, type InstallmentAmount, type InstallmentWords, type PositionedWord } from "../structure/installment-total.ts";
-import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
-import { amountsIn, formsOf } from "./currency-notation.ts";
+import { installmentFeeMismatches, type InstallmentSeriesWords } from "../structure/installment-fee.ts";
+import { installmentTotalMismatches, type InstallmentWords, type PositionedWord } from "../structure/installment-total.ts";
+import type { StructureIssue } from "../structure/issues.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAround } from "./quote-around.ts";
+import { statedAmountsOf } from "./stated-amounts.ts";
 
 const entriesOf = (doc: ProseDocument, lexicon: string, group?: string): Lexicon =>
   (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group);
@@ -41,28 +42,38 @@ const wordsOf = (doc: ProseDocument): InstallmentWords => ({
   numberWords: numberWordsOf(doc),
 });
 
-const amountsOf = (text: string, doc: ProseDocument): InstallmentAmount[] => {
-  const scales = scaleWordsOf(doc);
-  return amountsIn(
-    text,
-    formsOf(doc),
-    scales.map((scale) => scale.word),
-  ).flatMap((amount) => {
-    const read = scaledAmountOf(text, amount, scales);
-    return read === undefined
-      ? []
-      : [{ offset: read.offset, end: amount.offset + amount.written.length, currency: read.currency, value: read.value, scale: read.unit }];
-  });
-};
+const weightedOf = (doc: ProseDocument, lexicon: string, group: string): InstallmentSeriesWords["ordinals"] =>
+  entriesOf(doc, lexicon, group).flatMap((entry) => (entry.weight === undefined ? [] : [{ word: entry.pattern, value: entry.weight }]));
+
+const seriesWordsOf = (doc: ProseDocument): InstallmentSeriesWords => ({
+  numbered: patternsOf(doc, "installment-label", "numbered"),
+  finals: patternsOf(doc, "installment-label", "final"),
+  deposits: patternsOf(doc, "installment-label", "deposit"),
+  ordinals: [...weightedOf(doc, "installment-word", "ordinal"), ...numberWordsOf(doc)],
+  ordinalSuffixes: [...new Set(patternsOf(doc, "ordinal-suffix"))],
+  payments: patternsOf(doc, "installment-word", "payment"),
+  fees: patternsOf(doc, "installment-word", "fee"),
+  feeLinks: patternsOf(doc, "installment-word", "fee-link"),
+});
+
+const findingOf = (text: string, issue: StructureIssue, variant?: string): Finding => ({
+  rule: "installment-total-mismatch",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: quoteAround(text, issue.offset),
+  values: { ...issue.values, offset: issue.offset },
+  ...(variant === undefined ? {} : { variant }),
+});
 
 export const installmentTotalMismatch: Detector = (doc): Finding[] => {
   const text = proseAndTablesOf(doc);
-  return installmentTotalMismatches(text, amountsOf(text, doc), wordsOf(doc)).map((issue) => ({
-    rule: "installment-total-mismatch",
-    severity: "warning",
-    line: 0,
-    column: 0,
-    quote: quoteAround(text, issue.offset),
-    values: { ...issue.values, offset: issue.offset },
-  }));
+  const amounts = statedAmountsOf(text, doc);
+  const words = wordsOf(doc);
+  const loans = installmentTotalMismatches(text, amounts, words);
+  const headings = (doc.markup?.headings ?? []).map((heading) => heading.start);
+  const fees = installmentFeeMismatches(text, amounts, headings, words, seriesWordsOf(doc)).filter(
+    (issue) => !loans.some((loan) => loan.offset === issue.offset),
+  );
+  return [...loans.map((issue) => findingOf(text, issue)), ...fees.map((issue) => findingOf(text, issue, "fee"))];
 };

package/src/detectors/list-parallel.ts

@@ -63,18 +63,56 @@ const isTitleCase = (text: string): boolean =>
     .split(/\s+/u)
     .every((word) => TITLE_SMALL_WORDS.has(word) || /^\p{Lu}/u.test(word));
 
-const englishHead = (sentences: readonly Sentence[]): string | undefined => {
-  const first = (sentences[0]?.tokens ?? []).find((token) => !SKIPPED_AT_END.has(token.pos));
-  if (first === undefined || isUnsure(first) || isTitleCase(sentences[0]?.text ?? "")) return undefined;
+/** A determiner that opens an object (the, a, your): no noun phrase goes on from its head with one. */
+const opensObject = (token: Token | undefined): boolean => token?.features?.["PronType"] === "Art" || token?.features?.["Poss"] === "Yes";
+
+const AFTER_ADJECTIVE = new Set(["ADP", "PART"]);
+
+/** A noun or adjective, or an ordinary word the tagger took for a name because it is capitalised (Toggle). */
+const isNounOrAdjective = (token: Token): boolean =>
+  token.pos === "NOUN" || token.pos === "ADJ" || (token.pos === "PROPN" && token.features?.["OrdinaryWord"] === "Yes");
+
+/**
+ * The head of an item whose first two words overrule the first word's tag, or undefined when they do not. "Open the console"
+ * and "Press the button" open with a verb. "Clean up after closing" and "Bake in the oven" may open with a verb or an
+ * adjective phrase (Close to the station), and "Washing machine space" with a compound noun or a gerund and its object
+ * (Washing dishes): neither is judged.
+ */
+const headFromNextWord = (first: Token, next: Token | undefined): "verb" | "unjudged" | undefined => {
+  if (isNounOrAdjective(first) && opensObject(next)) return "verb";
+  if (first.pos === "ADJ" && AFTER_ADJECTIVE.has(next?.pos ?? "")) return "unjudged";
+  return first.features?.["VerbForm"] === "Ger" && next?.pos === "NOUN" ? "unjudged" : undefined;
+};
+
+/** The head as the first word's tag gives it. */
+const headFromTag = (first: Token): string | undefined => {
+  if (isUnsure(first)) return undefined;
   // A participle (Generated files, Nested lists) modifies the noun after it; the item is a noun phrase, but the tag does not say so.
   if (first.pos === "VERB") return first.features?.["VerbForm"] === "Part" ? undefined : "verb";
   return NOUN_HEAD.has(first.pos) ? "noun" : undefined;
 };
 
-/** An item's form on an axis, or undefined when its words do not tell. Japanese items have no head axis (the verb comes last). */
-export const formOf = (axis: Axis, sentences: readonly Sentence[], language: string): string | undefined => {
+const englishHead = (sentences: readonly Sentence[], instructionVerbs: ReadonlySet<string>): string | undefined => {
+  const tokens = sentences[0]?.tokens ?? [];
+  const at = tokens.findIndex((token) => !SKIPPED_AT_END.has(token.pos));
+  const first = tokens[at];
+  if (at === -1 || first === undefined || isTitleCase(sentences[0]?.text ?? "")) return undefined;
+  // The word right after, punctuation included: in "Next, the candidate" the comma ends the opener.
+  const next = tokens[at + 1];
+  // Before a common noun the word may head a compound (Click fraud, Scroll bar), so its tag decides.
+  if (instructionVerbs.has(first.surface.toLowerCase()) && next?.pos !== "NOUN") return "verb";
+  const overruled = headFromNextWord(first, next);
+  if (overruled === undefined) return headFromTag(first);
+  return overruled === "verb" ? "verb" : undefined;
+};
+
+/**
+ * An item's form on an axis, or undefined when its words do not tell. Japanese items have no head axis (the verb comes last).
+ * instructionVerbs: verbs the tagger does not know as verbs (click), from the adapter's instruction-verb word list.
+ */
+export const formOf = (axis: Axis, sentences: readonly Sentence[], language: string, instructionVerbs: ReadonlySet<string> = new Set()): string | undefined => {
   if (language === "ja") return axis === "ending" ? japaneseEnding(sentences) : undefined;
-  return axis === "ending" ? englishEnding(sentences) : englishHead(sentences);
+  return axis === "ending" ? englishEnding(sentences) : englishHead(sentences, instructionVerbs);
 };
 
 const within = (inner: Span, outer: Span): boolean => inner.start >= outer.start && inner.end <= outer.end;
@@ -131,9 +169,10 @@ const listFindings = (doc: ProseDocument, list: BulletList, limit: number): Find
     const span = list.itemSpans[index];
     return span !== undefined && isJudged(doc.source.slice(span.start, sentences.at(-1)?.span.end ?? span.end), sentences);
   });
+  const instructionVerbs = new Set((doc.lexicons["instruction-verb"] ?? []).map((entry) => entry.pattern.toLowerCase()));
   return AXES.flatMap((axis) => {
     const items = judged.flatMap((sentences) => {
-      const form = formOf(axis, sentences, doc.language);
+      const form = formOf(axis, sentences, doc.language, instructionVerbs);
       return form === undefined ? [] : [{ sentences, form }];
     });
     const odd = minorityWithin(items, (item) => item.form === FORMS[axis][0], limit);

package/src/detectors/name-variant.ts

@@ -1,12 +1,13 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { cuedNamesIn, mentionsIn, nameVariants, suffixedNamesIn, type NameMention, type VariantChars } from "../name-variants.ts";
+import type { WordUse } from "../name-end-letter.ts";
 import { withKnownNeighbours } from "../name-neighbours.ts";
 import type { SpellingInput } from "../name-spelling-chars.ts";
 import { lookalikeSlipsIn, type LookalikeChars } from "../name-lookalike-chars.ts";
-import { readingOfWords, type CharReadings } from "../name-char-reading.ts";
+import { givenNameReadingOf, readingOfWords, type CharReadings } from "../name-char-reading.ts";
 import { nameCueAt, type NameCues } from "../name-cue.ts";
 import { quoteAt } from "./structure-tree.ts";
-import { companyMentionsIn, companyVariants, type CompanyForm, type IsProper } from "../company-names.ts";
+import { companyMentionsIn, companyVariants, type CompanyForm, type IsProper, type PredicateEnds } from "../company-names.ts";
 import { kanaSpelledCompanies, type ReadWord } from "../company-kana-spelling.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { tableBodyCells } from "../facts/table-facts.ts";
@@ -33,6 +34,18 @@ const variantCharsOf = (doc: ProseDocument): VariantChars =>
 const charReadingsOf = (doc: ProseDocument): CharReadings =>
   new Map((doc.lexicons["name-char-reading"] ?? []).flatMap((entry): [string, string][] => (entry.group === undefined ? [] : [[entry.pattern, entry.group]])));
 
+/**
+ * 名の中での字の読み（建太 の 建 を ケン）は、語彙表 given-name-char-reading が組（group）に言う。解析器が読めない字の読み
+ * （name-char-reading）も名の中で同じに読む。
+ */
+const givenCharReadingsOf = (doc: ProseDocument, chars: CharReadings): CharReadings =>
+  new Map([
+    ...chars,
+    ...(doc.lexicons["given-name-char-reading"] ?? []).flatMap((entry): [string, string][] =>
+      entry.group === undefined ? [] : [[entry.pattern, entry.group]],
+    ),
+  ]);
+
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
 /** 会社の形の語（株式会社、Inc）は語彙表 company-form が、同じ形の組（group）と名前のどちら側に立つか（position）とともに言う。 */
@@ -124,6 +137,11 @@ const kanaStopsOf = (doc: ProseDocument): Parameters<typeof companyMentionsIn>[3
   return { particles: inGroup("particle"), openers: inGroup("opener"), ends: inGroup("end") };
 };
 
+/** 品詞解析が形容詞・動詞・助動詞と読んだ語の終わり。い で終わるひらがな（ながい食品）を会社の名前の頭に入れないため。 */
+const PREDICATE_POS: ReadonlySet<string> = new Set(["ADJ", "VERB", "AUX"]);
+const predicateEndsOf = (doc: ProseDocument): PredicateEnds =>
+  new Set(tokensOf(doc).flatMap((token) => (PREDICATE_POS.has(token.pos) ? [token.span.end] : [])));
+
 const readWordsOf = (doc: ProseDocument): ReadWord[] =>
   tokensOf(doc).map((token) => ({ start: token.span.start, end: token.span.end, surface: token.surface, reading: token.reading }));
 
@@ -133,7 +151,7 @@ const readWordsOf = (doc: ProseDocument): ReadWord[] =>
  */
 const companyFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] => {
   const stops = kanaStopsOf(doc);
-  const mentions = companyMentionsIn(prose, [...companyFormsOf(doc), ...foreignFormsOf(doc)], properOf(doc), stops);
+  const mentions = companyMentionsIn(prose, [...companyFormsOf(doc), ...foreignFormsOf(doc)], properOf(doc), stops, predicateEndsOf(doc));
   const variants = companyVariants(mentions).map(({ mention, usual, kind }) => ({
     offset: mention.offset,
     name: mention.surface,
@@ -220,21 +238,25 @@ const wordsCovering = (tokens: readonly Token[], startAt: ReadonlyMap<number, nu
 
 /**
  * 空白を挟んだ姓と名で、敬称か肩書きが付くか、人を書く欄にあるもの（高瀬 誠部長、氏名：森川 大輔）。語は解析器の切り方のまま、
- * 読みは語の読みをつなぐ。解析器の語の切れ目と姓・名の端が合わないものは読まない。
+ * 読みは語の読みをつなぐ。名を名の中での字の読みで読み直した読みも持つ（givenNameReading）。解析器の語の切れ目と姓・名の端が
+ * 合わないものは読まない。
  */
 const spacedNameMentionsOf = (doc: ProseDocument, prose: string, charReadings: CharReadings): NameMention[] => {
   const cues = { suffixes: patternsOf(doc, "person-suffix"), titles: patternsOf(doc, "person-title"), labels: patternsOf(doc, "person-label") };
   const tokens = tokensOf(doc);
   const startAt = new Map(tokens.map((token, index) => [token.span.start, index]));
+  const givenChars = givenCharReadingsOf(doc, charReadings);
   return spacedPersonNamesIn(prose, cues).flatMap(({ surname, given }): NameMention[] => {
     const surnameWords = wordsCovering(tokens, startAt, surname);
     const givenWords = wordsCovering(tokens, startAt, given);
     if (surnameWords === undefined || givenWords === undefined) return [];
     const words = [...surnameWords, ...givenWords];
     const surface = `${prose.slice(surname.start, surname.end)} ${prose.slice(given.start, given.end)}`;
-    return [
-      { surface, offset: surname.start, reading: readingOfWords(words, charReadings), words: words.map((word) => word.surface), person: true, cue: "person" },
-    ];
+    const surnameReading = readingOfWords(surnameWords, charReadings);
+    const givenReading = givenNameReadingOf(givenWords, givenChars, charReadings);
+    const givenNameReading = surnameReading === undefined || givenReading === undefined ? undefined : surnameReading + givenReading;
+    const reading = readingOfWords(words, charReadings);
+    return [{ surface, offset: surname.start, reading, givenNameReading, words: words.map((word) => word.surface), person: true, cue: "person" }];
   });
 };
 
@@ -311,12 +333,27 @@ const labelledNamesOf = (doc: ProseDocument, mentions: readonly NameMention[]):
   );
 };
 
+const LATIN_WORD = /^[A-Za-z]+$/u;
+const LOWERCASE_WORD = /^[a-z]+$/u;
+
+/** 文書が小文字で書くか、品詞解析が普通名詞と読む英字の語（文頭の Hurricane）。 */
+const isCommonToken = (token: Token): boolean => LOWERCASE_WORD.test(token.surface) || (token.pos === "NOUN" && LATIN_WORD.test(token.surface));
+
+/** 文書での英字の語の使い方。名前と読んだ語のうち小文字で書けばふつうの語と、普通名詞として書いた語。 */
+const wordUseOf = (doc: ProseDocument): WordUse => {
+  const tokens = tokensOf(doc);
+  return {
+    ordinary: new Set(tokens.flatMap((token) => (isOrdinaryToken(token) ? [token.surface.toLowerCase()] : []))),
+    common: new Set(tokens.flatMap((token) => (isCommonToken(token) ? [token.surface.toLowerCase()] : []))),
+  };
+};
+
 /** 同じ名前を、文書の中で少しだけ違う形に書いた所（GitHub と Github、山田太郎 と 山田太朗）。少ないほうを指す。 */
 export const nameVariant: Detector = (doc): Finding[] => {
   const prose = doc.prose ?? doc.source;
   const chars = variantCharsOf(doc);
   const mentions = labelledNamesOf(doc, ordinaryNamesOf(doc, nameMentionsOf(doc, prose, chars)));
-  const variants = nameVariants(mentions, chars, spellingInputOf(doc))
+  const variants = nameVariants(mentions, chars, spellingInputOf(doc), wordUseOf(doc))
     .map(({ mention, usual, kind }): Reported => ({ offset: mention.offset, name: mention.surface, usual, kind }))
     .filter(notSpacingOnly);
   const lookalikes = lookalikeSlipsIn(mentions, lookalikeCharsOf(doc)).map(({ mention, usual }) => ({