chaffjs 0.31.0 → 0.32.0

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,21 @@ 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 { 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 +95,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 +154,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 +176,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 +214,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,13 +299,14 @@ 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;
   };
 
@@ -286,6 +333,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 },
+  }));
+};

package/src/detectors/time-order.ts

@@ -8,9 +8,11 @@ import { arrivalOffsets, arrivalsBeforeDeparture } from "../structure/leg-times.
 import { shortConnections, type TravelLength, type TravelWords } from "../structure/connection-times.ts";
 import { timeLengths } from "../derived/time-lengths.ts";
 import { reversedTimeRanges } from "../structure/time-range.ts";
+import { cellMinutes, reversedShiftRows, showsOvernightWork } from "../structure/shift-times.ts";
+import { pairedTimesOutOfOrder } from "../structure/labelled-time-order.ts";
 import { quoteAt, rangeWordsOf } from "./structure-tree.ts";
 
-// 一日の予定の時刻の順番（time-order）、発より前の着（arrival-before-departure）、移動の時間より短い乗り継ぎ（connection-time-short）。時刻は compare/clock-time.ts が読み、
+// 一日の予定の時刻の順番と、語の決まった二つの時刻の順番（time-order）、発より前の着（arrival-before-departure）、移動の時間より短い乗り継ぎ（connection-time-short）。時刻は compare/clock-time.ts が読み、
 // 発着・翌日・時間帯の語は言語パッケージの語彙表（leg-mark、leg-column、day-shift-mark、time-zone、local-time-mark）から取る。
 
 const marksOf = (doc: ProseDocument, lexicon: string): Mark[] =>
@@ -34,26 +36,40 @@ const timesOf = (text: string): TimeSpan[] => clockTimes(text).map((time) => ({
 
 type Finder = (source: string, times: readonly TimeSpan[], dates: readonly DateSpan[], words: TimeWords, doc: ProseDocument) => StructureIssue[];
 
+/** 先頭の時刻を次の時刻と比べたもの（first）、勤務表の始まりと終わりの列（columns）。それ以外は variant のまま。 */
+const variantOf = (issue: StructureIssue, variant: string | undefined): string | undefined => {
+  if (variant !== undefined) return variant;
+  if ("next" in issue.values) return "first";
+  return "end_label" in issue.values ? "columns" : undefined;
+};
+
 /** 表と箇条書きを行のまま読むので、原文を渡す（doc.prose は表を覆う）。 */
 const detectorOf =
-  (rule: string, find: Finder): Detector =>
+  (rule: string, find: Finder, variant?: string): Detector =>
   (doc): Finding[] =>
-    find(doc.source, timesOf(doc.source), datesOf(doc), timeWordsOf(doc), doc).map((issue) => ({
-      rule,
-      severity: "warning",
-      line: 0,
-      column: 0,
-      quote: quoteAt(doc.source, issue.offset),
-      values: { ...issue.values, offset: issue.offset },
-      ...("next" in issue.values ? { variant: "first" } : {}),
-    }));
-
-export const timeOrder: Detector = detectorOf("time-order", timeOrderBreaks);
-export const arrivalBeforeDeparture: Detector = detectorOf("arrival-before-departure", arrivalsBeforeDeparture);
-export const timeRangeReversed: Detector = detectorOf("time-range-reversed", (source, times, _dates, words, doc) =>
-  reversedTimeRanges(source, times, rangeWordsOf(doc), words),
+    find(doc.source, timesOf(doc.source), datesOf(doc), timeWordsOf(doc), doc).map((issue) => {
+      const named = variantOf(issue, variant);
+      return {
+        rule,
+        severity: "warning",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, issue.offset),
+        values: { ...issue.values, offset: issue.offset },
+        ...(named === undefined ? {} : { variant: named }),
+      };
+    });
+
+const timeOrderInList: Detector = detectorOf("time-order", timeOrderBreaks);
+/** 語の決まった二つの時刻（開場と開演）。語は語彙表 timed-pair-label から取る。 */
+const timeOrderInPair: Detector = detectorOf(
+  "time-order",
+  (source, times, dates, words, doc) => pairedTimesOutOfOrder({ source, times, dates, words }, doc.lexicons["timed-pair-label"] ?? []),
+  "pair",
 );
 
+export const timeOrder: Detector = (doc, options) => [...timeOrderInList(doc, options), ...timeOrderInPair(doc, options)];
+export const arrivalBeforeDeparture: Detector = detectorOf("arrival-before-departure", arrivalsBeforeDeparture);
 const SECONDS_PER_HOUR = 3600;
 const SECONDS_PER_MINUTE = 60;
 
@@ -61,14 +77,32 @@ const patternsOf = (doc: ProseDocument, lexicon: string, weight?: number): strin
   (doc.lexicons[lexicon] ?? []).filter((entry) => weight === undefined || entry.weight === weight).map((entry) => entry.pattern);
 
 /** 時間と分の長さ（約10分、about 40 minutes）。単位は unit-time の重さ（秒）で時間と分に分ける。 */
-const travelLengthsOf = (doc: ProseDocument): TravelLength[] =>
-  timeLengths(doc.source, {
+const lengthsIn = (doc: ProseDocument, text: string): TravelLength[] =>
+  timeLengths(text, {
     hourUnits: patternsOf(doc, "unit-time", SECONDS_PER_HOUR),
     minuteUnits: patternsOf(doc, "unit-time", SECONDS_PER_MINUTE),
     halves: patternsOf(doc, "length-half"),
     numberWords: patternsOf(doc, "count-number"),
   });
 
+/** 升に書いた長さを分で。単位付き（8.0時間、9時間30分、8 hours）、時と分（1:00）、単位の無い時間（8.00）。 */
+const cellLength = (doc: ProseDocument, text: string): number | undefined => cellMinutes(text, lengthsIn(doc, text), true);
+
+/** 範囲に書いた時刻と、勤務表の始まりと終わりの列（語彙表 shift-column）。同じ時刻を両方から読んでも一度だけ言う。 */
+export const timeRangeReversed: Detector = detectorOf("time-range-reversed", (source, times, _dates, words, doc) => {
+  const inline = reversedTimeRanges(source, times, rangeWordsOf(doc), words);
+  const rows = reversedShiftRows({
+    source,
+    times,
+    columns: marksOf(doc, "shift-column"),
+    overnight: showsOvernightWork(source, times, marksOf(doc, "overnight-work-mark"), words),
+    lengthOf: (text) => cellLength(doc, text),
+  }).filter((row) => !inline.some((issue) => issue.offset <= row.offset && row.offset < issue.offset + String(issue.values["range"]).length));
+  return [...inline, ...rows].toSorted((left, right) => left.offset - right.offset);
+});
+
+const travelLengthsOf = (doc: ProseDocument): TravelLength[] => lengthsIn(doc, doc.source);
+
 const travelWordsOf = (doc: ProseDocument): TravelWords => {
   const marks = marksOf(doc, "travel-time-word");
   return { cues: marks.filter((mark) => mark.group === "travel"), bounds: marks.filter((mark) => mark.group === "bound") };

package/src/detectors/use-maximum.ts

@@ -0,0 +1,38 @@
+import type { Detector, Finding, ProseDocument, Span } from "../plugin.ts";
+import { exceededMaxima } from "../derived/use-maximum.ts";
+import { paragraphsOf } from "../derived/period-counts.ts";
+import { limitWordsOf, marksOf, periodCountWordsOf } from "./use-count-words.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { isMoneySpan, type CurrencyMark } from "../derived/money-span.ts";
+
+// 1回の量 × 期間あたりの回数が、その期間の上限を超える（product-exceeds-maximum）。語は use-count-word と use-amount-word から取る。
+
+const written = (doc: ProseDocument, span: Span): string => doc.source.slice(span.start, span.end);
+
+const LEADING_NUMBER = /^[\p{Nd}.,．，]+\s?/u;
+
+const currencyMarksOf = (doc: ProseDocument): CurrencyMark[] =>
+  (doc.lexicons["currency-notation"] ?? []).map((entry) => ({ pattern: entry.pattern, before: entry.position === "before" }));
+
+export const productExceedsMaximum: Detector = (doc): Finding[] => {
+  const words = { ...periodCountWordsOf(doc), ...limitWordsOf(doc), perUse: marksOf(doc, "use-amount-word") };
+  const marks = currencyMarksOf(doc);
+  const unitOf = (span: Span): string => written(doc, span).replace(LEADING_NUMBER, "");
+  const isMoney = (span: Span): boolean => isMoneySpan(doc.source, span, unitOf(span), marks);
+  const amounts = exceededMaxima(doc.source, paragraphsOf(doc.source), words).filter((exceeded) => !isMoney(exceeded.maximum) && !isMoney(exceeded.perUse));
+  return amounts.map((exceeded) => ({
+    rule: "product-exceeds-maximum",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, exceeded.maximum.start),
+    values: {
+      amount: written(doc, exceeded.perUse),
+      count: written(doc, exceeded.count),
+      maximum: written(doc, exceeded.maximum),
+      expected: exceeded.expected,
+      unit: unitOf(exceeded.maximum),
+      offset: exceeded.maximum.start,
+    },
+  }));
+};

package/src/detectors/variance.ts

@@ -0,0 +1,33 @@
+// variance-mismatch: the reading half. The heading words of the budget, actual and variance columns are lexicon
+// variance-column, the words of magnitude amount-multiplier; the tables are read from the prose with its tables put back.
+// The deciding is structure/variance-table.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 { varianceMismatches, type VarianceRole, type VarianceWords } from "../structure/variance-table.ts";
+
+const RULE = "variance-mismatch";
+const ROLES: readonly string[] = ["rate", "variance", "budget", "actual"] satisfies readonly VarianceRole[];
+const isRole = (group: string | undefined): group is VarianceRole => group !== undefined && ROLES.includes(group);
+
+const wordsOf = (doc: ProseDocument): VarianceWords => ({
+  columns: (doc.lexicons["variance-column"] ?? []).flatMap((entry) => (isRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : [])),
+  multipliers: (doc.lexicons["amount-multiplier"] ?? []).map((entry) => entry.pattern),
+});
+
+export const varianceMismatch: Detector = (doc): Finding[] => {
+  const words = wordsOf(doc);
+  if (words.columns.length === 0) return [];
+  const text = proseAndTablesOf(doc);
+  const tables = tablesOf(linesOf(text)).map((table) => ({ header: cellsOf(table.header), rows: table.rows.map(cellsOf) }));
+  return varianceMismatches(tables, words).map((issue) => ({
+    rule: RULE,
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};