chaffjs 0.30.0 → 0.32.0

package/src/detectors/structure-tree.ts

@@ -6,14 +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 { 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;
 
@@ -88,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;
@@ -141,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,
@@ -163,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" } : {}),
       }));
 
@@ -184,11 +197,69 @@ const summableAmountsOf = (doc: ProseDocument, tree: NonNullable<ProseDocument["
   return [...known, ...countedAmounts(doc.source, summedCountersOf(doc), known)].toSorted((left, right) => left.offset - right.offset);
 };
 
-/** 合計の行と内訳の行、文の中の合計と内訳。同じ金額は一度だけ言う。 */
+/** 合計の行で足す量の種類。換算の倍率は語彙表の weight。 */
+const SUMMED_DIMENSIONS = ["unit-mass", "unit-volume", "unit-length"] as const;
+
+/** 足す単位。零点のずれた単位（°F）は足せないので除く。 */
+const summedMeasuresOf = (doc: ProseDocument): SummedMeasure[] =>
+  measureUnitsOf(doc).filter((unit) => unit.zero === 0 && SUMMED_DIMENSIONS.some((dimension) => dimension === unit.dimension));
+
+const positionedOf = (doc: ProseDocument, lexicon: string, position: "before" | "after"): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => (entry.position ?? "before") === position).map((entry) => entry.pattern);
+
+const measureMarksOf = (doc: ProseDocument): MeasureMarks => ({
+  roughBefore: positionedOf(doc, "approximate-marker", "before"),
+  roughAfter: positionedOf(doc, "approximate-marker", "after"),
+  connectors: patternsOf(doc, "range-connector"),
+  perMarks: patternsOf(doc, "measure-per-mark"),
+});
+
+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[] =>
+  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 lines = totalMismatches(doc.source, amounts, patternsOf(doc, "total-label"));
   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"),
     discounts: patternsOf(doc, "discount-word"),
@@ -198,7 +269,7 @@ const totalIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["struct
     doc.source,
     doc.sentences.map((sentence) => sentence.span),
     amounts,
-    words,
+    phrases,
   );
   return [...lines, ...prose.filter((issue) => !lines.some((line) => line.offset === issue.offset))];
 };
@@ -219,7 +290,7 @@ export const totalMismatch: Detector = (doc): Finding[] =>
         values: { ...issue.values, offset: issue.offset },
       }));
 
-const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
+export const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
   connectors: (doc.lexicons["range-connector"] ?? []).map((entry) => entry.pattern),
   openers: (doc.lexicons["range-opener"] ?? []).map((entry) => entry.pattern),
   closers: (doc.lexicons["range-closer"] ?? []).map((entry) => entry.pattern),
@@ -228,13 +299,14 @@ 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;
   };
 
@@ -261,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/structure.ts

@@ -138,7 +138,7 @@ const withoutDateStamps = (doc: ProseDocument, paragraphs: readonly Paragraph[])
 export const preambleLength: Detector = (doc, options): Finding[] => {
   const body = bodySectionOf(doc.sections);
   if (body === undefined) return [];
-  const all = preambleParagraphs(doc.paragraphs, body.span.start);
+  const all = preambleParagraphs(doc.paragraphs, body.span.start, doc.source);
   if (all.length <= options.limit) return [];
   const before = withoutDateStamps(doc, all);
   if (before.length <= options.limit) return [];

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";
@@ -191,6 +192,17 @@ const isInflected = (token: Token): boolean =>
   token.lemma !== undefined && token.lemma !== "" && token.surface.toLowerCase() !== token.lemma && token.features?.["VerbForm"] !== "Part";
 
 const NOMINAL = new Set(["NOUN", "PROPN"]);
+/** What an adjective at the head of a subject goes on to: the noun it describes, or another word describing it. */
+const DESCRIBED = new Set(["NOUN", "PROPN", "ADJ"]);
+
+/**
+ * An adjective opening a subject is followed by what it describes (Each user, Large files). One followed by a preposition
+ * or an article is an imperative the tagger read as an adjective (Bake in the oven, Open the file).
+ */
+export const opensWithMisreadImperative = (tokens: readonly Token[]): boolean => {
+  const [head, next] = tokens.filter((token) => !SKIPPED.has(token.pos));
+  return head?.pos === "ADJ" && !DESCRIBED.has(next?.pos ?? "");
+};
 
 /** A determiner right after a noun opens a clause inside the phrase (a buffer that is big): the verb after it is the clause's, not a subject's. */
 const opensClause = (words: readonly Token[]): boolean => words.some((token, at) => at > 0 && token.pos === "DET" && NOMINAL.has(words[at - 1]?.pos ?? ""));
@@ -204,6 +216,7 @@ export const isStatement = (tokens: readonly Token[]): boolean => {
   const words = tokens.filter((token) => !SKIPPED.has(token.pos));
   const [head, ...rest] = words;
   if (head === undefined || words.length < MIN_STEP_TOKENS || !SUBJECT_HEAD.has(head.pos)) return false;
+  if (opensWithMisreadImperative(words)) return false;
   const verbAt = rest.findIndex((token) => PREDICATE.has(token.pos));
   const verb = rest[verbAt];
   const subject = [head, ...rest.slice(0, verbAt)];
@@ -215,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

@@ -7,9 +7,12 @@ import { scheduleDays, timeOrderBreaks } from "../structure/time-order.ts";
 import { arrivalOffsets, arrivalsBeforeDeparture } from "../structure/leg-times.ts";
 import { shortConnections, type TravelLength, type TravelWords } from "../structure/connection-times.ts";
 import { timeLengths } from "../derived/time-lengths.ts";
-import { quoteAt } from "./structure-tree.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[] =>
@@ -33,23 +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);
+    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;
 
@@ -57,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") };