chaffjs 0.30.0 → 0.32.0

package/src/detectors/relative-day-words.ts

@@ -6,6 +6,7 @@ import type { DatedValue } from "../derived/relative-dates.ts";
 import { relativeDayMismatch, type DayWord } from "../derived/relative-weekdays.ts";
 import { escapeRegExp } from "../orthography.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { readableDates } from "./readable-dates.ts";
 
 const FULL = /^\d{4}-\d{2}-\d{2}$/u;
 const LATIN = /^[A-Za-z]/u;
@@ -117,7 +118,7 @@ export const dayWordFindings = (doc: ProseDocument, dates: readonly DatedValue[]
             base: doc.source.slice(base.start, base.end),
             relative: doc.source.slice(word.start, word.end),
             target: doc.source.slice(target.start, target.end),
-            expected,
+            expected: readableDates(doc)(expected),
             offset: target.start,
           },
         },

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

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

package/src/detectors/request-owner.ts

@@ -14,6 +14,7 @@ export const REQUEST_LEXICONS = {
   deadline: "request-deadline",
   owner: "request-owner",
   pointer: "request-pointer",
+  offer: "request-offer",
 } as const;
 
 type Words = Readonly<Record<keyof typeof REQUEST_LEXICONS, readonly string[]>>;
@@ -30,6 +31,7 @@ const wordsOf = (doc: ProseDocument): Words => ({
   deadline: patternsOf(doc.lexicons[REQUEST_LEXICONS.deadline]),
   owner: patternsOf(doc.lexicons[REQUEST_LEXICONS.owner]),
   pointer: patternsOf(doc.lexicons[REQUEST_LEXICONS.pointer]),
+  offer: patternsOf(doc.lexicons[REQUEST_LEXICONS.offer]),
 });
 
 /** How far apart, in characters, the action word and the request ending may be: the action must be what is requested. */
@@ -57,13 +59,14 @@ const gapBetween = (left: Place, right: Place): number => Math.max(left.start -
 
 /**
  * A request for an action: an action word next to a request ending (「確認してください」「please send」), not a condition
- * (「ご不明な点があれば…ください」 is an offer), and not a pointer to where to read more (「詳細は資料をご確認ください」).
+ * (「ご不明な点があれば…ください」 is an offer), not an open offer to take the reader's questions (「ご質問はメールでお送りください」),
+ * and not a pointer to where to read more (「詳細は資料をご確認ください」).
  * The action has to be close to the ending, or a noun like 検討会 or 履修登録 earlier in the sentence would make one.
  */
 export const isRequest = (text: string, words: Words): boolean => {
   const endings = placesOf(text, words.ending);
   const asked = placesOf(text, words.action).some((action) => endings.some((ending) => gapBetween(action, ending) <= ACTION_REACH));
-  return asked && !containsAny(text, words.condition) && !containsAny(text, words.pointer);
+  return asked && ![words.condition, words.offer, words.pointer].some((patterns) => containsAny(text, patterns));
 };
 
 const NAMED = new Set(["PROPN"]);

package/src/detectors/revision-direction.ts

@@ -0,0 +1,44 @@
+// revision-direction-mismatch: a forecast said to be revised one way whose revision table moves the other way
+// (structure/revision-direction.ts). The words are revision-direction (rise, fall; the verbs rise-verb and fall-verb, read
+// only with a word of its group forecast in their sentence) and the labels of the previous and
+// revised forecasts revision-column (previous, revised); the sections start at the headings, whose words the prose masks
+// and this puts back.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { revisionDirectionMismatches, type RevisionWords } from "../structure/revision-direction.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { proseWithCells } from "../table-cells.ts";
+import { quoteAround } from "./quote-around.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => entry.group === group).map((entry) => entry.pattern);
+
+const wordsOf = (doc: ProseDocument): RevisionWords => ({
+  rises: patternsOf(doc, "revision-direction", "rise"),
+  falls: patternsOf(doc, "revision-direction", "fall"),
+  risesWithObject: patternsOf(doc, "revision-direction", "rise-verb"),
+  fallsWithObject: patternsOf(doc, "revision-direction", "fall-verb"),
+  objects: patternsOf(doc, "revision-direction", "forecast"),
+  previous: patternsOf(doc, "revision-column", "previous"),
+  revised: patternsOf(doc, "revision-column", "revised"),
+});
+
+export const revisionDirection: Detector = (doc): Finding[] => {
+  const headings = doc.markup?.headings ?? [];
+  const text = proseWithCells(
+    proseAndTablesOf(doc),
+    headings.map((heading) => ({ ...heading, text: doc.source.slice(heading.start, heading.end) })),
+  );
+  const input = {
+    text,
+    sectionStarts: headings.map((heading) => heading.start),
+    units: [...headings, ...doc.sentences.map((sentence) => sentence.span)],
+  };
+  return revisionDirectionMismatches(input, wordsOf(doc)).map((issue) => ({
+    rule: "revision-direction-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

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

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

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/signals.ts

@@ -371,7 +371,9 @@ export const concreteEvidence: Detector = (doc, options): Finding[] => {
  * ダッシュの多用。英語では正当な用法が多いが、2026 年時点で最も知られた生成文のシグナルでもある。
  * 日本語の組版ではそもそも扱いが難しい。どちらが正しいかは severity の言語別指定で分ける。spec §12.4。
  */
-const DASH = /[\u2014\u2015\u2013]/gu;
+// An en dash between two digits (45–58, 10:00–10:15) is a range mark, the typographer's correct choice, not a dash that
+// sets off words.
+const DASH = /[\u2014\u2015]|(?<!\p{Nd})\u2013|\u2013(?!\p{Nd})/gu;
 
 export const dashDensity: Detector = (doc, options): Finding[] => {
   const hits = findIn(doc, DASH);

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

@@ -0,0 +1,55 @@
+// A stated total time (所要時間：60分, Total time: 1 hr) that is not the sum of the times written in the numbered steps. The
+// units, the total labels, the rough-figure marks and the marks of a time that is not a step's own come from the language packages.
+import { stepTimeSlip, type StepTimeWords } from "../structure/step-times.ts";
+import type { Mark } from "../structure/time-marks.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_MINUTE = 60;
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const marksOf = (doc: ProseDocument, id: string): Mark[] =>
+  (doc.lexicons[id] ?? []).map((entry) => ({ pattern: entry.pattern, position: entry.position, group: entry.group }));
+
+const unitsWeighing = (doc: ProseDocument, seconds: number): string[] =>
+  (doc.lexicons["unit-time"] ?? []).filter((entry) => entry.weight === seconds).map((entry) => entry.pattern);
+
+const RANGE_GROUP = "range";
+
+const wordsOf = (doc: ProseDocument): StepTimeWords => {
+  const notOwn = marksOf(doc, "step-time-not-own");
+  return {
+    lengths: {
+      hourUnits: unitsWeighing(doc, SECONDS_PER_HOUR),
+      minuteUnits: unitsWeighing(doc, SECONDS_PER_MINUTE),
+      halves: patternsOf(doc, "length-half"),
+      numberWords: patternsOf(doc, "count-number"),
+    },
+    totals: marksOf(doc, "step-time-total"),
+    approximate: marksOf(doc, "approximate-marker"),
+    notOwn: notOwn.filter((mark) => mark.group !== RANGE_GROUP),
+    rangeJoiners: notOwn.filter((mark) => mark.group === RANGE_GROUP).map((mark) => mark.pattern),
+  };
+};
+
+export const stepTimeSumMismatch: Detector = (doc): Finding[] => {
+  const slip = stepTimeSlip(doc.source, wordsOf(doc));
+  if (slip === undefined) return [];
+  return [
+    {
+      rule: "step-time-sum-mismatch",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, slip.total.start),
+      values: {
+        written: doc.source.slice(slip.total.start, slip.total.end),
+        sum: slip.sum,
+        steps: slip.steps,
+        offset: slip.total.start,
+      },
+    },
+  ];
+};