chaffjs 0.30.0 → 0.31.0

package/src/detectors/name-variant.ts

@@ -1,14 +1,16 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { cuedNamesIn, mentionsIn, nameVariants, suffixedNamesIn, withKnownNeighbours, type NameMention, type VariantChars } from "../name-variants.ts";
+import type { SpellingInput } from "../name-spelling-chars.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 { proseAndTablesOf } from "../table-text.ts";
 import { tableBodyCells } from "../facts/table-facts.ts";
 import { cellNamesIn, cellNameVariants, proseNamesOf } from "../table-names.ts";
-import { placeMentionsIn, placeVariants, type PlaceReader, type PlaceWord } from "../place-names.ts";
+import { placeMentionsIn, placeVariants, type PlaceChars, type PlaceReader, type PlaceWord } from "../place-names.ts";
 import type { TableCell, Token } from "../plugin.ts";
 import { proseWithCells } from "../table-cells.ts";
+import { modelCodeFindings } from "./name-variant-model-codes.ts";
 import { labelledSpans, orderNamesOf, quotedSpans, stemOf, titleCaseSpans, wordOrderVariants, type OrderWord } from "../name-word-order.ts";
 
 // 人の名前と読ませる敬称（様、さん）は語彙表 person-suffix、人を指す前置き（担当の）は person-lead、名前のすぐ後ろに来る語
@@ -33,6 +35,18 @@ const properOf = (doc: ProseDocument): IsProper => {
 const placeWordsOf = (doc: ProseDocument): PlaceWord[] =>
   (doc.lexicons["place-word"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
 
+/**
+ * 場所の名前の字。方角や位置の字（東、上、新）は語彙表 place-direction、読みの同じ字（洲 と 州）は place-name-char と、字体の違う
+ * 同じ字の name-variant-char が組（group）ごとに言う。
+ */
+const placeCharsOf = (doc: ProseDocument, chars: VariantChars): PlaceChars => ({
+  directions: new Set(patternsOf(doc, "place-direction")),
+  sameReading: new Map([
+    ...chars,
+    ...(doc.lexicons["place-name-char"] ?? []).flatMap((entry): [string, string][] => (entry.group === undefined ? [] : [[entry.pattern, entry.group]])),
+  ]),
+});
+
 /** 名前の頭に立たない語の品詞（The、at、and）。 */
 const FUNCTION_POS: ReadonlySet<string> = new Set(["DET", "ADP", "PRON", "CCONJ", "SCONJ", "AUX", "PART"]);
 
@@ -87,8 +101,8 @@ const companyFindings = (doc: ProseDocument, prose: string, reported: readonly R
     .map(({ mention, usual, kind }) => ({ offset: mention.offset, name: mention.surface, usual, kind: kind === "spelling" ? kind : `company-${kind}` }));
 
 /** 場所の名前の書き分け。表の本体の升の中の名前も読む（見出しの行は読まない）。人や会社の名前の見方がすでに指した所と重なるものは除く。 */
-const placeFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] =>
-  placeVariants(placeMentionsIn(proseWithCells(prose, cellsOf(doc)), placeWordsOf(doc), placeReaderOf(doc)))
+const placeFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[], chars: VariantChars): Reported[] =>
+  placeVariants(placeMentionsIn(proseWithCells(prose, cellsOf(doc)), placeWordsOf(doc), placeReaderOf(doc)), placeCharsOf(doc, chars))
     .filter(({ mention }) => !overlapsAny(reported, mention.offset, mention.surface.length))
     .map(({ mention, usual, kind }) => ({ offset: mention.offset, name: mention.surface, usual, kind }));
 
@@ -142,6 +156,16 @@ const nameMentionsOf = (doc: ProseDocument, prose: string, chars: VariantChars):
   return withKnownNeighbours(cued, prose).toSorted((left, right) => left.offset - right.offset);
 };
 
+/** 一語の名前の中で同じ音を書く字（ヶ・ケ・が）は語彙表 name-spelling-char が組（group）ごとに言う。 */
+const spellingCharsOf = (doc: ProseDocument): VariantChars =>
+  new Map((doc.lexicons["name-spelling-char"] ?? []).flatMap((entry): [string, string][] => (entry.group === undefined ? [] : [[entry.pattern, entry.group]])));
+
+/** 名前の中の同じ音の字は、表の升の中の、解析器が固有名詞と読む語（物件名の升の 桜ケ丘）とも比べる。 */
+const spellingInputOf = (doc: ProseDocument): SpellingInput => {
+  const suffixes = patternsOf(doc, "person-suffix");
+  return { chars: spellingCharsOf(doc), alsoWritten: cellsOf(doc).flatMap((cell) => mentionsIn(cell.tokens ?? [], doc.source, suffixes)) };
+};
+
 /** 表の升に書いた名前の書き分け。名前の形をした升を、本文の名前と比べる。ほかの見方がすでに指した所と重なるものは除く。 */
 const tableFindings = (doc: ProseDocument, prose: string, mentions: readonly NameMention[], reported: readonly Reported[]): Reported[] =>
   cellNameVariants(cellNamesIn(cellsOf(doc)), proseNamesOf(mentions, prose))
@@ -153,7 +177,7 @@ export const nameVariant: Detector = (doc): Finding[] => {
   const prose = doc.prose ?? doc.source;
   const chars = variantCharsOf(doc);
   const mentions = nameMentionsOf(doc, prose, chars);
-  const names = nameVariants(mentions, chars).map(({ mention, usual, kind }): Reported => ({
+  const names = nameVariants(mentions, chars, spellingInputOf(doc)).map(({ mention, usual, kind }): Reported => ({
     offset: mention.offset,
     name: mention.surface,
     usual,
@@ -161,8 +185,10 @@ export const nameVariant: Detector = (doc): Finding[] => {
   }));
   const namesAndCompanies = [...names, ...companyFindings(doc, prose, names)];
   const withTables = [...namesAndCompanies, ...tableFindings(doc, prose, mentions, namesAndCompanies)];
-  const withPlaces = [...withTables, ...placeFindings(doc, prose, withTables)];
-  return [...withPlaces, ...orderFindings(doc, prose, withPlaces)]
+  const withPlaces = [...withTables, ...placeFindings(doc, prose, withTables, chars)];
+  const withOrder = [...withPlaces, ...orderFindings(doc, prose, withPlaces)];
+  const codes = modelCodeFindings(doc, prose).filter((code) => !overlapsAny(withOrder, code.offset, code.name.length));
+  return [...withOrder, ...codes]
     .toSorted((left, right) => left.offset - right.offset)
     .map(({ offset, name, usual, kind }) => ({
       rule: "",

package/src/detectors/orthographic-variant.ts

@@ -1,6 +1,6 @@
-import type { Detector, Finding, ProseDocument, Sentence, Token } from "../plugin.ts";
+import type { Detector, Finding, ProseDocument, Sentence, TableCell, Token } from "../plugin.ts";
 import { groupBy, oddSpellings, type KeyedWord, type OddSpelling } from "../spelling-variants.ts";
-import { dropsOkurigana, kanjiSkeleton, katakanaKey, lemmaReading } from "../kana-spelling.ts";
+import { dropsOkurigana, kanjiKeyAmong, katakanaKey, lemmaReading } from "../kana-spelling.ts";
 import { isKatakanaWord, stemOf } from "../long-vowel.ts";
 import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { nameSpans, touchesAny } from "../team-names.ts";
@@ -12,7 +12,14 @@ import { isPartOfAddress } from "./address-word.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
  * whether it is written onto the noun after it (取扱事業者).
  */
-type Placed = KeyedWord & { readonly sentence: Sentence; readonly offset: number; readonly shown?: string; readonly compoundHead?: boolean };
+type Placed = KeyedWord & {
+  readonly sentence: Sentence;
+  readonly offset: number;
+  readonly shown?: string;
+  readonly compoundHead?: boolean;
+  /** Where a run of words ends (タイヤレバー). */
+  readonly end?: number;
+};
 
 type IsOpen = (start: number, end: number) => boolean;
 
@@ -141,11 +148,12 @@ const readingWords = (sentence: Sentence, isOpen: IsOpen, skips: Skips): Placed[
  */
 const byKanji = (words: readonly Placed[]): Placed[] =>
   [...groupBy(words, (word) => word.key).values()].flatMap((group) => {
-    const skeletons = [...new Set(group.map((word) => kanjiSkeleton(word.spelling)).filter((skeleton) => skeleton !== ""))];
     const spellings = [...new Set(group.map((word) => word.spelling))];
+    const skeletonOf = (spelling: string): string => kanjiKeyAmong(spelling, spellings);
+    const skeletons = [...new Set(spellings.map(skeletonOf).filter((skeleton) => skeleton !== ""))];
     const apart = spellings.some((spelling) => dropsOkurigana(spelling, spellings)) ? "|compound" : "";
     return group.flatMap((word): Placed[] => {
-      const own = kanjiSkeleton(word.spelling);
+      const own = skeletonOf(word.spelling);
       if (own === "" && skeletons.length > 1) return [];
       const use = word.compoundHead === true ? apart : "";
       return [{ ...word, key: `${word.key}|${own === "" ? (skeletons[0] ?? "") : own}${use}` }];
@@ -161,6 +169,44 @@ const katakanaWords = (sentence: Sentence, isOpen: IsOpen): Placed[] =>
     return [...key].length < MIN_KATAKANA_KEY ? [] : [{ key: `kana|${key}`, spelling: stemOf(token.surface), sentence, offset: token.span.start }];
   });
 
+const isKatakanaNoun = (token: Token): boolean => token.pos === "NOUN" && isKatakanaWord(token.surface);
+
+/** Katakana nouns written onto each other (タイヤ and レバー in タイヤレバー), each run whole: one place may be cut into words another is not. */
+const katakanaRuns = (tokens: readonly Token[]): Token[][] =>
+  tokens.reduce<Token[][]>((runs, token, at) => {
+    if (!isKatakanaNoun(token)) return runs;
+    const last = runs.at(-1);
+    if (last !== undefined && isTouching(tokens[at - 1], token) && last.at(-1) === tokens[at - 1]) last.push(token);
+    else runs.push([token]);
+    return runs;
+  }, []);
+
+/**
+ * Katakana runs keyed like one katakana word, spelled as their words' stems joined: タイヤーレバー (one unknown word) meets
+ * タイヤレバー read as タイヤ and レバー, while the final ー of a word inside the run (サーバーリスト and サーバリスト) stays katakana-long-vowel's.
+ */
+const katakanaRunWords = (sentence: Sentence, isOpen: IsOpen): Placed[] =>
+  katakanaRuns(sentence.tokens ?? []).flatMap((run): Placed[] => {
+    const [first, last] = [run[0], run.at(-1)];
+    if (first === undefined || last === undefined) return [];
+    const [start, end] = [first.span.start - sentence.span.start, last.span.end - sentence.span.start];
+    const key = katakanaKey(run.map((token) => token.surface).join(""));
+    if ([...key].length < MIN_KATAKANA_KEY || !isOpen(start, end)) return [];
+    return [
+      {
+        key: `kana|${key}`,
+        spelling: run.map((token) => stemOf(token.surface)).join(""),
+        shown: run.map((token) => token.surface).join(""),
+        sentence,
+        offset: first.span.start,
+        end: last.span.end,
+      },
+    ];
+  });
+
+/** Whether a run holds a place another key already points at: the word inside it is said, not the run around it. */
+const coversOffset = (run: Placed, offset: number): boolean => offset >= run.offset && offset < (run.end ?? run.offset + 1);
+
 const LATIN_WORD = /[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)*/gu;
 const LOWER = /\p{Ll}/u;
 
@@ -204,6 +250,23 @@ const findingOf = (words: readonly Placed[], odd: OddSpelling<Placed>): Finding
   values: { written: odd.word.shown ?? odd.word.spelling, other: shownUsual(words, odd), count: odd.count, of: odd.of, offset: odd.word.offset },
 });
 
+/** A cell that is one Latin word in lower case (openapi, contentType): a field name or a value, spelled by the data and not by the writer. */
+const DATA_KEY_CELL = /^\p{Ll}[A-Za-z0-9]*$/u;
+
+type Place = { readonly sentence: Sentence; readonly isOpen: IsOpen; readonly readsLatin: boolean };
+
+/** A link's brackets and where it goes (`[`, `](#contentType)`, `][ref]`). The prose hides them outside tables; a cell keeps the Markdown as written. */
+const LINK_CHROME = /\]\([^)]*\)|\]\[[^\]]*\]|\[/gu;
+
+const withoutLinkChrome = (text: string): string => text.replaceAll(LINK_CHROME, (chrome) => " ".repeat(chrome.length));
+
+/** A body cell of a table read as a sentence of its own: the prose covers tables, so a cell's words (片栗粉 in a list of ingredients) are not in the sentences. Header rows stay out. */
+const cellPlace = (cell: TableCell, names: readonly string[]): Place => {
+  const text = withoutLinkChrome(cell.text);
+  const sentence: Sentence = { span: { start: cell.start, end: cell.end }, text, tokens: cell.tokens ?? [] };
+  return { sentence, isOpen: isOpenIn(sentence, names), readsLatin: !DATA_KEY_CELL.test(text.trim()) };
+};
+
 /**
  * One word written two ways in one document (出来る and できる, 引っ越し and 引越し, ウィンドウ and ウインドウ, e-mail and email),
  * found without a list of words: the document's own words are grouped by reading or by an evened-out spelling, and the way the
@@ -211,12 +274,18 @@ const findingOf = (words: readonly Placed[], odd: OddSpelling<Placed>): Finding
  */
 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 placed = doc.sentences.map((sentence) => ({ sentence, isOpen: isOpenIn(sentence, doc.names ?? []) }));
+  const names = doc.names ?? [];
+  const placed: Place[] = [
+    ...doc.sentences.map((sentence) => ({ sentence, isOpen: isOpenIn(sentence, names), readsLatin: true })),
+    ...(doc.tableCells?.() ?? []).map((cell) => cellPlace(cell, names)),
+  ];
   const reading = byKanji(placed.flatMap(({ sentence, isOpen }) => readingWords(sentence, isOpen, skips)));
   const katakana = placed.flatMap(({ sentence, isOpen }) => katakanaWords(sentence, isOpen));
-  const latin = placed.flatMap(({ sentence, isOpen }) => latinWords(sentence, isOpen, skips.skip));
+  const runs = placed.flatMap(({ sentence, isOpen }) => katakanaRunWords(sentence, isOpen));
+  const latin = placed.flatMap(({ sentence, isOpen, readsLatin }) => (readsLatin ? latinWords(sentence, isOpen, skips.skip) : []));
   const odd = [reading, katakana, latin].flatMap((words) => oddSpellings(words, options.limit));
-  const all = [...reading, ...katakana, ...latin];
+  const oddRuns = oddSpellings(runs, options.limit).filter(({ word }) => !odd.some((other) => coversOffset(word, other.word.offset)));
+  const all = [...reading, ...katakana, ...runs, ...latin];
   // A word can be odd by its reading and by its katakana key at once; one place is said once.
-  return [...new Map(odd.map((entry) => [entry.word.offset, entry])).values()].map((entry) => findingOf(all, entry));
+  return [...new Map([...odd, ...oddRuns].map((entry) => [entry.word.offset, entry])).values()].map((entry) => findingOf(all, entry));
 };

package/src/detectors/orthography.ts

@@ -5,6 +5,7 @@ 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";
 
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
 export const preferredTerm: Detector = (doc, options): Finding[] => {
@@ -70,18 +71,27 @@ 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);
+
+/** 文の中で一度だけ探すもの: 日付・時刻の数の頭の位置、コロンで書いた時刻、メールアドレス・URL。 */
+type SentenceCodes = { readonly calendar: ReadonlySet<number>; readonly clockTimes: readonly Span[]; readonly addresses: readonly Span[] };
+
 /**
  * 番号・識別子として書かれた数（number-name.ts）、日付・時刻の数、「第1節」の後ろの境目、文頭の項目の番号（「一 JIS」）の後ろの境目は、空け方の好みではないので数えない。
- * 日付・時刻は前の境目（「は 9月」「午後3時」「令和 3 年」）も数えない。日付はまとめて一つの書き方で、数量の空け方の票にはしない。
+ * 日付・時刻は前の境目（「は 9月」「午後3時」「令和 3 年」）も数えない。日付はまとめて一つの書き方で、数量の空け方の票にはしない。コロンで書いた時刻（13:30）も同じ。
+ * メールアドレス・URL の前後の境目も数えない（spacing-code.ts）。
  * 「本社 5階」のように名前の後ろに空白で区切った階・部屋の番号の前の空白も、所在の組の区切りなので数えない（location-part.ts）。
  */
-const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, calendar: ReadonlySet<number>): boolean => {
+const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, codes: SentenceCodes): boolean => {
   if (followsItemNumber(sentence.text, boundary, context.itemNumbers)) return false;
   if (boundary.kind !== "after-digit" && endsWithDivisionLabel(sentence.text.slice(0, boundary.offset), context.divisions)) return false;
-  if (boundary.kind === "letter") return true;
+  if (boundary.kind === "letter") return !besideAddress(codes.addresses, boundary);
+  if (isInsideSpan(codes.clockTimes, digitBeside(boundary))) return false;
   const run = digitRunAround(sentence.text, digitBeside(boundary));
   if (run === undefined) return true;
-  if (calendar.has(run.start)) return false;
+  if (codes.calendar.has(run.start)) return false;
   if (boundary.kind === "before-digit" && isSpacedLocationPart(sentence.text, run, sentence.tokens, sentence.span.start, context.floors)) return false;
   return !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start, context);
 };
@@ -153,10 +163,10 @@ export const latinSpacing: Detector = (doc, options): Finding[] => {
   };
   const located: Located[] = doc.sentences.flatMap((sentence) => {
     const quoted = quotedSpans(sentence.text);
-    const calendar = calendarStarts(sentence, context.calendar);
+    const codes = { calendar: calendarStarts(sentence, context.calendar), clockTimes: clockTimeSpans(sentence.text), addresses: addressSpans(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, calendar))
+      .filter((boundary) => isCounted(sentence, boundary, context, codes))
       .map((boundary) => ({ sentence, ...boundary }));
   });
   return KINDS.flatMap((kind) =>

package/src/detectors/quantity-range.ts

@@ -0,0 +1,47 @@
+// quantity-range-reversed: a range of measured quantities whose upper end is below its lower end (5–2 kg, 30〜10 cm,
+// 40〜-10℃), decided by structure/amount-range.ts as amount-range-reversed is. The quantities are read with the unit
+// lexicons (unit-length, unit-mass, …); the joints are range-connector, range-opener, range-closer and quantity-range-word;
+// quantity-change-word (its lead group: a word right before the range) and quantity-bound-label say what makes a pair a
+// change and what labels a bound.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { measuredValues } from "../facts/measures.ts";
+import { measureUnitsOf } from "../facts/measure-units.ts";
+import { reversedAmountRanges, type AmountRangeWords } from "../structure/amount-range.ts";
+import { quantityRangeEnds, unledRanges } from "../structure/quantity-range.ts";
+import { AMOUNT } from "./currency-notation.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAround } from "./quote-around.ts";
+
+/** A bare end may carry a minus sign (-10〜-40℃); a hyphen right after a digit or a letter is a range mark (5-10 kg). */
+const SIGNED_NUMBER = `(?:[-−－](?=[0-9０-９]))?${AMOUNT}`;
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
+
+const ungroupedOf = (doc: ProseDocument, lexicon: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => entry.group === undefined).map((entry) => entry.pattern);
+
+const wordsOf = (doc: ProseDocument): AmountRangeWords => ({
+  connectors: [...patternsOf(doc, "range-connector"), ...patternsOf(doc, "quantity-range-word")],
+  openers: patternsOf(doc, "range-opener"),
+  closers: patternsOf(doc, "range-closer"),
+  changes: ungroupedOf(doc, "quantity-change-word"),
+  lowers: patternsOf(doc, "quantity-bound-label", "lower"),
+  uppers: patternsOf(doc, "quantity-bound-label", "upper"),
+  links: patternsOf(doc, "quantity-bound-label", "link"),
+  scales: [],
+  number: SIGNED_NUMBER,
+});
+
+export const quantityRange: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  const reversed = reversedAmountRanges(text, quantityRangeEnds(text, measuredValues(text, measureUnitsOf(doc))), wordsOf(doc));
+  return unledRanges(text, reversed, patternsOf(doc, "quantity-change-word", "lead")).map((issue) => ({
+    rule: "quantity-range-reversed",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/range-band.ts

@@ -0,0 +1,125 @@
+// range-band-mismatch: neighbouring bands of one table column or one list that overlap or leave a gap (structure/range-bands.ts).
+// The words that bound a band are range-band-word's, the units range-band-unit's, and the column headings that say what bare
+// numbers count range-band-heading's.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { linesOf } from "../structure/lines.ts";
+import {
+  bandSlips,
+  headingOf,
+  parseBand,
+  runKindOf,
+  type BandMarker,
+  type BandSlip,
+  type BandWords,
+  type PlacedBand,
+  type UnitKind,
+} from "../structure/range-bands.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const MARKER_GROUPS: Readonly<Record<string, Pick<BandMarker, "side" | "kind">>> = {
+  "lower-inclusive": { side: "low", kind: "inclusive" },
+  "lower-exclusive": { side: "low", kind: "exclusive" },
+  "upper-inclusive": { side: "high", kind: "inclusive" },
+  "upper-exclusive": { side: "high", kind: "exclusive" },
+};
+
+const isUnitKind = (group: string | undefined): group is UnitKind => group === "integer" || group === "continuous";
+
+export const bandWordsOf = (lexicons: ProseDocument["lexicons"]): BandWords => {
+  const words = lexicons["range-band-word"] ?? [];
+  const patterns = (group: string): string[] => words.filter((entry) => entry.group === group).map((entry) => entry.pattern);
+  return {
+    connectors: patterns("connector"),
+    openers: words.filter((entry) => entry.group === "connector" && entry.position === "before").map((entry) => entry.pattern),
+    leads: patterns("lead"),
+    markers: words.flatMap((entry) => {
+      const marker = MARKER_GROUPS[entry.group ?? ""];
+      return marker === undefined ? [] : [{ pattern: entry.pattern, ...marker, position: entry.position ?? "after" }];
+    }),
+    units: (lexicons["range-band-unit"] ?? []).flatMap((entry) =>
+      isUnitKind(entry.group) ? [{ pattern: entry.pattern, kind: entry.group, position: entry.position ?? "after" }] : [],
+    ),
+    headings: (lexicons["range-band-heading"] ?? []).flatMap((entry) => (isUnitKind(entry.group) ? [{ pattern: entry.pattern, kind: entry.group }] : [])),
+  };
+};
+
+type Slot = { readonly text: string; readonly start: number; readonly end: number };
+
+/** Runs of consecutive slots that each state a band. A slot that is not one (合計, a blank) ends the run. */
+const bandRuns = (slots: readonly (Slot | undefined)[], words: BandWords): PlacedBand[][] =>
+  slots
+    .reduce<PlacedBand[][]>(
+      (runs, slot) => {
+        const band = slot === undefined ? undefined : parseBand(slot.text, words);
+        if (slot === undefined || band === undefined) return [...runs, []];
+        const last = runs.at(-1) ?? [];
+        return [...runs.slice(0, -1), [...last, { band, start: slot.start, end: slot.end, text: slot.text.trim() }]];
+      },
+      [[]],
+    )
+    .filter((run) => run.length > 1);
+
+const slipsOfRuns = (runs: readonly PlacedBand[][], heading: ReturnType<typeof headingOf>, words: BandWords): BandSlip[] =>
+  runs.flatMap((run) => {
+    const kind = runKindOf(
+      run.map((placed) => placed.band),
+      heading,
+      words,
+    );
+    return kind === undefined ? [] : bandSlips(run, kind);
+  });
+
+const trimmedSlot = (text: string, start: number): Slot => {
+  const lead = text.length - text.trimStart().length;
+  return { text: text.trim(), start: start + lead, end: start + lead + text.trim().length };
+};
+
+const tableSlips = (source: string, words: BandWords): BandSlip[] =>
+  tablesOf(linesOf(source)).flatMap((table) => {
+    const headings = cellsOf(table.header);
+    const rows = table.rows.map(cellsOf);
+    return headings.flatMap((heading, column) =>
+      slipsOfRuns(
+        bandRuns(
+          rows.map((cells) => {
+            const cell = cells[column];
+            return cell === undefined ? undefined : trimmedSlot(cell.text, cell.start);
+          }),
+          words,
+        ),
+        headingOf(heading.text, words),
+        words,
+      ),
+    );
+  });
+
+const LIST_MARKER = /^\s*(?:[-*+]|\d+[.)])\s+/u;
+/** Where the band at the head of a list item ends: a colon, a comma, a bracket, or a dash set off by spaces. */
+const ITEM_HEAD_END = /[:：、,，(（]|\s[-–—]\s|\t/u;
+
+const listSlips = (doc: ProseDocument, words: BandWords): BandSlip[] =>
+  doc.lists.flatMap((list) => {
+    const heads = list.itemSpans.map((span): Slot | undefined => {
+      const item = doc.source.slice(span.start, span.end).split("\n")[0] ?? "";
+      const marker = LIST_MARKER.exec(item)?.[0];
+      if (marker === undefined) return undefined;
+      const body = item.slice(marker.length);
+      const end = ITEM_HEAD_END.exec(body)?.index ?? body.length;
+      return trimmedSlot(body.slice(0, end), span.start + marker.length);
+    });
+    return slipsOfRuns(bandRuns(heads, words), undefined, words);
+  });
+
+export const rangeBand: Detector = (doc): Finding[] => {
+  const words = bandWordsOf(doc.lexicons);
+  return [...tableSlips(doc.source, words), ...listSlips(doc, words)].map((slip) => ({
+    rule: "range-band-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.later.start),
+    ...(slip.kind === "gap" ? { variant: "gap" } : {}),
+    values: { earlier: slip.earlier.text, later: slip.later.text, offset: slip.later.start },
+  }));
+};

package/src/detectors/registry/capacity-runtime-mismatch.ts

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

package/src/detectors/registry/contact-variant.ts

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

package/src/detectors/registry/count-over-capacity.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { countOverCapacity } from "../count-over-capacity.ts";
+
+export const detector: Detector = countOverCapacity;

package/src/detectors/registry/date-stamp-order.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { dateStampOrder } from "../date-stamp-order.ts";
+
+export const detector: Detector = dateStampOrder;

package/src/detectors/registry/event-deadline.ts

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

package/src/detectors/registry/interval-count-mismatch.ts

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

package/src/detectors/registry/layout-code-mismatch.ts

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

package/src/detectors/registry/quantity-range.ts

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

package/src/detectors/registry/range-band-mismatch.ts

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

package/src/detectors/registry/rent-multiple-mismatch.ts

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

package/src/detectors/registry/scaled-quantity-mismatch.ts

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

package/src/detectors/registry/step-time-sum-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { stepTimeSumMismatch } from "../step-time-sum.ts";
+
+export const detector: Detector = stepTimeSumMismatch;

package/src/detectors/registry/time-range-reversed.ts

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

package/src/detectors/registry/unlisted-item-used.ts

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

package/src/detectors/registry/walk-time-distance-mismatch.ts

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

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

@@ -0,0 +1,56 @@
+// rent-multiple-mismatch: a deposit or key money given in months of rent beside an amount that is not that many months of
+// the rent (structure/rent-multiple.ts). The amounts are currency-notation's, read with amount-multiplier's words of scale;
+// the labels are rent-label and rent-multiple-label, the words rent-multiple-word, the counts number-word (digit), and a
+// range of rent is joined by range-connector or amount-range-word.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { rentMultipleMismatches, type RentAmount, type RentMultipleWords } from "../structure/rent-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): RentMultipleWords["numberWords"] =>
+  (doc.lexicons["number-word"] ?? []).flatMap((entry) =>
+    entry.group === "digit" && entry.weight !== undefined ? [{ word: entry.pattern, value: entry.weight }] : [],
+  );
+
+const wordsOf = (doc: ProseDocument): RentMultipleWords => ({
+  rents: patternsOf(doc, "rent-label", "rent"),
+  fees: patternsOf(doc, "rent-label", "fee"),
+  multiples: patternsOf(doc, "rent-multiple-label"),
+  months: patternsOf(doc, "rent-multiple-word", "month"),
+  links: patternsOf(doc, "rent-multiple-word", "link"),
+  periods: patternsOf(doc, "rent-multiple-word", "period"),
+  skips: patternsOf(doc, "rent-multiple-word", "skip"),
+  connectors: [...patternsOf(doc, "range-connector"), ...patternsOf(doc, "amount-range-word")],
+  numberWords: numberWordsOf(doc),
+});
+
+const amountsOf = (text: string, doc: ProseDocument): RentAmount[] => {
+  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 rentMultipleMismatch: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  return rentMultipleMismatches(text, amountsOf(text, doc), wordsOf(doc)).map((issue) => ({
+    rule: "rent-multiple-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/scaled-quantity.ts

@@ -0,0 +1,49 @@
+// One row of a servings table (4人分 / 8人分, Serves 4 / Serves 8) that does not scale by the columns' ratio while the other rows
+// do. The column marks, the amounts left to the cook and the spellings of one unit come from the language packages.
+import { scaleSlips, type ScaleWords } from "../structure/scaled-quantities.ts";
+import type { MeasureUnit } from "../facts/measures.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+const DIMENSIONS = ["unit-mass", "unit-volume"] as const;
+
+const measuresOf = (doc: ProseDocument): MeasureUnit[] =>
+  DIMENSIONS.flatMap((dimension) =>
+    (doc.lexicons[dimension] ?? []).flatMap((entry) =>
+      entry.weight === undefined
+        ? []
+        : [{ pattern: entry.pattern, dimension, factors: [entry.weight], zero: 0, before: entry.position === "before", context: [] }],
+    ),
+  );
+
+const wordsOf = (doc: ProseDocument): ScaleWords => ({
+  columns: (doc.lexicons["servings-column"] ?? []).map((entry) => ({ pattern: entry.pattern, position: entry.position })),
+  unscaled: (doc.lexicons["unscaled-amount"] ?? []).map((entry) => entry.pattern),
+  unitForms: (doc.lexicons["scaled-unit-form"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern })),
+  measures: measuresOf(doc),
+});
+
+const DECIMALS = 1000;
+const shown = (amount: number): string => String(Math.round(amount * DECIMALS) / DECIMALS);
+
+export const scaledQuantityMismatch: Detector = (doc): Finding[] =>
+  scaleSlips(doc.source, wordsOf(doc)).map((slip) => {
+    const offset = slip.cell.start + (slip.cell.text.length - slip.cell.text.trimStart().length);
+    return {
+      rule: "scaled-quantity-mismatch",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, offset),
+      values: {
+        item: slip.item.text.trim(),
+        written: slip.cell.text.trim(),
+        column: slip.heading,
+        other: slip.other.text.trim(),
+        otherColumn: slip.otherHeading,
+        expected: shown(slip.expected),
+        scaledRows: slip.scaledRows,
+        offset,
+      },
+    };
+  });