chaffjs 0.31.0 → 0.32.0

package/src/detectors/number-style.ts

@@ -19,6 +19,8 @@ export type NumberWords = {
   readonly countWords: readonly string[];
   /** Plural nouns of measure (days, miles) that take figures in every style: a number before one is not a count. */
   readonly figureNouns: readonly string[];
+  /** Words written before a number to name one of a series (Grade 5, Room 12): the number after one is not a count. */
+  readonly nameWords: readonly string[];
 };
 
 const alternation = (words: readonly string[]): string =>
@@ -147,9 +149,14 @@ const valueOf = (surface: string, words: readonly string[]): number | undefined
 const isCountedNoun = (token: Token | undefined, figureNouns: readonly string[]): boolean =>
   token?.pos === "NOUN" && token.features?.["Number"] === "Plur" && !figureNouns.includes(token.surface.toLowerCase());
 
+/** Whether the text ends in one of the name words, standing as a word of its own (Grade 5, No. 5). */
+const endsInNameWord = (before: string, nameWords: readonly string[]): boolean =>
+  nameWords.length > 0 && new RegExp(`(?<![\\p{L}\\p{N}])(?:${alternation(nameWords)})\\s*$`, "u").test(before);
+
 /**
  * A number before a plural noun (three files, 3 files), from two to the last number word the language lists. One is a
- * pronoun as often as a count. A number word that opens the sentence is spelt out by every style, so it is not counted.
+ * pronoun as often as a count. A number word that opens the sentence is spelt out by every style, so it is not counted,
+ * nor a number after a name word (Grade 5 students), which names the group rather than counting it.
  */
 const englishCountMarks = (sentence: Sentence, words: NumberWords): NumberMark[] => {
   const tokens = sentence.tokens ?? [];
@@ -157,8 +164,9 @@ const englishCountMarks = (sentence: Sentence, words: NumberWords): NumberMark[]
     const value = valueOf(token.surface, words.countWords);
     if (value === undefined || value < SMALL_FROM || value > words.countWords.length || index === 0 || !isCountedNoun(tokens[index + 1], words.figureNouns))
       return [];
+    if (endsInNameWord(sentence.text.slice(0, token.span.start - sentence.span.start), words.nameWords)) return [];
     const style = /^\d+$/u.test(token.surface) ? "digits" : "words";
-    return [{ kind: value < LARGE_FROM ? "count-small" : "count-large", style, written: token.surface, offset: sentence.span.start + token.span.start }];
+    return [{ kind: value < LARGE_FROM ? "count-small" : "count-large", style, written: token.surface, offset: token.span.start }];
   });
 };
 
@@ -201,6 +209,7 @@ const wordsOf = (doc: ProseDocument): NumberWords => {
     percentUnits: patterns("percent-unit"),
     countWords: patterns("count-number"),
     figureNouns: patterns("figure-noun"),
+    nameWords: patterns("number-name-word"),
   };
 };
 

package/src/detectors/order-quantity.ts

@@ -0,0 +1,46 @@
+// delivered-over-ordered and backorder-mismatch: the reading half. Reads the document's Markdown tables and the lexicon
+// order-quantity-column, and leaves the deciding to structure/order-quantity.ts.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { linesOf } from "../structure/lines.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import type { ChangeTable } from "../structure/change-rate-table.ts";
+import type { StructureIssue } from "../structure/issues.ts";
+import { backorderMismatches, deliveredOverOrdered, type QuantityRole, type QuantityWords } from "../structure/order-quantity.ts";
+
+const ROLES: readonly string[] = ["ordered", "delivered", "backordered"] satisfies readonly QuantityRole[];
+const isRole = (group: string | undefined): group is QuantityRole => group !== undefined && ROLES.includes(group);
+
+/**
+ * Lexicon order-quantity-column: the heading words that say which column holds the ordered, delivered and backordered
+ * count, and (group qualifier) the words after a number that make it no exact count.
+ */
+export const quantityWordsOf = (doc: ProseDocument): QuantityWords => {
+  const entries = doc.lexicons["order-quantity-column"] ?? [];
+  return {
+    columns: entries.flatMap((entry) => (isRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : [])),
+    qualifiers: entries.flatMap((entry) => (entry.group === "qualifier" ? [entry.pattern] : [])),
+  };
+};
+
+type RowCheck = (tables: readonly ChangeTable[], words: QuantityWords) => StructureIssue[];
+
+const detectorOf =
+  (rule: string, check: RowCheck): Detector =>
+  (doc): Finding[] => {
+    const words = quantityWordsOf(doc);
+    if (words.columns.length === 0) return [];
+    const tables = tablesOf(linesOf(proseAndTablesOf(doc))).map((table) => ({ header: cellsOf(table.header), rows: table.rows.map(cellsOf) }));
+    return check(tables, words).map((issue) => ({
+      rule,
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: { ...issue.values, offset: issue.offset },
+    }));
+  };
+
+export const deliveredOverOrderedDetector: Detector = detectorOf("delivered-over-ordered", deliveredOverOrdered);
+export const backorderMismatchDetector: Detector = detectorOf("backorder-mismatch", backorderMismatches);

package/src/detectors/orthographic-variant.ts

@@ -7,6 +7,7 @@ import { nameSpans, touchesAny } from "../team-names.ts";
 import { furiganaSpans } from "../furigana.ts";
 import { acronymsIn, isCapitalsNotSpelling } from "../capitals-with-small.ts";
 import { isPartOfAddress } from "./address-word.ts";
+import { wholeWordRuns, type WholeWordRun } from "../whole-word-runs.ts";
 
 /**
  * A word found in the document: where it is, which sentence it is in, its key and spelling, how it is written when that differs, and
@@ -37,6 +38,8 @@ const DISTINCT = "orthographic-variant-distinct";
 const FUKUSHI = "hiragana-fukushi";
 /** Lexicon: idioms written as noun, particle and verb (気をつける). The verb there is compared apart from the verb on its own. */
 const IDIOM = "orthographic-variant-idiom";
+/** Lexicon: words the tokenizer cuts in one spelling and not the other (お客様, お客 and さま). Each is read whole, keyed by its group. */
+const WHOLE_WORD = "orthographic-variant-whole-word";
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
@@ -116,7 +119,7 @@ const isCutFromKatakana = ({ token, previous }: InContext): boolean =>
 const isCopulaReadAsVerb = ({ token, previous }: InContext): boolean =>
   token.pos === "VERB" && token.surface === "で" && previous !== undefined && previous.pos !== "ADP";
 
-type Skips = { readonly skip: ReadonlySet<string>; readonly idioms: ReadonlySet<string> };
+type Skips = { readonly skip: ReadonlySet<string>; readonly idioms: ReadonlySet<string>; readonly wholeWords: ReadonlyMap<string, string> };
 
 const readingKeyOf = (word: InContext, { skip, idioms }: Skips): string | undefined => {
   const { token } = word;
@@ -127,17 +130,40 @@ const readingKeyOf = (word: InContext, { skip, idioms }: Skips): string | undefi
   return `${token.pos}|${useOf(word, idioms)}|${reading}`;
 };
 
+/**
+ * A listed word keyed by its group, so its spellings meet however the tokenizer cut each one. Not by reading: お父様 is read
+ * オ + トウサマ and お父さま オ + チチ + サマ.
+ */
+const wholeWordOf = (
+  sentence: Sentence,
+  tokens: readonly Token[],
+  { first, last, word }: WholeWordRun,
+  isOpen: IsOpen,
+  groups: ReadonlyMap<string, string>,
+): Placed[] => {
+  const [head, tail] = [tokens[first], tokens[last]];
+  if (head === undefined || tail === undefined || !isOpen(head.span.start - sentence.span.start, tail.span.end - sentence.span.start)) return [];
+  return [{ key: `whole|${groups.get(word) ?? word}`, spelling: word, sentence, offset: head.span.start }];
+};
+
 /** Japanese words keyed by part of speech, use and the reading of the dictionary form, spelled as the dictionary form. */
 const readingWords = (sentence: Sentence, isOpen: IsOpen, skips: Skips): Placed[] => {
   const tokens = sentence.tokens ?? [];
-  return tokens.flatMap((token, at): Placed[] => {
-    const key = readingKeyOf({ token, previous: tokens[at - 1], before: tokens[at - 2] }, skips);
-    const local = token.span.start - sentence.span.start;
-    if (key === undefined || token.lemma === undefined || !isOpen(local, local + token.surface.length)) return [];
-    const next = tokens[at + 1];
-    const compoundHead = token.pos === "NOUN" && next?.pos === "NOUN" && isTouching(token, next);
-    return [{ key, spelling: token.lemma, sentence, offset: token.span.start, compoundHead }];
-  });
+  const runs = wholeWordRuns(tokens, skips.wholeWords);
+  const inRun = new Set(runs.flatMap(({ first, last }) => Array.from({ length: last - first + 1 }, (_, extra) => first + extra)));
+  const whole = runs.flatMap((run) => wholeWordOf(sentence, tokens, run, isOpen, skips.wholeWords));
+  return [
+    ...whole,
+    ...tokens.flatMap((token, at): Placed[] => {
+      if (inRun.has(at)) return [];
+      const key = readingKeyOf({ token, previous: tokens[at - 1], before: tokens[at - 2] }, skips);
+      const local = token.span.start - sentence.span.start;
+      if (key === undefined || token.lemma === undefined || !isOpen(local, local + token.surface.length)) return [];
+      const next = tokens[at + 1];
+      const compoundHead = token.pos === "NOUN" && next?.pos === "NOUN" && isTouching(token, next);
+      return [{ key, spelling: token.lemma, sentence, offset: token.span.start, compoundHead }];
+    }),
+  ];
 };
 
 /**
@@ -273,7 +299,11 @@ const cellPlace = (cell: TableCell, names: readonly string[]): Place => {
  * document writes less is pointed at. No way is called right; limit is the largest share, in percent, the minority may have.
  */
 export const orthographicVariant: Detector = (doc, options): Finding[] => {
-  const skips: Skips = { skip: new Set([...patternsOf(doc, DISTINCT), ...patternsOf(doc, FUKUSHI)]), idioms: new Set(patternsOf(doc, IDIOM)) };
+  const skips: Skips = {
+    skip: new Set([...patternsOf(doc, DISTINCT), ...patternsOf(doc, FUKUSHI)]),
+    idioms: new Set(patternsOf(doc, IDIOM)),
+    wholeWords: new Map((doc.lexicons[WHOLE_WORD] ?? []).map((entry) => [entry.pattern, entry.group ?? entry.pattern])),
+  };
   const names = doc.names ?? [];
   const placed: Place[] = [
     ...doc.sentences.map((sentence) => ({ sentence, isOpen: isOpenIn(sentence, names), readsLatin: true })),

package/src/detectors/orthography.ts

@@ -5,7 +5,8 @@ import { minorityReport } from "../spacing-minority.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { digitRunAround, endsWithDivisionLabel, isNumberName, sequenceLabelStarts, type NameContext } from "../number-name.ts";
 import { isSpacedLocationPart, type FloorWords } from "../location-part.ts";
-import { addressSpans, clockTimeSpans, isInsideSpan } from "../spacing-code.ts";
+import { isNameSeparator, type OrganizationWords } from "../name-separator.ts";
+import { addressSpans, clockTimeSpans, identifierSpans, isInsideSpan } from "../spacing-code.ts";
 
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
 export const preferredTerm: Detector = (doc, options): Finding[] => {
@@ -37,13 +38,15 @@ const digitBeside = (boundary: Boundary): number => {
 
 /**
  * 文書全体で一度だけ読むもの（number-name.ts の NameContext に加えて）。calendar は日付・時刻の単位、
- * divisions は「第1節」のように「第」と番号の後ろに書く区切りの語、floors は階・部屋の番号を読む語（5階、201号室、地下 1階）。
+ * divisions は「第1節」のように「第」と番号の後ろに書く区切りの語、floors は階・部屋の番号を読む語（5階、201号室、地下 1階）、
+ * organizations は組織の名前を読む語（経営企画部、株式会社）。
  */
 type NumberContext = NameContext & {
   readonly calendar: CalendarUnits;
   readonly divisions: ReadonlySet<string>;
   readonly itemNumbers: ReadonlySet<string>;
   readonly floors: FloorWords;
+  readonly organizations: OrganizationWords;
 };
 
 /** 文頭の項目の番号の後ろと見る境目の位置の上限。番号は短く文の頭にあるので、これより後ろの境目は番号の後ろではない。長い文で文頭からの切り出しを繰り返さない。 */
@@ -71,23 +74,30 @@ const followsItemNumber = (text: string, boundary: Boundary, itemNumbers: Readon
 const calendarStarts = (sentence: Sentence, units: CalendarUnits): ReadonlySet<number> =>
   new Set(calendarRuns(sentence.text, sentence.tokens, sentence.span.start, units).map(({ run }) => run.start));
 
-/** 英字の側がメールアドレスか URL の境目。後ろの空白は、アドレスの終わりを示す区切り。 */
-const besideAddress = (addresses: readonly Span[], boundary: Boundary): boolean =>
-  isInsideSpan(addresses, boundary.offset - 1) || isInsideSpan(addresses, boundary.spaced ? boundary.offset + 1 : boundary.offset);
+/** 英数字の側が spans のどれか（メールアドレス・URL・番号）の中にある境目。 */
+const besideSpan = (spans: readonly Span[], boundary: Boundary): boolean =>
+  isInsideSpan(spans, boundary.offset - 1) || isInsideSpan(spans, boundary.spaced ? boundary.offset + 1 : boundary.offset);
 
-/** 文の中で一度だけ探すもの: 日付・時刻の数の頭の位置、コロンで書いた時刻、メールアドレス・URL。 */
-type SentenceCodes = { readonly calendar: ReadonlySet<number>; readonly clockTimes: readonly Span[]; readonly addresses: readonly Span[] };
+/** 文の中で一度だけ探すもの: 日付・時刻の数の頭の位置、コロンで書いた時刻、メールアドレス・URL、予約番号や型番のような番号。 */
+type SentenceCodes = {
+  readonly calendar: ReadonlySet<number>;
+  readonly clockTimes: readonly Span[];
+  readonly addresses: readonly Span[];
+  readonly identifiers: readonly Span[];
+};
 
 /**
  * 番号・識別子として書かれた数（number-name.ts）、日付・時刻の数、「第1節」の後ろの境目、文頭の項目の番号（「一 JIS」）の後ろの境目は、空け方の好みではないので数えない。
  * 日付・時刻は前の境目（「は 9月」「午後3時」「令和 3 年」）も数えない。日付はまとめて一つの書き方で、数量の空け方の票にはしない。コロンで書いた時刻（13:30）も同じ。
- * メールアドレス・URL の前後の境目も数えない（spacing-code.ts）。
+ * メールアドレス・URL の前後の境目も数えない（spacing-code.ts）。「予約番号 MN-48215 を」の番号の前後も、番号を文から区切る空白なので数えない。
  * 「本社 5階」のように名前の後ろに空白で区切った階・部屋の番号の前の空白も、所在の組の区切りなので数えない（location-part.ts）。
+ * 「経営企画部 IR担当」のように名前だけを並べた行で、名前と名前を分ける空白も数えない（name-separator.ts）。
  */
 const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, codes: SentenceCodes): boolean => {
-  if (followsItemNumber(sentence.text, boundary, context.itemNumbers)) return false;
+  if (followsItemNumber(sentence.text, boundary, context.itemNumbers) || besideSpan(codes.identifiers, boundary)) return false;
   if (boundary.kind !== "after-digit" && endsWithDivisionLabel(sentence.text.slice(0, boundary.offset), context.divisions)) return false;
-  if (boundary.kind === "letter") return !besideAddress(codes.addresses, boundary);
+  if (boundary.kind === "letter")
+    return !besideSpan(codes.addresses, boundary) && !isNameSeparator(sentence.text, boundary, sentence.tokens, sentence.span.start, context.organizations);
   if (isInsideSpan(codes.clockTimes, digitBeside(boundary))) return false;
   const run = digitRunAround(sentence.text, digitBeside(boundary));
   if (run === undefined) return true;
@@ -160,10 +170,16 @@ export const latinSpacing: Detector = (doc, options): Finding[] => {
     divisions: labelsAt(doc, "after"),
     itemNumbers: numberedItems(patternList(doc, "item-number"), doc.prose ?? doc.source),
     floors: { units: patternsOf(doc, "floor-unit"), levels: patternsOf(doc, "floor-level") },
+    organizations: { units: patternsOf(doc, "organization-unit"), forms: patternList(doc, "company-form") },
   };
   const located: Located[] = doc.sentences.flatMap((sentence) => {
     const quoted = quotedSpans(sentence.text);
-    const codes = { calendar: calendarStarts(sentence, context.calendar), clockTimes: clockTimeSpans(sentence.text), addresses: addressSpans(sentence.text) };
+    const codes = {
+      calendar: calendarStarts(sentence, context.calendar),
+      clockTimes: clockTimeSpans(sentence.text),
+      addresses: addressSpans(sentence.text),
+      identifiers: identifierSpans(sentence.text),
+    };
     return latinBoundaries(sentence.text, doc.source.slice(sentence.span.start, sentence.span.end))
       .filter((boundary) => !isQuoted(quoted, boundary) && !isInsideLink(doc.links, sentence.span.start + boundary.offset))
       .filter((boundary) => isCounted(sentence, boundary, context, codes))

package/src/detectors/period-label-conflict.ts

@@ -0,0 +1,43 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { periodLabelConflicts, type ReportingWords } from "../structure/period-label-conflict.ts";
+import { compileFrames, type Era, type PeriodFrame } from "../structure/period-labels.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+const framesOf = (doc: ProseDocument, lexicon: string, titleAlone: boolean): PeriodFrame[] =>
+  (doc.lexicons[lexicon] ?? []).flatMap((entry) =>
+    entry.group === undefined ? [] : [{ pattern: entry.pattern, kind: entry.group, insteadOf: entry.instead_of, titleAlone }],
+  );
+
+const erasOf = (doc: ProseDocument): Era[] =>
+  (doc.lexicons["calendar-era"] ?? []).flatMap((entry) => (entry.first_year === undefined ? [] : [{ name: entry.pattern, firstYear: entry.first_year }]));
+
+/**
+ * 期間の名前の書き方と種類（group）、業績の語、期間の行の語、比べる相手と見込みの語、今の期間の語とそれに似た別の語、名前に似た別の語は語彙表から取る。
+ * reporting-year-frame の書き方（令和8年分、Tax Year 2026）は業績の語の無い題からも読む。元号の年は calendar-era の元年で西暦にする。
+ */
+const wordsOf = (doc: ProseDocument): ReportingWords => ({
+  frames: compileFrames([...framesOf(doc, "reporting-period-frame", false), ...framesOf(doc, "reporting-year-frame", true)], erasOf(doc)),
+  results: patternsOf(doc, "reporting-results-word"),
+  periodLines: patternsOf(doc, "reporting-period-line"),
+  comparisons: patternsOf(doc, "reporting-comparison"),
+  forecasts: patternsOf(doc, "reporting-forecast"),
+  currents: patternsOf(doc, "reporting-current"),
+  notCurrents: patternsOf(doc, "reporting-current-not"),
+  notNames: patternsOf(doc, "reporting-period-not"),
+});
+
+/** 題で言った決算の期間と同じ種類の別の期間を、今の業績を言う所に書いた所。 */
+export const periodLabelConflict: Detector = (doc): Finding[] => {
+  const headings = (doc.markup?.headings ?? []).map((heading) => ({ start: heading.start, end: heading.end, text: heading.text }));
+  const sentences = doc.sentences.map((sentence) => sentence.span);
+  return periodLabelConflicts(doc.source, sentences, headings, wordsOf(doc)).map((issue) => ({
+    rule: "period-label-conflict",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { label: issue.label, stated: issue.stated, offset: issue.offset },
+  }));
+};

package/src/detectors/period-multiple-mismatch.ts

@@ -0,0 +1,54 @@
+// period-multiple-mismatch: an amount stated as a number of another period's amount (月払の12か月分, 12 monthly payments)
+// that is not that many of it (structure/period-multiple.ts). The amounts are currency-notation's, read with
+// amount-multiplier's words of scale; the base labels are period-multiple-label, the words period-multiple-word, the counts
+// number-word (digit), and a range of counts is joined by range-connector or amount-range-word.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { periodMultipleMismatches, type PeriodMultipleWords } from "../structure/period-multiple.ts";
+import type { StatedAmount } from "../structure/stated-multiple.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";
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
+
+const numberWordsOf = (doc: ProseDocument): PeriodMultipleWords["numberWords"] =>
+  (doc.lexicons["number-word"] ?? []).flatMap((entry) =>
+    entry.group === "digit" && entry.weight !== undefined ? [{ word: entry.pattern, value: entry.weight }] : [],
+  );
+
+const wordsOf = (doc: ProseDocument): PeriodMultipleWords => ({
+  bases: patternsOf(doc, "period-multiple-label"),
+  times: patternsOf(doc, "period-multiple-word", "times"),
+  links: patternsOf(doc, "period-multiple-word", "link"),
+  skips: patternsOf(doc, "period-multiple-word", "skip"),
+  connectors: [...patternsOf(doc, "range-connector"), ...patternsOf(doc, "amount-range-word")],
+  numberWords: numberWordsOf(doc),
+});
+
+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 periodMultipleMismatch: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  return periodMultipleMismatches(text, amountsOf(text, doc), wordsOf(doc)).map((issue) => ({
+    rule: "period-multiple-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/period-part.ts

@@ -0,0 +1,71 @@
+import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { overlapsAny, spanIndex } from "../compare/spans.ts";
+import type { DurationUnit } from "../derived/date-arithmetic.ts";
+import { hyphenatedCounts } from "../derived/hyphenated-counts.ts";
+import { periodPartIssues, tableRowsOf, type PeriodLength, type PeriodPartWords, type PlacedWord } from "../derived/period-parts.ts";
+import { DURATION_LEXICONS, quantitiesOf } from "./derived-numbers.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const UNITS: readonly DurationUnit[] = ["day", "week", "month", "year"];
+const isDurationUnit = (group: string | undefined): group is DurationUnit => UNITS.some((unit) => unit === group);
+
+/** 期間の単位（か月、months）と、年数にもなる単位（「保証期間は1年」の 年。retention-unit の group が大きさ）。 */
+const unitOf = (doc: ProseDocument, unit: string): DurationUnit | undefined => {
+  const folded = unit.normalize("NFKC").toLowerCase();
+  const listed = DURATION_LEXICONS.find(([id]) => patternsOf(doc, id).some((pattern) => pattern.normalize("NFKC").toLowerCase() === folded))?.[1];
+  const extra = (doc.lexicons["retention-unit"] ?? []).find((entry) => entry.pattern.normalize("NFKC") === folded)?.group;
+  return listed ?? (isDurationUnit(extra) ? extra : undefined);
+};
+
+const datesOf = (tree: StructureNode) => spanIndex(inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [node.span] : [])));
+
+/** 木の数量（12か月、2 years）と名詞の前の期間（a 12-month warranty）。日付の中の数（2026年）は読まない。 */
+const lengthsOf = (doc: ProseDocument, tree: StructureNode): PeriodLength[] => {
+  const dates = datesOf(tree);
+  const hyphenated = hyphenatedCounts(
+    doc.source,
+    DURATION_LEXICONS.flatMap(([id]) => patternsOf(doc, id)),
+  );
+  return [...quantitiesOf(tree, doc.source), ...hyphenated]
+    .flatMap((quantity): PeriodLength[] => {
+      const unit = unitOf(doc, quantity.unit);
+      return unit === undefined || overlapsAny(dates, quantity) ? [] : [{ start: quantity.start, end: quantity.end, amount: quantity.amount, unit }];
+    })
+    .toSorted((left, right) => left.start - right.start);
+};
+
+const placed = (doc: ProseDocument, id: string): PlacedWord[] =>
+  (doc.lexicons[id] ?? []).map((entry) => ({ pattern: entry.pattern, position: entry.position ?? "before" }));
+
+/** 印、期間の語、後に来る期間の語、長さを言う語、目安と幅の語は語彙表から取る。 */
+const wordsOf = (doc: ProseDocument): PeriodPartWords => ({
+  markers: (doc.lexicons["period-part-marker"] ?? []).map((entry) => ({ pattern: entry.pattern, position: entry.position ?? "after", group: entry.group })),
+  periodWords: patternsOf(doc, "period-part-word"),
+  afterWords: patternsOf(doc, "period-part-after"),
+  lengthVerbs: patternsOf(doc, "period-part-length-verb"),
+  approximate: placed(doc, "approximate-marker"),
+  rangeJoiners: patternsOf(doc, "period-part-range"),
+  inlineJoiners: patternsOf(doc, "period-part-inline-joiner"),
+  unnamed: patternsOf(doc, "period-part-unnamed"),
+});
+
+const written = (doc: ProseDocument, span: { start: number; end: number }): string => doc.source.slice(span.start, span.end);
+
+/** 期間の一部として書いた期間が、全体の期間より長い（保証期間（12か月）のうち、無料交換期間は18か月）。 */
+export const periodPartExceedsWhole: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const units = [...doc.sentences.map((sentence) => sentence.span), ...tableRowsOf(doc.source)].toSorted((left, right) => left.start - right.start);
+  const sectionStarts = (doc.markup?.headings ?? []).map((heading) => heading.start);
+  const input = { source: doc.source, units, sectionStarts, lengths: lengthsOf(doc, doc.structure), words: wordsOf(doc) };
+  return periodPartIssues(input).map(({ part, whole }) => ({
+    rule: "period-part-exceeds-whole",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, part.start),
+    values: { part: written(doc, part), whole: written(doc, whole), offset: part.start },
+  }));
+};

package/src/detectors/range-words.ts

@@ -0,0 +1,17 @@
+import type { ProseDocument } from "../plugin.ts";
+import { rangeFrameOf } from "../structure/date-range.ts";
+import type { PeriodWords } from "../structure/stated-period.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+/** The words that read a period on a labelled line: the range signs (range-connector, range-opener, range-frame's joint), month and weekday names. */
+export const periodWordsOf = (doc: ProseDocument, labels: readonly string[]): PeriodWords => ({
+  labels,
+  connectors: [
+    ...patternsOf(doc, "range-connector"),
+    ...patternsOf(doc, "range-opener"),
+    ...patternsOf(doc, "range-frame").flatMap((pattern) => rangeFrameOf(pattern)?.joint ?? []),
+  ],
+  months: patternsOf(doc, "month-name"),
+  weekdays: patternsOf(doc, "weekday"),
+});

package/src/detectors/ratio-mismatch.ts

@@ -0,0 +1,116 @@
+// ratio-mismatch: the reading half. Reads the tables (each row's label and cells) and the sentences (the words of lexicons
+// ratio-label and ratio-term, and the structure tree's quantities in a currency or a percent unit) and leaves the deciding
+// to structure/ratio.ts.
+import type { Detector, Finding, ProseDocument, Span } from "../plugin.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAt } from "./structure-tree.ts";
+import {
+  proseValues,
+  sentenceRatioMismatch,
+  tableRatioMismatches,
+  type AmountWords,
+  proseQuantitiesOf,
+  type LabelHit,
+  type RatioIssue,
+  type RatioWords,
+  type TableRow,
+} from "../structure/ratio.ts";
+
+const RULE = "ratio-mismatch";
+const LATIN = /^[A-Za-z]/u;
+/** A ratio label's group names the two terms it divides: "operating-profit/sales". */
+const GROUP_SEPARATOR = "/";
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const wordsOf = (doc: ProseDocument): RatioWords => ({
+  labels: (doc.lexicons["ratio-label"] ?? []).flatMap((entry) => {
+    const [numerator, denominator, ...rest] = (entry.group ?? "").split(GROUP_SEPARATOR);
+    return numerator === undefined || denominator === undefined || rest.length > 0 ? [] : [{ pattern: entry.pattern, numerator, denominator }];
+  }),
+  terms: (doc.lexicons["ratio-term"] ?? []).flatMap((entry) => (entry.group === undefined ? [] : [{ pattern: entry.pattern, term: entry.group }])),
+  percentUnits: patternsOf(doc, "percent-unit"),
+});
+
+const currencyMarks = (doc: ProseDocument, position: "before" | "after"): string[] =>
+  (doc.lexicons["currency-notation"] ?? []).filter((entry) => entry.position === position).map((entry) => entry.pattern);
+
+const amountWordsOf = (doc: ProseDocument, percentUnits: readonly string[]): AmountWords => ({
+  before: currencyMarks(doc, "before"),
+  after: currencyMarks(doc, "after"),
+  multipliers: patternsOf(doc, "amount-multiplier"),
+  percentUnits,
+});
+
+/** A table line read as its label (the first cell) and the cells after it, each without its edge marks. */
+export const tableRowOf = (row: Line): TableRow[] => {
+  const [first, ...rest] = cellsOf(row);
+  if (first === undefined) return [];
+  const cells = rest.map((cell) => {
+    const text = withoutEdgeMarks(cell.text);
+    return { start: cell.start + Math.max(0, cell.text.indexOf(text)), text };
+  });
+  return [{ label: withoutEdgeMarks(first.text), cells }];
+};
+
+const tableRowsOf = (source: string): TableRow[][] => tablesOf(linesOf(source)).map((table) => table.rows.flatMap(tableRowOf));
+
+/** A kanji or katakana next to a word written in them makes it part of a longer word (営業利益率 in 調整後営業利益率). */
+const CJK_LETTER = /[\p{sc=Han}\p{sc=Katakana}ー]/u;
+
+/** Where a word stands in the text: a Latin word as a whole word in any case, any other word not inside a longer one. */
+const spansOf = (text: string, offset: number, word: string): Span[] => {
+  const latin = LATIN.test(word);
+  const pattern = latin ? new RegExp(`\\b${escapeRegExp(word)}\\b`, "giu") : new RegExp(escapeRegExp(word), "gu");
+  return [...text.matchAll(pattern)]
+    .filter((match) => latin || !(CJK_LETTER.test(text.charAt(match.index - 1)) || CJK_LETTER.test(text.charAt(match.index + match[0].length))))
+    .map((match) => ({ start: offset + match.index, end: offset + match.index + match[0].length }));
+};
+
+/** A word inside a longer one is not a word of its own (営業利益 in 営業利益率, sales in net sales). */
+const longestHits = (hits: readonly LabelHit[]): LabelHit[] =>
+  hits.filter(
+    (hit) => !hits.some((other) => other !== hit && other.start <= hit.start && hit.end <= other.end && other.end - other.start > hit.end - hit.start),
+  );
+
+const hitsIn = (text: string, offset: number, words: RatioWords): LabelHit[] => {
+  const labels = words.labels.flatMap((label) => spansOf(text, offset, label.pattern).map((at) => ({ ...at, label })));
+  const terms = words.terms.flatMap((term) => spansOf(text, offset, term.pattern).map((at) => ({ ...at, term: term.term })));
+  return longestHits([...labels, ...terms]);
+};
+
+const proseIssues = (doc: ProseDocument, words: RatioWords): RatioIssue[] => {
+  const named = doc.sentences.flatMap((sentence) => {
+    const text = doc.source.slice(sentence.span.start, sentence.span.end);
+    const hits = hitsIn(text, sentence.span.start, words);
+    return hits.some((hit) => "label" in hit) ? [{ span: sentence.span, text, hits }] : [];
+  });
+  if (named.length === 0) return [];
+  const amountWords = amountWordsOf(doc, words.percentUnits);
+  const quantities = proseQuantitiesOf(doc.structure);
+  return named.flatMap(({ span, text, hits }) => {
+    const issue = sentenceRatioMismatch({ hits, end: span.end, ...proseValues(text, span.start, quantities, amountWords) });
+    return issue === undefined ? [] : [issue];
+  });
+};
+
+export const ratioMismatch: Detector = (doc): Finding[] => {
+  const words = wordsOf(doc);
+  if (words.labels.length === 0) return [];
+  const tables = tableRowsOf(proseAndTablesOf(doc)).flatMap((rows) => tableRatioMismatches(rows, words));
+  const prose = proseIssues(doc, words).filter((issue) => !tables.some((table) => table.offset === issue.offset));
+  return [...tables, ...prose]
+    .toSorted((left, right) => left.offset - right.offset)
+    .map((issue) => ({
+      rule: RULE,
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: { ...issue.values, offset: issue.offset },
+    }));
+};

package/src/detectors/readable-dates.ts

@@ -0,0 +1,36 @@
+import type { ProseDocument } from "../plugin.ts";
+import { dayOrderOf, readableDate, type DateWords } from "../derived/readable-date.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+
+const MONTHS_IN_YEAR = 12;
+
+const wordsOf = (doc: ProseDocument): DateWords => {
+  const monthWords = (doc.lexicons["month-name"] ?? []).map((entry) => entry.pattern);
+  const written =
+    doc.structure === undefined
+      ? []
+      : inDocumentOrder(doc.structure).flatMap((node) => (node.kind === "date" ? [doc.source.slice(node.span.start, node.span.end)] : []));
+  return { language: doc.language, months: monthWords.slice(0, MONTHS_IN_YEAR), order: dayOrderOf(written, monthWords) };
+};
+
+const wordsByDocument = new WeakMap<ProseDocument, DateWords>();
+
+/**
+ * A date value (2026-06-30) as a message writes it, in the document's language and its own day order. The month names are
+ * the language's month-name lexicon (January first). The document is read once, on the first date a message needs.
+ */
+export const readableDates =
+  (doc: ProseDocument) =>
+  (value: string): string => {
+    const words = wordsByDocument.get(doc) ?? wordsOf(doc);
+    wordsByDocument.set(doc, words);
+    return readableDate(value, words);
+  };
+
+/** The named values written as readable dates; the other values as they are. */
+export const withReadableDates = (
+  values: Readonly<Record<string, string | number>>,
+  keys: readonly string[],
+  readable: (value: string) => string,
+): Record<string, string | number> =>
+  Object.fromEntries(Object.entries(values).map(([key, value]) => [key, keys.includes(key) && typeof value === "string" ? readable(value) : value]));

package/src/detectors/reference-flag.ts

@@ -0,0 +1,36 @@
+// reference-flag-mismatch: the reading half (structure/reference-flags.ts). The column headings are lab-result-column's and
+// reference-column-heading's, the flags reference-flag's, and a range is read with range-band-word and reference-bound-mark.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { referenceFlagSlips, type FlagMeaning, type ReferenceWords } from "../structure/reference-flags.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { labColumnWordsOf } from "./lab-columns.ts";
+import { bandWordsOf } from "./range-band.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const isMeaning = (group: string | undefined): group is FlagMeaning => group === "high" || group === "low" || group === "normal" || group === "outside";
+
+const wordsOf = (doc: ProseDocument): ReferenceWords => {
+  const boundWords = [...(doc.lexicons["range-band-word"] ?? []), ...(doc.lexicons["reference-bound-mark"] ?? [])];
+  const band = bandWordsOf({ ...doc.lexicons, "range-band-word": boundWords });
+  return {
+    headings: labColumnWordsOf(doc, "reference-column-heading"),
+    flags: (doc.lexicons["reference-flag"] ?? []).flatMap((entry) => (isMeaning(entry.group) ? [{ pattern: entry.pattern, meaning: entry.group }] : [])),
+    band: { ...band, units: [], headings: [] },
+  };
+};
+
+export const referenceFlag: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  return referenceFlagSlips(text, wordsOf(doc)).map((slip) => {
+    const offset = slip.flag.start + (slip.flag.text.length - slip.flag.text.trimStart().length);
+    return {
+      rule: "reference-flag-mismatch",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(text, offset),
+      ...(slip.kind === "inside" ? {} : { variant: slip.kind }),
+      values: { item: slip.item, value: slip.value, range: slip.range, flag: slip.flag.text.trim(), offset },
+    };
+  });
+};