chaffjs 0.33.0 → 0.35.0

package/src/detectors/date-heading-year.ts

@@ -0,0 +1,55 @@
+// The year a section's heading gives the dates under it: "FY27-Q2 (May 1)", 「2026年度の予定」, 「令和8年の行事」. A yearless
+// date in such a section has its year. Pure.
+import type { StructureNode } from "../plugin.ts";
+
+/** A fiscal-year name with its year as a number: "FY{y}" of the language's reporting-period-frame lexicon. */
+export type YearLabel = { readonly before: string; readonly after: string };
+
+/** The words that name a year in a heading: era names (令和) and fiscal-year labels ("FY{y}"). */
+export type HeadingYearWords = { readonly eras: readonly string[]; readonly labels: readonly YearLabel[] };
+
+/** A year written as figures: 2024年度, "2024 events". */
+const YEAR_FIGURES = /(?<![0-9０-９])(?:1[89]|20)\d{2}(?![0-9０-９])/u;
+/** An era's year after its name: 8年 of 令和8年, 元年 of 令和元年度 (not 8月). */
+const ERA_YEAR_NUMBER = /^[ \t]?(?:[0-9０-９]{1,2}|元)[ \t]?年/u;
+/** A fiscal year's number: two figures (FY27) or four (FY2027). */
+const LABEL_YEAR = /^(?:\d{2}|\d{4})(?!\d)/u;
+const LETTER = /\p{L}/u;
+
+/** "FY{y}" as the lexicon writes it: the words before and after the year. A name with no {y} names no year. */
+export const yearLabelOf = (pattern: string): YearLabel | undefined => {
+  const at = pattern.indexOf("{y}");
+  return at === -1 || pattern.includes("{", at + 1) ? undefined : { before: pattern.slice(0, at).toLowerCase(), after: pattern.slice(at + 3).toLowerCase() };
+};
+
+const startsAt = (text: string, index: number): boolean => index === 0 || !LETTER.test(text.charAt(index - 1));
+
+const indicesOf = (text: string, word: string, from = 0): number[] => {
+  const at = word === "" ? -1 : text.indexOf(word, from);
+  return at === -1 ? [] : [at, ...indicesOf(text, word, at + 1)];
+};
+
+const namesLabelYear = (heading: string, label: YearLabel): boolean => {
+  const text = heading.toLowerCase();
+  return indicesOf(text, label.before).some((at) => {
+    if (!startsAt(text, at)) return false;
+    const year = LABEL_YEAR.exec(text.slice(at + label.before.length))?.[0];
+    return year !== undefined && text.startsWith(label.after, at + label.before.length + year.length);
+  });
+};
+
+const namesEraYear = (heading: string, era: string): boolean => indicesOf(heading, era).some((at) => ERA_YEAR_NUMBER.test(heading.slice(at + era.length)));
+
+/** The heading names a year: figures (2026年度), an era's year (令和8年), or a fiscal year (FY27). */
+export const headingNamesYear = (heading: string, words: HeadingYearWords): boolean =>
+  YEAR_FIGURES.test(heading) || words.eras.some((era) => namesEraYear(heading, era)) || words.labels.some((label) => namesLabelYear(heading, label));
+
+const sectionHeading = (node: StructureNode, current: string): string =>
+  node.kind === "section" && node.attrs["heading"] !== undefined ? String(node.attrs["heading"]) : current;
+
+/** The offsets of the dates whose own section, the innermost one they are in, has a heading that names a year. */
+export const datesUnderYearHeadings = (tree: StructureNode, words: HeadingYearWords, heading = ""): number[] => {
+  const own = sectionHeading(tree, heading);
+  if (tree.kind === "date") return headingNamesYear(own, words) ? [tree.span.start] : [];
+  return tree.children.flatMap((child) => datesUnderYearHeadings(child, words, own));
+};

package/src/detectors/date-year.ts

@@ -3,15 +3,27 @@
 import type { Detector, Finding, LexiconEntry, ProseDocument, StructureNode } from "../plugin.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
 import { quoteAt } from "./structure-tree.ts";
-import { ANY_YEAR_MARKER_LEXICON, YEAR_SPAN_JOINER_LEXICON, anyYearDate, opensSpan, type AnyYearMarker, type MarkerReach } from "./date-any-year.ts";
+import {
+  ANY_YEAR_MARKER_LEXICON,
+  MARKER_REACHES,
+  YEAR_SPAN_JOINER_LEXICON,
+  anyYearDate,
+  opensSpan,
+  type AnyYearMarker,
+  type MarkerReach,
+} from "./date-any-year.ts";
+import { datesUnderYearHeadings, yearLabelOf, type HeadingYearWords } from "./date-heading-year.ts";
 
 /** The words that make a yearless date any year's (毎年, 例えば, "each") and that join a period's two ends (から, "to"). */
 export type AnyYearWords = { readonly markers: readonly AnyYearMarker[]; readonly joiners: readonly string[] };
 
 const NO_ANY_YEAR_WORDS: AnyYearWords = { markers: [], joiners: [] };
 
-/** A date as the tree reads it: "2026-10-14" with its year, "10-14" without. */
-export type DatePoint = { readonly offset: number; readonly end: number; readonly value: string };
+/**
+ * A date as the tree reads it: "2026-10-14" with its year, "10-14" without. `yearHeaded`: the heading of its section
+ * names a year ("FY27-Q2 (May 1)", 「2026年度の予定」), which the date takes.
+ */
+export type DatePoint = { readonly offset: number; readonly end: number; readonly value: string; readonly yearHeaded?: boolean };
 
 /** The first and the last year of the document's dated dates. */
 export type YearSpan = { readonly from: number; readonly to: number };
@@ -106,9 +118,23 @@ const hasYearWord = (point: DatePoint, source: string, yearWords: readonly YearW
  */
 const yearGiven = (point: DatePoint, anchors: readonly DatePoint[], source: string, yearWords: readonly YearWord[]): boolean => {
   const start = lineStart(source, point.offset);
-  return hasYearWord(point, source, yearWords) || anchors.some((other) => other.offset >= start && other.offset < point.offset);
+  return point.yearHeaded === true || hasYearWord(point, source, yearWords) || anchors.some((other) => other.offset >= start && other.offset < point.offset);
 };
 
+const DAY_MS = 24 * 60 * 60 * 1000;
+const COMMON_YEAR_MS = 365 * DAY_MS;
+/** A year with no 29 February, so that "03-01" follows "02-28" as it does in most years. */
+const COMMON_YEAR = 2025;
+
+const dayOf = (value: string): number => Date.UTC(COMMON_YEAR, Number(value.slice(0, 2)) - 1, Number(value.slice(3, 5)));
+
+/**
+ * A period of one whole year: its end is the day before its start (January 1 to December 31, 4月1日から3月31日). Without
+ * a year it is every year's, like a calendar or a fiscal year.
+ */
+export const wholeYear = (start: string, end: string): boolean =>
+  MONTH_DAY.test(start) && MONTH_DAY.test(end) && (dayOf(end) + DAY_MS - dayOf(start)) % COMMON_YEAR_MS === 0;
+
 /**
  * The yearless dates whose year the reader cannot tell. Where most dates carry a year (at least two, and more than the
  * yearless ones) and those years differ, every yearless one is reported: in a one-year document the year is plain. Where
@@ -124,9 +150,13 @@ export const yearGaps = (
   const dated = points.filter((point) => FULL.test(point.value));
   const anchors = [...dated, ...points.filter((point) => hasYearWord(point, source, yearWords))];
   const nextOf = new Map(points.map((point, index) => [point, points[index + 1]]));
+  const previousOf = new Map(points.map((point, index) => [point, points[index - 1]]));
+  const yearlySpan = (start: DatePoint | undefined, end: DatePoint | undefined): boolean =>
+    start !== undefined && end !== undefined && wholeYear(start.value, end.value) && opensSpan(start, end, source, anyYear.joiners);
   const yearOfAny = (point: DatePoint): boolean => {
     const next = nextOf.get(point);
     if (anyYearDate(point, source, anyYear.markers)) return true;
+    if (yearlySpan(point, next) || yearlySpan(previousOf.get(point), point)) return true;
     return next !== undefined && opensSpan(point, next, source, anyYear.joiners) && hasYearWord(next, source, yearWords);
   };
   // A recurring day or an example's date has no year to write, and is not the document's way of writing dates either.
@@ -134,20 +164,35 @@ export const yearGaps = (
   const span = spanOf(dated);
   const unclear = dated.length >= 2 && yearless.length < dated.length && span !== undefined && span.to > span.from;
   const datedSides = new Set(dated.flatMap((point) => sideOf(monthOf(FULL, point.value)) ?? []));
-  const previousOf = new Map(points.map((point, index) => [point, points[index - 1]]));
   return yearless.flatMap((point): YearGap[] => {
     if (unclear) return [{ point, kind: "years", span }];
     return crossesYear(point, previousOf.get(point), datedSides) ? [{ point, kind: "boundary", span }] : [];
   });
 };
 
-export const datePoints = (tree: StructureNode): DatePoint[] =>
-  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
+const NO_HEADING_YEAR_WORDS: HeadingYearWords = { eras: [], labels: [] };
+
+export const datePoints = (tree: StructureNode, headingWords: HeadingYearWords = NO_HEADING_YEAR_WORDS): DatePoint[] => {
+  const yearHeaded = new Set(datesUnderYearHeadings(tree, headingWords));
+  return inDocumentOrder(tree).flatMap((node) =>
+    node.kind === "date"
+      ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]), yearHeaded: yearHeaded.has(node.span.start) }]
+      : [],
+  );
+};
 
 const yearWordsOf = (doc: ProseDocument): YearWord[] =>
   (doc.lexicons[YEAR_REFERENCE_LEXICON] ?? []).map((entry: LexiconEntry) => ({ word: entry.pattern, position: entry.position }));
 
-const reachOf = (group: string | undefined): MarkerReach => (group === "adjacent" || group === "label" ? group : "sentence");
+/** The era names (calendar-era) and the fiscal-year names ("FY{y}" of reporting-period-frame) a heading may give a year with. */
+const headingYearWordsOf = (doc: ProseDocument): HeadingYearWords => ({
+  eras: (doc.lexicons["calendar-era"] ?? []).map((entry: LexiconEntry) => entry.pattern),
+  labels: (doc.lexicons["reporting-period-frame"] ?? []).flatMap((entry: LexiconEntry) =>
+    entry.group === "fiscal-year" ? (yearLabelOf(entry.pattern) ?? []) : [],
+  ),
+});
+
+const reachOf = (group: string | undefined): MarkerReach => MARKER_REACHES.find((reach) => reach === group) ?? "sentence";
 
 const anyYearWordsOf = (doc: ProseDocument): AnyYearWords => ({
   markers: (doc.lexicons[ANY_YEAR_MARKER_LEXICON] ?? []).map((entry: LexiconEntry) => ({ word: entry.pattern, reach: reachOf(entry.group) })),
@@ -157,7 +202,7 @@ const anyYearWordsOf = (doc: ProseDocument): AnyYearWords => ({
 export const dateWithoutYear: Detector = (doc: ProseDocument): Finding[] =>
   doc.structure === undefined
     ? []
-    : yearGaps(datePoints(doc.structure), doc.source, yearWordsOf(doc), anyYearWordsOf(doc)).map((gap) => ({
+    : yearGaps(datePoints(doc.structure, headingYearWordsOf(doc)), doc.source, yearWordsOf(doc), anyYearWordsOf(doc)).map((gap) => ({
         rule: "date-without-year",
         severity: "warning",
         line: 0,

package/src/detectors/defined-term-form.ts

@@ -199,11 +199,31 @@ const MIN_NAME_CHARS = 4;
 /** In English a long name has two words or more (Acme Corporation); one capitalised word is the term's own kind of word. */
 const MIN_NAME_WORDS = 2;
 const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+const JAPANESE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u;
 
 const isNamePart = (token: Token): boolean => NAME_PARTS.has(token.pos) || NAME_MARKS.has(token.surface);
 
+/**
+ * A label for each of several things or for all of them together ((each, a "Certificate"), (collectively, the "Plans"))
+ * names the head of the clause before it (a certificate that represented any share of Common Stock), not its last words.
+ */
+const LABELS_THE_CLAUSE = /^[(（](?:each|collectively)\b/iu;
+
+/**
+ * Whether the words make a long name. In English, two words with letters, one of them capitalised: a figure is not a word
+ * of a name (as amended on January 26, 2015 (the "Indenture"), a par value of $1.00 (the "Preference Stock")), and lower-case
+ * words (with respect thereto) are used in their own sense. A name with Japanese in it (株式会社ABC), four characters or more.
+ */
+const isLongName = (name: string): boolean => {
+  const words = name.split(/\s+/u).filter((word) => LETTER.test(word));
+  if (words.length === 0 || [...name].length < MIN_NAME_CHARS) return false;
+  return !LATIN.test(name) || JAPANESE.test(name) || (words.length >= MIN_NAME_WORDS && words.some((word) => UPPER_START.test(word)));
+};
+
 /** The long name written right before an inline definition: the run of name words that ends at its opening bracket. */
 export const nameBefore = (sentence: Sentence, bracket: number): string | undefined => {
+  if (LABELS_THE_CLAUSE.test(sentence.text.slice(bracket - sentence.span.start))) return undefined;
   const tokens = (sentence.tokens ?? []).filter((token) => token.span.end <= bracket);
   const firstOfRun = tokens.findLastIndex((token) => !isNamePart(token)) + 1;
   if (isModifier(tokens[firstOfRun - 1])) return undefined;
@@ -212,16 +232,17 @@ export const nameBefore = (sentence: Sentence, bracket: number): string | undefi
   const end = run.at(-1);
   if (first === undefined || end === undefined || bracket - end.span.end > 1) return undefined;
   const name = withoutTrailingMarks(sentence.text.slice(first.span.start - sentence.span.start, end.span.end - sentence.span.start));
-  const words = name.split(/\s+/u).length;
-  return [...name].length < MIN_NAME_CHARS || (LATIN.test(name) && words < MIN_NAME_WORDS) ? undefined : name;
+  return isLongName(name) ? name : undefined;
 };
 
 /**
- * A word that narrows the name before it: an article, an adjective, a verb, or の (妊娠中の女性従業員, the Beta Preview, 本利用規約).
- * The words then name a kind of thing the definition picks out, not one party, and are used in their own sense again.
+ * A word that narrows the name before it: an article, an adjective, a verb, or a possessive (妊娠中の女性従業員, the Beta
+ * Preview, 本利用規約, users of Customer's Web site). The words then name a kind of thing the definition picks out, not one
+ * party, and are used in their own sense again.
  */
 const MODIFIERS = new Set(["DET", "ADJ", "VERB", "AUX"]);
-const isModifier = (token: Token | undefined): boolean => token !== undefined && (MODIFIERS.has(token.pos) || token.surface === "の");
+const POSSESSIVES = new Set(["の", "'s", "’s", "'", "’"]);
+const isModifier = (token: Token | undefined): boolean => token !== undefined && (MODIFIERS.has(token.pos) || POSSESSIVES.has(token.surface));
 
 const TRAILING_MARKS = new Set([",", ".", " "]);
 

package/src/detectors/document-shape.ts

@@ -1,6 +1,7 @@
 // The shape of a document's top: whether the lead says anything the title does not, and whether a title or heading
 // runs too long to scan. Pure; both read only the sections, paragraphs and tokens chaff has already built.
 import { newContentMorphemes } from "./content-morphemes.ts";
+import { formValueTokens, isFormBlock } from "./form-line.ts";
 import { trigrams } from "./heading-overlap.ts";
 import { findingAt, writtenHeadings } from "./markup-finding.ts";
 import type { Detector, Finding, LengthUnit, MarkupHeading, Paragraph, ProseDocument, Section } from "../plugin.ts";
@@ -38,6 +39,13 @@ const leadOf = (doc: ProseDocument): Lead | undefined => {
   const lead = title === undefined ? undefined : leadParagraphOf(doc, title);
   if (title === undefined || lead === undefined || title.headingTokens === undefined) return undefined;
   const leadTokens = lead.sentences.flatMap((sentence) => sentence.tokens ?? []);
+  // A form or a letter opens with fields or a letterhead, not a lead (Invoice number: INV-2026-0318). A line that only copies the title is still one.
+  const leadSource = doc.source.slice(lead.span.start, lead.span.end);
+  if (
+    isFormBlock(leadSource, lead.span.start, leadTokens) &&
+    newContentMorphemes(title.headingTokens, formValueTokens(leadSource, lead.span.start, leadTokens)) > 0
+  )
+    return undefined;
   const leadText = lead.sentences.map((sentence) => sentence.text).join(" ");
   return { title, lead, fresh: newContentMorphemes(title.headingTokens, leadTokens), echo: echoPercent(title.heading, leadText) };
 };

package/src/detectors/due-date.ts

@@ -1,18 +1,22 @@
 // due-before-issue: the reading half. The issue-date and due-date words come from the language's lexicons
 // (issue-date-label, due-date-label, deadline-passed-word), and so do the words of minutes (minutes-title-word, meeting-date-label,
 // action-section-heading, earlier-section-word, action-due-label, item-done-word) and the other pairs of dates that must come in
-// order (dated-pair-label, date-now-word, and dated-span-label for the words whose line states a period, read up to its end;
-// a table whose header names both columns of a pair, from dated-pair-label and the header-only dated-column-label);
+// order (dated-pair-label, date-now-word, and dated-span-label for the words whose line states a period, read up to its end,
+// or from its start in the group a dated-span-label entry names;
+// a table whose header names both columns of a pair, from dated-pair-label and the header-only dated-column-label;
+// a signature line giving a pair's later date, from the role words of dated-signer-label;
+// a pair's label naming a version, End of support for 5.0.0 or 3.0.0 のサポート終了日, from dated-pair-version-word);
 // the dates are the structure tree's, and the lines are read with code masked.
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { actionDueBeforeMeeting, type ActionWords } from "../structure/action-due.ts";
 import { columnDatesOutOfOrder } from "../structure/column-date-order.ts";
-import { pairedDatesOutOfOrder, type OrderDate } from "../structure/labelled-date-order.ts";
+import { pairedDatesOutOfOrder, type OrderDate, type PairedIssue } from "../structure/labelled-date-order.ts";
 import { dueBeforeIssue, type DueWords } from "../structure/due-date.ts";
 import { inDocumentOrder, type StructureIssue } from "../structure/issues.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { periodWordsOf } from "./range-words.ts";
 import { quoteAt } from "./structure-tree.ts";
+import type { VersionWords } from "../structure/versioned-label.ts";
 import { readableDates, withReadableDates } from "./readable-dates.ts";
 
 /** A record's facts table can sit well below its header date (a listing date above the table holding the move-in date). */
@@ -35,6 +39,12 @@ const actionWordsOf = (doc: ProseDocument): ActionWords => ({
   minutes: patternsOf(doc, "minutes-title-word"),
 });
 
+const versionWordsOf = (doc: ProseDocument): VersionWords => {
+  const entries = doc.lexicons["dated-pair-version-word"] ?? [];
+  const at = (position: "before" | "after"): string[] => entries.filter((entry) => entry.position === position).map((entry) => entry.pattern);
+  return { after: at("after"), before: at("before") };
+};
+
 const orderAsidesOf = (doc: ProseDocument): string[] => [...patternsOf(doc, "deadline-passed-word"), ...patternsOf(doc, "date-now-word")];
 
 const treeDates = (tree: NonNullable<ProseDocument["structure"]>): OrderDate[] =>
@@ -50,17 +60,26 @@ const findingOf = (doc: ProseDocument, issue: StructureIssue, variant?: string):
   ...(variant === undefined ? {} : { variant }),
 });
 
+const variantOf = (issue: PairedIssue): string => {
+  if (issue.fromStart === true) return "period-start";
+  return issue.period ? "period" : "order";
+};
+
 export const dueDate: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
   const text = proseAndTablesOf(doc);
   const dates = treeDates(doc.structure);
   const pairs = doc.lexicons["dated-pair-label"] ?? [];
-  const spans = periodWordsOf(doc, patternsOf(doc, "dated-span-label"));
+  const spanEntries = doc.lexicons["dated-span-label"] ?? [];
+  const spans = { ...periodWordsOf(doc, [...new Set(spanEntries.map((entry) => entry.pattern))]), entries: spanEntries };
   return [
     ...dueBeforeIssue(text, dates, wordsOf(doc)).map((issue) => findingOf(doc, issue)),
-    ...pairedDatesOutOfOrder(text, dates, pairs, orderAsidesOf(doc), MAX_RECORD_LINE_GAP, spans).map((issue) =>
-      findingOf(doc, issue, issue.period ? "period" : "order"),
-    ),
+    ...pairedDatesOutOfOrder(text, dates, pairs, orderAsidesOf(doc), MAX_RECORD_LINE_GAP, {
+      spans,
+      whole: doc.source,
+      signers: doc.lexicons["dated-signer-label"] ?? [],
+      versions: versionWordsOf(doc),
+    }).map((issue) => findingOf(doc, issue, variantOf(issue))),
     ...columnDatesOutOfOrder(text, dates, [...pairs, ...(doc.lexicons["dated-column-label"] ?? [])], orderAsidesOf(doc)).map((issue) =>
       findingOf(doc, issue, "order"),
     ),

package/src/detectors/en-shape.ts

@@ -1,6 +1,7 @@
 import { lengthOf } from "../measure.ts";
 import { isClosed } from "../sentence-shape.ts";
 import { isTitleCase, minorityCase, pageTitleOf } from "./heading-case.ts";
+import { namesWrittenMidSentence } from "./heading-names.ts";
 import type { Detector, Finding, Lexicon, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
 import { entryOpens } from "./lexicon-match.ts";
 
@@ -137,7 +138,10 @@ const headingsOf = (sections: readonly Section[], fixedCase: ReadonlySet<string>
  * 見るのは文書の中で揃っているかだけで、少数派のほうを指摘する。題名は指摘しない（minorityCase）。
  */
 export const titleCaseMix: Detector = (doc, options): Finding[] => {
-  const fixedCase = new Set(FIXED_CASE_LISTS.flatMap((id) => (doc.lexicons[id] ?? []).map((entry) => entry.pattern)));
+  const fixedCase = new Set([
+    ...FIXED_CASE_LISTS.flatMap((id) => (doc.lexicons[id] ?? []).map((entry) => entry.pattern)),
+    ...namesWrittenMidSentence(doc.sentences.map((sentence) => sentence.text)),
+  ]);
   const pageTitle = pageTitleOf(doc.sections);
   const judged = headingsOf(
     doc.sections.filter((section) => section !== pageTitle),

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(
@@ -142,9 +140,10 @@ const readFacts = (doc: ProseDocument, tree: StructureNode): ScopedFact[] => {
   );
   const read = new Set([...termed, ...labelled.map((fact) => fact.value.start)]);
   const verbs = verbQuantityFacts(doc.source, values, verbQuantityWordsOf(doc)).filter((fact) => !read.has(fact.value.start));
-  const tabled = tableFacts(doc.source, values, totalColumnsOf(doc), countLabelWordsOf(doc.lexicons));
+  const tabled = tableFacts(doc.source, values, totalColumnsOf(doc), countLabelWordsOf(doc.lexicons), { columnGroups: true });
   const facts = withQualifiedKeys(doc, [...labelled, ...terms, ...verbs, ...tabled]);
-  return withCellKeys(scopedFacts(facts, tree, doc.source, patternsOf(doc, "summary-heading")), qualifierWordsOf(doc));
+  const scoped = scopedFacts(facts, tree, doc.source, patternsOf(doc, "summary-heading"), { paragraphHeads: true });
+  return withCellKeys(scoped, qualifierWordsOf(doc));
 };
 
 /** 文書の名前付きの値。二つの rule が読むので、文書ごとに一度だけ読む。 */
@@ -263,8 +262,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 +317,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

@@ -4,12 +4,10 @@
 // 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 { StatedAmount } from "../structure/stated-multiple.ts";
 import type { TaxPriceRole, TaxPriceWord } from "../structure/tax-price.ts";
-import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
-import { amountsIn, formsOf } from "./currency-notation.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);
@@ -31,23 +29,9 @@ const wordsOf = (doc: ProseDocument): FormulaWords => ({
   notIncluded: patternsOf(doc, "formula-amount-word", "not-included"),
 });
 
-const amountsOf = (text: string, doc: ProseDocument): StatedAmount[] => {
-  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 }];
-  });
-};
-
 export const formulaAmount: Detector = (doc): Finding[] => {
   const text = proseAndTablesOf(doc);
-  const input = { text, amounts: amountsOf(text, doc), defaultTaxRate: doc.profile?.taxRate };
+  const input = { text, amounts: statedAmountsOf(text, doc), defaultTaxRate: doc.profile?.taxRate };
   return formulaAmountMismatches(input, wordsOf(doc)).map((issue) => ({
     rule: "formula-amount-mismatch",
     severity: "warning",

package/src/detectors/gram-passages.ts

@@ -0,0 +1,36 @@
+import type { Section, Sentence } from "../plugin.ts";
+
+/**
+ * 問いの印で終わる見出し。後ろに括弧の注記（(updated Nov. 14, 2024)）が付いてもよい。
+ * 「Q1」の札だけでは問いと見ない。四半期（Q1 2024）の見出しと見分けられない。
+ */
+const QUESTION_END = /[?？]\s*(?:[(（][^()（）]*[)）])?$/u;
+
+export const isQuestionHeading = (heading: string): boolean => QUESTION_END.test(heading.trim());
+
+/** 範囲を決めるのに見るのは、見出しと深さと文だけ。 */
+type Heading = Pick<Section, "depth" | "heading" | "sentences">;
+
+type Answer = { readonly depth: number; readonly sentences: Sentence[] };
+type Passages = { readonly rest: Sentence[]; readonly answers: Answer[]; readonly open: readonly Answer[] };
+
+/** 節は、それを囲む一番内側の問いの答えに入る。同じ深さか浅い見出しが来れば、その問いは閉じている。 */
+const place = (passages: Passages, section: Heading): Passages => {
+  const open = passages.open.filter((answer) => answer.depth < section.depth);
+  if (isQuestionHeading(section.heading)) {
+    const answer = { depth: section.depth, sentences: [...section.sentences] };
+    return { ...passages, answers: [...passages.answers, answer], open: [...open, answer] };
+  }
+  const owner = open.at(-1);
+  (owner?.sentences ?? passages.rest).push(...section.sentences);
+  return { ...passages, open };
+};
+
+/**
+ * 言い回しを数える範囲。問いの見出しの下（より深い見出しの「A1」も含む）はそれぞれ一つの答えで、読み手は答えを一つずつ読む。
+ * 別の答えで同じ案内（〜をご覧ください）を繰り返しても、書き手が言い直したのではない。問いでない節は、文書全体で一つの範囲。
+ */
+export const gramPassagesOf = (sections: readonly Heading[]): Sentence[][] => {
+  const passages = sections.reduce<Passages>(place, { rest: [], answers: [], open: [] });
+  return [passages.rest, ...passages.answers.map((answer) => answer.sentences)].filter((sentences) => sentences.length > 0);
+};