chaffjs 0.31.0 → 0.33.0

package/src/detectors/row-sentence-amounts.ts

@@ -0,0 +1,96 @@
+import type { Finding, ProseDocument, StructureNode } from "../plugin.ts";
+import { nameSpans } from "../compare/proper-nouns.ts";
+import { factValues, type FactValue } from "../facts/fact-values.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { scopedFacts, type ScopedFact } from "../facts/fact-scope.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import {
+  periodOf,
+  rowSentenceConflicts,
+  type Amount,
+  type AmountRow,
+  type PeriodMark,
+  type SubjectSentence,
+  type SubjectWords,
+} from "../facts/row-sentence-amounts.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const LETTER = /\p{L}/u;
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const within = <T extends FactValue>(span: { start: number; end: number }, values: readonly T[]): T[] =>
+  values.filter((value) => span.start <= value.start && value.end <= span.end);
+
+/** 範囲は事実と同じ読み（fact-scope）。値の位置で決まる。位置ごとの範囲。 */
+const scopesAt = (doc: ProseDocument, tree: StructureNode, values: readonly FactValue[]): ReadonlyMap<number, string> =>
+  new Map(
+    scopedFacts(
+      values.map((value) => ({ label: "", key: "", value })),
+      tree,
+      doc.source,
+      patternsOf(doc, "summary-heading"),
+    ).map((fact) => [fact.value.start, fact.scope]),
+  );
+
+const amountRow = (row: Line, amounts: readonly Amount[], scopes: ReadonlyMap<number, string>): AmountRow[] => {
+  const [first, ...rest] = cellsOf(row);
+  if (first === undefined) return [];
+  const label = withoutEdgeMarks(first.text);
+  const inRow = rest.flatMap((cell) => within(cell, amounts));
+  const [head] = inRow;
+  if (head === undefined || !LETTER.test(label) || within(first, amounts).length > 0) return [];
+  return [{ label, scope: scopes.get(head.start) ?? "", amounts: inRow }];
+};
+
+const subjectSentences = (doc: ProseDocument, amounts: readonly Amount[], scopes: ReadonlyMap<number, string>): SubjectSentence[] =>
+  doc.sentences.flatMap((sentence) => {
+    const inSentence = within(sentence.span, amounts);
+    const [head] = inSentence;
+    return head === undefined ? [] : [{ text: sentence.text, scope: scopes.get(head.start) ?? "", amounts: inSentence }];
+  });
+
+const subjectWordsOf = (doc: ProseDocument): SubjectWords => ({
+  separators: patternsOf(doc, "fact-separator"),
+  determiners: patternsOf(doc, "fact-label-drop"),
+  conditions: patternsOf(doc, "fact-amount-condition"),
+});
+
+const periodMarksOf = (doc: ProseDocument): PeriodMark[] =>
+  (doc.lexicons["per-unit-mark"] ?? []).map((entry): PeriodMark => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
+
+/** 金額: 通貨の語彙表の印を単位に書いた数量。前後に期間あたりの印があれば、その期間も。 */
+const amountsOf = (doc: ProseDocument, tree: StructureNode): Amount[] => {
+  const currencies = new Set(patternsOf(doc, "currency-notation").map((pattern) => pattern.normalize("NFKC")));
+  const marks = periodMarksOf(doc);
+  return factValues(tree, doc.source, nameSpans(doc))
+    .filter((value) => value.kind === "quantity" && currencies.has(value.unit))
+    .map((value): Amount => {
+      const period = periodOf(doc.source, value, marks);
+      return period === undefined ? value : { ...value, period };
+    });
+};
+
+/** 表の行の金額と、その行の見出しを主語にした文の金額の食い違い。名前付きの値として読めた文の値は、ほかの読みが比べる。 */
+export const rowSentenceFindings = (doc: ProseDocument, facts: readonly ScopedFact[]): Finding[] => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const amounts = amountsOf(doc, tree);
+  const tableRows = tablesOf(linesOf(doc.source)).flatMap((table) => table.rows);
+  if (tableRows.length === 0 || amounts.length === 0) return [];
+  const scopes = scopesAt(doc, tree, amounts);
+  const rows = tableRows.flatMap((row) => amountRow(row, amounts, scopes));
+  const read = new Set(facts.map((fact) => fact.value.start));
+  return rowSentenceConflicts(rows, subjectSentences(doc, amounts, scopes), subjectWordsOf(doc))
+    .filter((conflict) => !read.has(conflict.value.start))
+    .map(({ label, value, other }) => ({
+      rule: "fact-conflict",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, value.start),
+      variant: "term",
+      values: { label, value: doc.source.slice(value.start, value.end), other: doc.source.slice(other.start, other.end), offset: value.start },
+    }));
+};

package/src/detectors/running-balance.ts

@@ -0,0 +1,31 @@
+// running-balance-mismatch: the reading half. Reads the document's Markdown tables and the lexicons balance-column and
+// total-label, and leaves the deciding to structure/running-balance.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 { runningBalanceMismatches, type BalanceRole, type BalanceWord } from "../structure/running-balance.ts";
+
+const RULE = "running-balance-mismatch";
+const ROLES: readonly string[] = ["date", "sequence", "balance", "interest", "principal", "in", "out", "payment"] satisfies readonly BalanceRole[];
+const isRole = (group: string | undefined): group is BalanceRole => group !== undefined && ROLES.includes(group);
+
+/** Lexicon balance-column: the heading words that say which column holds the balance and which the movement of a row. */
+const columnWordsOf = (doc: ProseDocument): BalanceWord[] =>
+  (doc.lexicons["balance-column"] ?? []).flatMap((entry) => (isRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : []));
+
+export const runningBalance: Detector = (doc): Finding[] => {
+  const columns = columnWordsOf(doc);
+  if (columns.length === 0) return [];
+  const tables = tablesOf(linesOf(proseAndTablesOf(doc))).map((table) => ({ header: cellsOf(table.header), rows: table.rows.map(cellsOf) }));
+  const totalLabels = (doc.lexicons["total-label"] ?? []).map((entry) => entry.pattern);
+  return runningBalanceMismatches(tables, { columns, totalLabels }).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/scaled-quantity.ts

@@ -5,7 +5,7 @@ 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 DIMENSIONS = ["unit-mass", "unit-volume", "unit-area"] as const;
 
 const measuresOf = (doc: ProseDocument): MeasureUnit[] =>
   DIMENSIONS.flatMap((dimension) =>

package/src/detectors/serial-range.ts

@@ -0,0 +1,37 @@
+// serial-range-reversed: a range of serial, lot or batch codes whose end is below its start (製造番号：A2400〜A1800,
+// "Lots L5240 through L5210"), decided by structure/amount-range.ts as quantity-range-reversed is. The codes are read by
+// structure/serial-range.ts; serial-label names the codes on the line; the joints are range-connector, range-opener,
+// range-closer and quantity-range-word; quantity-change-word's ungrouped words make a pair a change.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { reversedAmountRanges, type AmountRangeWords } from "../structure/amount-range.ts";
+import { labelledRanges, NO_BARE_NUMBER, serialRangeEnds } from "../structure/serial-range.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAround } from "./quote-around.ts";
+
+const patternsOf = (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: patternsOf(doc, "quantity-change-word"),
+  lowers: [],
+  uppers: [],
+  links: [],
+  scales: [],
+  number: NO_BARE_NUMBER,
+});
+
+export const serialRange: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  const reversed = reversedAmountRanges(text, serialRangeEnds(text), wordsOf(doc));
+  return labelledRanges(text, reversed, patternsOf(doc, "serial-label")).map((issue) => ({
+    rule: "serial-range-reversed",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/share-amount.ts

@@ -0,0 +1,51 @@
+// share-amount-mismatch: the reading half. Reads the document's Markdown tables, its lines outside tables and where its
+// headings start, the lexicon share-amount-label, and leaves the deciding to structure/share-amount.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, type Line } from "../structure/lines.ts";
+import { TABLE_ROW } from "../structure/runs.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { shareAmountMismatches, type ShareRole, type ShareText, type ShareWords } from "../structure/share-amount.ts";
+
+const RULE = "share-amount-mismatch";
+const ROLES: readonly string[] = ["base", "share", "paid"] satisfies readonly ShareRole[];
+const isRole = (group: string | undefined): group is ShareRole => group !== undefined && ROLES.includes(group);
+const HEADING = /^#{1,6}[ \t]/u;
+
+/** Lexicon share-amount-label: the words of the total, the share and the payment, and (group rounding) the step an amount in a unit may be rounded to. */
+const shareWordsOf = (doc: ProseDocument): ShareWords => {
+  const entries = doc.lexicons["share-amount-label"] ?? [];
+  return {
+    labels: entries.flatMap((entry) => (isRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : [])),
+    roundings: entries.flatMap((entry) => (entry.group === "rounding" && entry.weight !== undefined ? [{ unit: entry.pattern, step: entry.weight }] : [])),
+  };
+};
+
+/** A heading of the source that the prose blanks (not one inside code). */
+const isHeading = (line: Line, prose: string): boolean => HEADING.test(line.text) && prose.slice(line.start, line.start + line.text.length).trim() === "";
+
+const shareTextOf = (doc: ProseDocument): ShareText => {
+  const prose = proseAndTablesOf(doc);
+  const lines = linesOf(prose);
+  return {
+    tables: tablesOf(lines).map((table) => ({ header: cellsOf(table.header), rows: table.rows.map(cellsOf) })),
+    lines: lines.filter((line) => !TABLE_ROW.test(line.text) && line.text.trim() !== ""),
+    headings: linesOf(doc.source)
+      .filter((line) => isHeading(line, prose))
+      .map((line) => line.start),
+  };
+};
+
+export const shareAmount: Detector = (doc): Finding[] => {
+  const words = shareWordsOf(doc);
+  if (words.labels.length === 0) return [];
+  return shareAmountMismatches(shareTextOf(doc), words).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/structure-tree.ts

@@ -6,17 +6,22 @@ import { weekdayMismatches } from "../structure/weekday.ts";
 import { documentDateOf } from "./document-date.ts";
 import { dateOrderBreaks } from "../structure/date-order.ts";
 import { totalMismatches, type Amount } from "../structure/total.ts";
-import { isTotalLine } from "../structure/total-line.ts";
+import { isListedTotal, isPeriodTotalLine, isTotalLikeLine, isTotalLine } from "../structure/total-line.ts";
 import { proseTotalMismatches } from "../structure/prose-total.ts";
 import { countedAmounts, type SummedCounter } from "../structure/counted-amounts.ts";
 import { measuredAmounts, type MeasureMarks, type SummedMeasure } from "../structure/measured-amounts.ts";
+import { withCompoundHours } from "../structure/compound-hours.ts";
+import { timeLengths } from "../derived/time-lengths.ts";
 import { measureUnitsOf } from "../facts/measure-units.ts";
 import { rangeFrameOf, reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
+import { isStartEndRange, startEndWordsOf } from "../structure/start-end-range.ts";
 import { afterLabel } from "../structure/stated-period.ts";
+import { afterSpanLabel } from "../structure/span-label.ts";
 import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
 import { proseShareMismatches } from "../structure/percent-sum-prose.ts";
 import { isQuotedAlone } from "../quoted-span.ts";
 import { ordinalRunGaps } from "./ordinal-run-gaps.ts";
+import { readableDates, withReadableDates } from "./readable-dates.ts";
 
 const QUOTE_LENGTH = 80;
 
@@ -91,8 +96,14 @@ const dayName = (doc: ProseDocument, day: unknown): string => {
   return doc.lexicons["weekday"]?.[index]?.pattern ?? String(index);
 };
 
+const weekdayAttr = (weekday: unknown): number | undefined => (typeof weekday === "number" ? weekday : undefined);
+
 const datedSpans = (tree: NonNullable<ProseDocument["structure"]>): DatedSpan[] =>
-  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
+  inDocumentOrder(tree).flatMap((node) =>
+    node.kind === "date"
+      ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]), weekday: weekdayAttr(node.attrs["weekday"]) }]
+      : [],
+  );
 
 /** 引用符の中で日付の横にあってよい語は、曜日の一語だけ（"Monday, December 5, 2026"、「2026年12月5日（月）」）。 */
 const WEEKDAY_WORDS = 1;
@@ -144,7 +155,7 @@ export const dateWeekdayMismatch: Detector = (doc): Finding[] => {
       column: 0,
       quote: quoteAt(doc.source, issue.offset),
       values: {
-        date: String(issue.values["date"]),
+        date: readableDates(doc)(String(issue.values["date"])),
         written: dayName(doc, issue.values["written"]),
         actual: dayName(doc, issue.values["actual"]),
         offset: issue.offset,
@@ -166,7 +177,7 @@ export const dateOrder: Detector = (doc): Finding[] =>
         line: 0,
         column: 0,
         quote: quoteAt(doc.source, issue.offset),
-        values: { ...issue.values, offset: issue.offset },
+        values: { ...withReadableDates(issue.values, ["date", "previous", "next"], readableDates(doc)), offset: issue.offset },
         ...("next" in issue.values ? { variant: "first" } : {}),
       }));
 
@@ -204,15 +215,51 @@ const measureMarksOf = (doc: ProseDocument): MeasureMarks => ({
   perMarks: patternsOf(doc, "measure-per-mark"),
 });
 
-/** 表と箇条書きの合計で足す数量。金額と助数詞の数に、単位の付いた量（300 mg、0.5 g）を加える。 */
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_MINUTE = 60;
+
+const timeUnitsOf = (doc: ProseDocument, seconds: number): string[] =>
+  (doc.lexicons["unit-time"] ?? []).filter((entry) => entry.weight === seconds).map((entry) => entry.pattern);
+
+/** 時間と分を続けて書いた長さ（9時間30分）を一つの量にする。単位は unit-time、半（7時間半）は length-half から取る。 */
+const compoundHoursOf = (doc: ProseDocument, amounts: readonly Amount[]): Amount[] => {
+  const hourUnits = timeUnitsOf(doc, SECONDS_PER_HOUR);
+  const lengths = timeLengths(doc.source, {
+    hourUnits,
+    minuteUnits: timeUnitsOf(doc, SECONDS_PER_MINUTE),
+    halves: patternsOf(doc, "length-half"),
+    numberWords: [],
+  });
+  return withCompoundHours(amounts, lengths, hourUnits);
+};
+
+/** 表と箇条書きの合計で足す数量。金額と助数詞の数に、単位の付いた量（300 mg、0.5 g）を加え、時間と分の長さを一つにする。 */
 const lineAmountsOf = (doc: ProseDocument, amounts: readonly Amount[]): Amount[] =>
-  [...amounts, ...measuredAmounts(doc.source, summedMeasuresOf(doc), measureMarksOf(doc), amounts)].toSorted((left, right) => left.offset - right.offset);
+  compoundHoursOf(
+    doc,
+    [...amounts, ...measuredAmounts(doc.source, summedMeasuresOf(doc), measureMarksOf(doc), amounts)].toSorted((left, right) => left.offset - right.offset),
+  );
 
 /** 合計の行と内訳の行、文の中の合計と内訳。同じ金額は一度だけ言う。単位の付いた量は、表と箇条書きの合計だけで足す。 */
 const totalIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["structure"]>): StructureIssue[] => {
   const amounts = summableAmountsOf(doc, tree);
-  const words = { labels: patternsOf(doc, "total-label"), qualifiers: doc.lexicons["total-label-qualifier"] ?? [] };
-  const lines = totalMismatches(doc.source, lineAmountsOf(doc, amounts), (text) => isTotalLine(text, words));
+  const words = {
+    labels: patternsOf(doc, "total-label"),
+    qualifiers: doc.lexicons["total-label-qualifier"] ?? [],
+    nounQualifiers: doc.lexicons["total-noun-qualifier"] ?? [],
+    unsummedNouns: patternsOf(doc, "total-noun-unsummed"),
+    periodQualifiers: doc.lexicons["total-period-qualifier"] ?? [],
+    periodLabels: (doc.lexicons["total-label"] ?? []).filter((entry) => entry.group === "period").map((entry) => entry.pattern),
+    listedNouns: patternsOf(doc, "total-noun-listed"),
+    amountNames: patternsOf(doc, "net-amount-label"),
+  };
+  const lines = totalMismatches(
+    doc.source,
+    lineAmountsOf(doc, amounts),
+    (text, header) => isTotalLine(text, words, header),
+    (text) => isPeriodTotalLine(text, words),
+    { isListed: (text) => isListedTotal(text, words), isTotalLike: (text, header) => isTotalLikeLine(text, words, header) },
+  );
   const phrases = {
     totals: patternsOf(doc, "total-phrase"),
     breakdowns: patternsOf(doc, "breakdown-phrase"),
@@ -253,21 +300,23 @@ export const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
   weekdays: (doc.lexicons["weekday"] ?? []).map((entry) => entry.pattern),
 });
 
-/** その位置が、期間の語（period-label）で始まる行の、語より後ろにあるか。 */
+/** その位置が、期間の語（period-label）で始まる行か、期間を名指す語（range-label）で終わる見出しの行の、語より後ろにあるか。 */
 const labelledAt =
   (doc: ProseDocument) =>
   (offset: number): boolean => {
     const lineStart = doc.source.lastIndexOf("\n", offset - 1) + 1;
     const lineEnd = doc.source.indexOf("\n", offset);
-    const after = afterLabel(doc.source.slice(lineStart, lineEnd === -1 ? doc.source.length : lineEnd), patternsOf(doc, "period-label"));
+    const line = doc.source.slice(lineStart, lineEnd === -1 ? doc.source.length : lineEnd);
+    const after = afterLabel(line, patternsOf(doc, "period-label")) ?? afterSpanLabel(line, patternsOf(doc, "range-label"));
     return after !== undefined && offset >= lineStart + after;
   };
 
-/** 期間の終わりが始まりより前。範囲の記号と語は言語パッケージの語彙表（range-connector、range-opener、range-closer）から取る。 */
+/** 期間の終わりが始まりより前。範囲の記号と語は言語パッケージの語彙表（range-connector、range-opener、range-closer、range-start-end）から取る。 */
 export const dateRangeReversed: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
   const dates = datedSpans(doc.structure);
-  return reversedRanges(doc.source, dates, rangeWordsOf(doc), labelledAt(doc))
+  const startEnd = startEndWordsOf(doc.lexicons["range-start-end"] ?? [], patternsOf(doc, "weekday"));
+  return reversedRanges(doc.source, dates, rangeWordsOf(doc), labelledAt(doc), (start, end) => isStartEndRange(doc.source, start, end, startEnd))
     .filter((issue) => {
       const start = dateAt(dates, issue.offset);
       return !quotedDates(doc, dates[start], dates[start + 1]);
@@ -286,6 +335,7 @@ const shareWordsOf = (doc: ProseDocument): ShareWords => ({
   labels: (doc.lexicons["share-label"] ?? []).map((entry) => entry.pattern),
   columnLabels: (doc.lexicons["share-column"] ?? []).map((entry) => entry.pattern),
   rates: (doc.lexicons["share-column-rate"] ?? []).map((entry) => entry.pattern),
+  headerRates: (doc.lexicons["share-column-rate-header"] ?? []).map((entry) => entry.pattern),
   exceptions: (doc.lexicons["share-exception"] ?? []).map((entry) => entry.pattern),
   rests: (doc.lexicons["share-rest"] ?? []).map((entry) => entry.pattern),
   changes: (doc.lexicons["change-direction"] ?? []).map((entry) => entry.pattern),

package/src/detectors/table-scale.ts

@@ -0,0 +1,37 @@
+// table-unit-mix: the reading half. The scale units, the caption marks and the total labels are the lexicons table-scale-unit,
+// table-unit-caption and total-label.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { tableScaleSlips, type TableScaleWords } from "../structure/table-scale.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const wordsOf = (doc: ProseDocument): TableScaleWords => ({
+  units: (doc.lexicons["table-scale-unit"] ?? []).flatMap((entry) => (entry.weight === undefined ? [] : [{ word: entry.pattern, value: entry.weight }])),
+  captionMarks: (doc.lexicons["table-unit-caption"] ?? []).map((entry) => entry.pattern),
+  totalLabels: (doc.lexicons["total-label"] ?? []).map((entry) => entry.pattern),
+});
+
+const MAX_DECIMALS = 3;
+const shown = (value: number): string => value.toLocaleString("en-US", { maximumFractionDigits: MAX_DECIMALS });
+
+export const tableUnitMix: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  return tableScaleSlips(text, wordsOf(doc)).map((slip) => {
+    const offset = slip.cell.start + (slip.cell.text.length - slip.cell.text.trimStart().length);
+    return {
+      rule: "table-unit-mix",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(text, offset),
+      variant: slip.kind,
+      values: {
+        item: slip.item,
+        written: slip.cell.text.trim(),
+        unit: slip.tableUnit,
+        reading: slip.reading === undefined ? "" : shown(slip.reading),
+        offset,
+      },
+    };
+  });
+};

package/src/detectors/tax-amount.ts

@@ -1,8 +1,20 @@
-// tax-mismatch: the reading half. The words of a tax row, a total row and an included tax come from the language's
-// lexicons (tax-label, total-label, tax-included-word); the amounts are the structure tree's.
+// tax-mismatch: the reading half. The words of a tax row, a total row, an included tax and a service charge come from the
+// language's lexicons (tax-label, total-label, tax-included-word, service-charge-label); the amounts are the structure tree's.
+// The tax-excluded and tax-included price columns of a price list come from the lexicon tax-price-column and the document's
+// Markdown tables.
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { taxMismatches, type TaxWords } from "../structure/tax.ts";
+import { taxIncludedPriceMismatches, type TaxPriceRole, type TaxPriceText, type TaxPriceWord } from "../structure/tax-price.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { linesOf } from "../structure/lines.ts";
+import { TABLE_ROW } from "../structure/runs.ts";
+import { proseAndTablesOf } from "../table-text.ts";
 import { amountsOf, quoteAt } from "./structure-tree.ts";
+import type { StructureIssue } from "../structure/issues.ts";
+
+const RULE = "tax-mismatch";
+const PRICE_ROLES: readonly string[] = ["excluded", "included", "rate"] satisfies readonly TaxPriceRole[];
+const isPriceRole = (group: string | undefined): group is TaxPriceRole => group !== undefined && PRICE_ROLES.includes(group);
 
 const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
 
@@ -10,16 +22,36 @@ const wordsOf = (doc: ProseDocument): TaxWords => ({
   labels: patternsOf(doc, "tax-label"),
   totals: patternsOf(doc, "total-label"),
   included: patternsOf(doc, "tax-included-word"),
+  charges: patternsOf(doc, "service-charge-label"),
+});
+
+const priceWordsOf = (doc: ProseDocument): TaxPriceWord[] =>
+  (doc.lexicons["tax-price-column"] ?? []).flatMap((entry) => (isPriceRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : []));
+
+const priceTextOf = (doc: ProseDocument): TaxPriceText => {
+  const lines = linesOf(proseAndTablesOf(doc));
+  return {
+    tables: tablesOf(lines).map((table) => ({ header: cellsOf(table.header), rows: table.rows.map(cellsOf) })),
+    lines: lines.filter((line) => !TABLE_ROW.test(line.text) && line.text.trim() !== "").map((line) => line.text),
+  };
+};
+
+const findingOf = (doc: ProseDocument, issue: StructureIssue, variant?: string): Finding => ({
+  rule: RULE,
+  severity: "error",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, issue.offset),
+  values: { ...issue.values, offset: issue.offset },
+  ...(variant === undefined ? {} : { variant }),
 });
 
-export const taxAmount: Detector = (doc): Finding[] =>
-  doc.structure === undefined
-    ? []
-    : taxMismatches(doc.source, amountsOf(doc.structure), wordsOf(doc)).map((issue) => ({
-        rule: "tax-mismatch",
-        severity: "error",
-        line: 0,
-        column: 0,
-        quote: quoteAt(doc.source, issue.offset),
-        values: { ...issue.values, offset: issue.offset },
-      }));
+const priceFindings = (doc: ProseDocument): Finding[] => {
+  const words = priceWordsOf(doc);
+  return words.length === 0 ? [] : taxIncludedPriceMismatches(priceTextOf(doc), words).map((issue) => findingOf(doc, issue, "price"));
+};
+
+export const taxAmount: Detector = (doc): Finding[] => [
+  ...(doc.structure === undefined ? [] : taxMismatches(doc.source, amountsOf(doc.structure), wordsOf(doc)).map((issue) => findingOf(doc, issue))),
+  ...priceFindings(doc),
+];

package/src/detectors/technical-docs.ts

@@ -3,6 +3,7 @@
 // as a statement among instructions. Pure. Shell languages and prompt marks come from the shell-fence-language and
 // shell-prompt lexicons.
 import { codeFences, codeSpans, type CodeFence } from "./code-fences.ts";
+import { opensAsNounPhrase } from "./nominal-step.ts";
 import { quoteAt } from "./structure-tree.ts";
 import { escapeRegExp } from "../orthography.ts";
 import type { Detector, Finding, ProseDocument, Span, Token } from "../plugin.ts";
@@ -227,8 +228,9 @@ export const isStatement = (tokens: readonly Token[]): boolean => {
 
 type Step = { readonly start: number; readonly kind: "statement" | "instruction" | "other" };
 
-/** A step that opens with its verb: an instruction (Run the installer). */
-export const isInstruction = (tokens: readonly Token[]): boolean => INSTRUCTION_OPENER.has(tokens.find((token) => !SKIPPED.has(token.pos))?.pos ?? "");
+/** A step that opens with its verb: an instruction (Run the installer). An item that names a case (Faults caused by a drop) is not one. */
+export const isInstruction = (tokens: readonly Token[]): boolean =>
+  INSTRUCTION_OPENER.has(tokens.find((token) => !SKIPPED.has(token.pos))?.pos ?? "") && !opensAsNounPhrase(tokens);
 
 const kindOf = (tokens: readonly Token[]): Step["kind"] => {
   if (isStatement(tokens)) return "statement";

package/src/detectors/tier-threshold.ts

@@ -0,0 +1,108 @@
+// tier-threshold-mismatch: the reading half. Reads the tiers a table (name in the first column, a band in another) or a list
+// ("Gold: 20 nights or more") defines, the "key: value" lines outside tables with the section they are in, and the lexicons
+// tier-label (the keys that state a member's tier), tier-unit (the units a threshold is counted in) and range-band-word (the
+// words that bound a band). The deciding is structure/tier-threshold.ts's.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import { TABLE_ROW } from "../structure/runs.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { bandWordsOf } from "./range-band.ts";
+import type { BandUnit } from "../structure/range-bands.ts";
+import { bandIn, plainKey, tierSlips, type KeyValueLine, type TierEntry, type TierWords } from "../structure/tier-threshold.ts";
+
+const RULE = "tier-threshold-mismatch";
+const HEADING = /^#{1,6}[ \t]/u;
+const LIST_MARKER = /^\s*(?:[-*+]|\d+[.)])\s+/u;
+const COLON = /[:：]/u;
+/** A key longer than this is a sentence with a colon in it, not a label. */
+const MAX_KEY = 40;
+
+const isUnitKind = (group: string | undefined): group is BandUnit["kind"] => group === "integer" || group === "continuous";
+
+const tierWordsOf = (doc: ProseDocument): TierWords => ({
+  band: {
+    ...bandWordsOf(doc.lexicons),
+    units: (doc.lexicons["tier-unit"] ?? []).flatMap((entry) =>
+      isUnitKind(entry.group) ? [{ pattern: entry.pattern, kind: entry.group, position: entry.position ?? "after" }] : [],
+    ),
+    headings: [],
+  },
+  labels: (doc.lexicons["tier-label"] ?? []).filter((entry) => entry.group === "label").map((entry) => entry.pattern),
+  others: (doc.lexicons["tier-label"] ?? []).filter((entry) => entry.group === "other").map((entry) => entry.pattern),
+});
+
+type Split = { readonly key: string; readonly value: string; readonly valueAt: number };
+
+/** The key and the value of a line or a list item without its marker, and where the value starts in it. */
+const splitKeyValue = (text: string): Split | undefined => {
+  const marker = LIST_MARKER.exec(text)?.[0] ?? "";
+  const body = text.slice(marker.length);
+  const colon = COLON.exec(body)?.index;
+  const key = colon === undefined ? "" : body.slice(0, colon).trim();
+  if (colon === undefined || key === "" || key.length > MAX_KEY) return undefined;
+  const after = body.slice(colon + 1);
+  const value = after.trim();
+  return { key, value, valueAt: marker.length + colon + 1 + (after.length - after.trimStart().length) };
+};
+
+/** A heading of the source that the prose blanks (not one inside code). */
+const isHeading = (line: Line, prose: string): boolean => HEADING.test(line.text) && prose.slice(line.start, line.start + line.text.length).trim() === "";
+
+const keyValueLines = (doc: ProseDocument, prose: string): KeyValueLine[] => {
+  const headings = linesOf(doc.source)
+    .filter((line) => isHeading(line, prose))
+    .map((line) => line.start);
+  return linesOf(prose).flatMap((line) => {
+    const split = TABLE_ROW.test(line.text) ? undefined : splitKeyValue(line.text);
+    if (split === undefined) return [];
+    const section = headings.filter((start) => start <= line.start).length;
+    return [{ key: split.key, value: split.value, valueStart: line.start + split.valueAt, section }];
+  });
+};
+
+/** For each column after the first, the tiers the first column names with that column's cells. */
+const tableRuns = (prose: string): TierEntry[][] =>
+  tablesOf(linesOf(prose)).flatMap((table) => {
+    const rows = table.rows.map(cellsOf);
+    const columns = cellsOf(table.header).length;
+    return Array.from({ length: Math.max(0, columns - 1) }, (_, index) =>
+      rows.flatMap((cells) => {
+        const name = cells[0]?.text.trim();
+        const text = cells[index + 1]?.text.trim();
+        return name === undefined || text === undefined ? [] : [{ name, text }];
+      }),
+    );
+  });
+
+/** Runs of consecutive list items that each state a band after a name ("Gold: 20 nights or more"). Another item ends the run. */
+const listRuns = (doc: ProseDocument, words: TierWords): TierEntry[][] =>
+  doc.lists.flatMap((list) =>
+    list.itemSpans.reduce<TierEntry[][]>(
+      (runs, span) => {
+        const split = splitKeyValue(doc.source.slice(span.start, span.end).split("\n")[0] ?? "");
+        if (split === undefined || bandIn(split.value, words.band) === undefined) return [...runs, []];
+        return [...runs.slice(0, -1), [...(runs.at(-1) ?? []), { name: split.key, text: split.value }]];
+      },
+      [[]],
+    ),
+  );
+
+export const tierThreshold: Detector = (doc): Finding[] => {
+  const words = tierWordsOf(doc);
+  if (words.band.units.length === 0) return [];
+  const prose = proseAndTablesOf(doc);
+  const lines = keyValueLines(doc, prose);
+  const labels = new Set(words.labels.map(plainKey));
+  if (!lines.some((line) => labels.has(plainKey(line.key)))) return [];
+  const tierRuns = [...tableRuns(prose), ...listRuns(doc, words)];
+  return tierSlips({ tierRuns, lines }, words).map((slip) => ({
+    rule: RULE,
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.offset),
+    values: { ...slip.values, offset: slip.offset },
+  }));
+};