chaffjs 0.30.0 → 0.32.0

package/src/structure/measured-amounts.ts

@@ -0,0 +1,138 @@
+import type { Amount } from "./total.ts";
+import type { MeasureUnit } from "../facts/measures.ts";
+import { CONTINUES_WORD, NUMBER, overlapsAny, valueOf } from "./counted-amounts.ts";
+
+/**
+ * 足してよい、単位の付いた量（300 mg、0.5 g、2 L、3 cm）。単位は量の種類（dimension）と、基準の単位への倍率（factors）を持つ。
+ * 同じ種類の量は、その種類で一番小さい単位に直して足す（500 mg と 0.5 g は 1,000 mg）。倍率が二つある単位（cup）は換算が決まらない。
+ */
+export type SummedMeasure = Pick<MeasureUnit, "pattern" | "dimension" | "factors" | "before" | "context">;
+
+/** 足せない量の印。目安の印（約、about、程度）、範囲の印（〜）、何あたりかの印（数の前の $3 / 200 g、単位の後ろの 300 mg/錠、per tablet）。 */
+export type MeasureMarks = {
+  readonly roughBefore: readonly string[];
+  readonly roughAfter: readonly string[];
+  readonly connectors: readonly string[];
+  readonly perMarks: readonly string[];
+};
+
+/**
+ * 足せない量の単位に付ける印。量は読むが、単位に位置も入れて、ほかのどの量とも同じ単位にならないようにする。その量がある列の和は取らない。
+ * 読まずに捨てると、その行が空の升に見えて、残りの行の和を合計と比べてしまう。
+ */
+const UNSUMMABLE = "?";
+
+const LOOKAHEAD = 32;
+const LATIN = /\p{Script=Latin}/u;
+const DIGIT_AT_END = /\p{N}$/u;
+
+const lineStartOf = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
+
+/** text が word で終わり、英字の語なら語の途中（awesome の some）でない。 */
+const endsWithWord = (text: string, word: string): boolean => {
+  if (!text.toLowerCase().endsWith(word.toLowerCase())) return false;
+  return !LATIN.test(word.charAt(0)) || !LATIN.test(text.charAt(text.length - word.length - 1));
+};
+
+/** text が word で始まり、英字の語なら語の途中（personal の per）でない。 */
+const startsWithWord = (text: string, word: string): boolean => {
+  if (!text.toLowerCase().startsWith(word.toLowerCase())) return false;
+  return !LATIN.test(word.at(-1) ?? "") || !LATIN.test(text.charAt(word.length));
+};
+
+/**
+ * 数の前の目安の印（約300mg、about 300 mg）、何あたりかの印（$3 / 200 g、$3 per 200 g）、
+ * 範囲の後ろの端（300〜400mg、300 - 400 mg）。
+ */
+const markedBefore = (source: string, start: number, marks: MeasureMarks): boolean => {
+  const before = source.slice(lineStartOf(source, start), start);
+  const trimmed = before.trimEnd();
+  if ([...marks.roughBefore, ...marks.perMarks].some((word) => endsWithWord(trimmed, word))) return true;
+  return marks.connectors.some(
+    (connector) => before.endsWith(connector) || (trimmed.endsWith(connector) && DIGIT_AT_END.test(trimmed.slice(0, -connector.length).trimEnd())),
+  );
+};
+
+/** 印の前に置かれうる、開き括弧と空白（5 mg (per tablet)）。 */
+const OPENING = /^[\s(（[［]+/u;
+
+/** 単位の後ろの、目安の印（300mg程度）か何あたりかの印（300 mg/tablet、300 mg per tablet、5 mg (per tablet)）。 */
+const markedAfter = (source: string, end: number, marks: MeasureMarks): boolean => {
+  const after = source.slice(end, end + LOOKAHEAD).replace(OPENING, "");
+  return [...marks.roughAfter, ...marks.perMarks].some((word) => startsWithWord(after, word));
+};
+
+type Found = { readonly measure: SummedMeasure; readonly end: number };
+
+const lineAt = (source: string, offset: number): string => {
+  const end = source.indexOf("\n", offset);
+  return source.slice(lineStartOf(source, offset), end === -1 ? source.length : end);
+};
+
+/** 文脈の語が要る単位（unit-context）は、同じ行にその語があるときだけ単位。 */
+const inContext = (measure: SummedMeasure, source: string, offset: number): boolean => {
+  if (measure.context.length === 0) return true;
+  const line = lineAt(source, offset).toLowerCase();
+  return measure.context.some((word) => line.includes(word.toLowerCase()));
+};
+
+/** 数のすぐ後ろ（空白一つまで）の単位。長い単位から試す（mg を m で切らない）。大文字と小文字は区別する（mL と ML は別）。 */
+const measureAfter = (source: string, end: number, measures: readonly SummedMeasure[], marks: MeasureMarks): Found | undefined => {
+  const gap = source.charAt(end) === " " ? 1 : 0;
+  const rest = source.slice(end + gap, end + gap + LOOKAHEAD);
+  const measure = measures.find((candidate) => {
+    if (candidate.before || !rest.startsWith(candidate.pattern) || !inContext(candidate, source, end)) return false;
+    const unitEnd = end + gap + candidate.pattern.length;
+    return markedAfter(source, unitEnd, marks) || !CONTINUES_WORD.test(rest.slice(candidate.pattern.length));
+  });
+  return measure === undefined ? undefined : { measure, end: end + gap + measure.pattern.length };
+};
+
+/** 量の種類ごとの、一番小さい倍率。倍率が一つの単位だけから取る。 */
+const baseFactors = (measures: readonly SummedMeasure[]): Map<string, number> =>
+  measures.reduce((bases, measure) => {
+    const [factor] = measure.factors;
+    if (measure.factors.length !== 1 || factor === undefined || factor <= 0) return bases;
+    return bases.set(measure.dimension, Math.min(bases.get(measure.dimension) ?? factor, factor));
+  }, new Map<string, number>());
+
+const unsummable = (offset: number, end: number, value: number, measure: SummedMeasure): Amount => ({
+  offset,
+  end,
+  value,
+  unit: `${measure.dimension}${UNSUMMABLE}${String(offset)}`,
+});
+
+const amountOf = (source: string, start: number, written: string, found: Found, bases: Map<string, number>, marks: MeasureMarks): Amount => {
+  const value = valueOf(written);
+  const { measure } = found;
+  const [factor] = measure.factors;
+  const base = bases.get(measure.dimension);
+  const sure = measure.factors.length === 1 && factor !== undefined && base !== undefined;
+  if (!sure || markedBefore(source, start, marks) || markedAfter(source, found.end, marks)) return unsummable(start, found.end, value, measure);
+  const scale = factor / base;
+  return { offset: start, end: found.end, value: value * scale, unit: measure.dimension, scale };
+};
+
+/**
+ * 数のすぐ前（空白一つまで）の単位（大さじ1）は、足さない量として読む。読まずに捨てると、その行が空の升に見えてしまう。
+ */
+const measureBefore = (source: string, start: number, end: number, measures: readonly SummedMeasure[]): Amount | undefined => {
+  const gap = source.charAt(start - 1) === " " ? 1 : 0;
+  const head = source.slice(Math.max(0, start - gap - LOOKAHEAD), start - gap);
+  const measure = measures.find((candidate) => candidate.before && head.endsWith(candidate.pattern) && inContext(candidate, source, start));
+  return measure === undefined ? undefined : unsummable(start - gap - measure.pattern.length, end, valueOf(source.slice(start, end)), measure);
+};
+
+/** 文書の中の、単位の付いた量。値は量の種類で一番小さい単位に直す。木がすでに数量として読んだもの（known）とは重ねない。 */
+export const measuredAmounts = (source: string, measures: readonly SummedMeasure[], marks: MeasureMarks, known: readonly Amount[]): Amount[] => {
+  const longestFirst = measures.toSorted((left, right) => right.pattern.length - left.pattern.length);
+  const bases = baseFactors(measures);
+  return [...source.matchAll(NUMBER)].flatMap((match): Amount[] => {
+    const end = match.index + match[0].length;
+    const found = measureAfter(source, end, longestFirst, marks);
+    if (found !== undefined) return overlapsAny(match.index, found.end, known) ? [] : [amountOf(source, match.index, match[0], found, bases, marks)];
+    const before = measureBefore(source, match.index, end, longestFirst);
+    return before === undefined || overlapsAny(before.offset, before.end, known) ? [] : [before];
+  });
+};

package/src/structure/meter-usage-read.ts

@@ -0,0 +1,139 @@
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { linesOf, type Line } from "./lines.ts";
+import { withoutTrailingNote, type MeterEntry, type MeterGroup, type MeterKind, type MeterUnitWord } from "./meter-usage.ts";
+
+/**
+ * 検針票の名前の付いた値を、まとまりごとに集める。まとまりは見出しから次の見出しまで。値は三つの書き方から読む。
+ * 「今回指示数：12,640」の行、行の見出しが名前の表（| 今回指示数 | 12,640 |）、列の見出しが名前の表
+ * （| 今回指示数 | 前回指示数 | ご使用量 |）。列の見出しが名前の表で本体が二行以上なら、行ごとに別のメーターとして一つの
+ * まとまりにする。名前は語彙表 meter-reading-label から、列の見出しの単位は meter-unit から来る。Pure.
+ */
+export type MeterLabel = { readonly pattern: string; readonly kind: MeterKind };
+
+export type MeterReadWords = { readonly labels: readonly MeterLabel[]; readonly units: readonly MeterUnitWord[] };
+
+const LIST_MARK = /^[-*+]\s/u;
+const DIGIT = /\d/u;
+
+const keyOf = (text: string): string => withoutEdgeMarks(text).normalize("NFKC").toLowerCase().replace(/\s+/gu, " ").trim();
+
+const kindOf = (label: string, words: MeterReadWords): MeterKind | undefined => {
+  const key = withoutTrailingNote(keyOf(label));
+  return words.labels.find((word) => keyOf(word.pattern) === key)?.kind;
+};
+
+/** The unit a column heading names: the heading itself ("kWh") or its bracket ("指示数（kWh）"). */
+const headerUnitOf = (heading: string, words: MeterReadWords): string | undefined => {
+  const key = keyOf(heading);
+  const bracket = withoutTrailingNote(key);
+  const named = bracket === key ? key : key.slice(bracket.length).trim().slice(1, -1).trim();
+  return words.units.find((unit) => keyOf(unit.pattern) === named)?.unit;
+};
+
+/** "- 今回指示数：12,640" → the label and the value with where the value starts in the line; undefined without a colon. */
+const labelAndValue = (text: string): { label: string; value: string; at: number } | undefined => {
+  const colon = [text.indexOf(":"), text.indexOf("：")].filter((index) => index > 0).reduce((first, index) => Math.min(first, index), Infinity);
+  if (colon === Infinity) return undefined;
+  const label = text.slice(0, colon).trim().replace(LIST_MARK, "");
+  const rest = text.slice(colon + 1);
+  const value = rest.trim();
+  return value === "" ? undefined : { label, value, at: colon + 1 + rest.indexOf(value) };
+};
+
+const valueStart = (cell: Cell): number => cell.start + (cell.text.length - cell.text.trimStart().length);
+
+const entryOf = (kind: MeterKind, cell: Cell, headerUnit: string | undefined): MeterEntry => ({
+  kind,
+  value: cell.text.trim(),
+  offset: valueStart(cell),
+  ...(headerUnit === undefined ? {} : { headerUnit }),
+});
+
+/** | 今回指示数 | 12,640 |: the row's one cell with a figure in it is the value. */
+const rowEntry = (row: Line, headings: readonly string[], words: MeterReadWords): MeterEntry[] => {
+  const [label, ...rest] = cellsOf(row);
+  const kind = label === undefined ? undefined : kindOf(label.text, words);
+  if (kind === undefined) return [];
+  const withFigure = rest.flatMap((cell, index) => (DIGIT.test(cell.text) ? [{ cell, heading: headings[index + 1] ?? "" }] : []));
+  const [only, ...more] = withFigure;
+  if (only === undefined || more.length > 0) return [];
+  return [entryOf(kind, only.cell, headerUnitOf(only.heading, words))];
+};
+
+/** | 今回指示数 | 前回指示数 | ご使用量 | over one row of values: each named column gives the value under it. */
+const columnEntries = (row: Line, headings: readonly string[], words: MeterReadWords): MeterEntry[] =>
+  cellsOf(row).flatMap((cell, index) => {
+    const kind = kindOf(headings[index] ?? "", words);
+    return kind === undefined ? [] : [entryOf(kind, cell, headerUnitOf(headings[index] ?? "", words))];
+  });
+
+/** alone: a row of a table with one meter per row, a group by itself; only its own text says what happened to its meter. */
+type Placed = { readonly line: number; readonly entries: readonly MeterEntry[]; readonly alone: boolean; readonly text: string };
+
+const MIN_NAMED_COLUMNS = 2;
+
+const tableEntries = (table: { header: Line; rows: Line[] }, words: MeterReadWords): Placed[] => {
+  const headings = cellsOf(table.header).map((cell) => cell.text);
+  const named = headings.filter((heading) => kindOf(heading, words) !== undefined).length;
+  if (named >= MIN_NAMED_COLUMNS) {
+    const alone = table.rows.length > 1;
+    return table.rows.map((row) => ({ line: row.number, entries: columnEntries(row, headings, words), alone, text: row.text }));
+  }
+  return table.rows.map((row) => ({ line: row.number, entries: rowEntry(row, headings, words), alone: false, text: row.text }));
+};
+
+const lineEntry = (line: Line, words: MeterReadWords): Placed[] => {
+  if (line.text.includes("|")) return [];
+  const parts = labelAndValue(line.text);
+  const kind = parts === undefined ? undefined : kindOf(parts.label, words);
+  if (parts === undefined || kind === undefined) return [];
+  return [{ line: line.number, entries: [{ kind, value: parts.value, offset: line.start + parts.at }], alone: false, text: line.text }];
+};
+
+/** Each line's section: how many headings start at or before it. Index 0 is unused (lines count from 1). */
+const sectionsOf = (lines: readonly Line[], headingLines: readonly number[]): number[] => {
+  const headings = new Set(headingLines);
+  const sections = [0];
+  lines.forEach((line) => sections.push((sections.at(-1) ?? 0) + (headings.has(line.number) ? 1 : 0)));
+  return sections;
+};
+
+/**
+ * The groups of a document. text is the prose with its tables (headings blanked, offsets kept); headingLines are the line
+ * numbers of its headings, which split it into sections.
+ */
+export const meterGroups = (text: string, headingLines: readonly number[], words: MeterReadWords): MeterGroup[] => {
+  const lines = linesOf(text);
+  const tables = tablesOf(lines);
+  const inTable = new Set(tables.flatMap((table) => [table.header.number, ...table.rows.map((row) => row.number)]));
+  const placed = [
+    ...tables.flatMap((table) => tableEntries(table, words)),
+    ...lines.filter((line) => !inTable.has(line.number)).flatMap((line) => lineEntry(line, words)),
+  ].filter((entry) => entry.entries.length > 0);
+  if (placed.length === 0) return [];
+  const sections = sectionsOf(lines, headingLines);
+  const sectionOf = (line: number): number => sections[line] ?? 0;
+  const sectionLines = groupedBy(lines, (line) => sectionOf(line.number));
+  const alone = placed.filter((entry) => entry.alone).map((entry) => ({ entries: entry.entries, text: entry.text }));
+  const bySection = groupedBy(
+    placed.filter((entry) => !entry.alone).toSorted((left, right) => left.line - right.line),
+    (entry) => sectionOf(entry.line),
+  );
+  const shared = [...bySection].map(([section, entries]) => ({
+    entries: entries.flatMap((entry) => entry.entries),
+    text: (sectionLines.get(section) ?? []).map((line) => line.text).join("\n"),
+  }));
+  return [...shared, ...alone];
+};
+
+const groupedBy = <T>(items: readonly T[], keyOf: (item: T) => number): Map<number, T[]> => {
+  const groups = new Map<number, T[]>();
+  items.forEach((item) => {
+    const key = keyOf(item);
+    const group = groups.get(key);
+    if (group === undefined) groups.set(key, [item]);
+    else group.push(item);
+  });
+  return groups;
+};

package/src/structure/meter-usage.ts

@@ -0,0 +1,224 @@
+import { escapeRegExp } from "../orthography.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/**
+ * 検針票で、今回の指示数 − 前回の指示数（乗率があれば × 乗率）が、書いた使用量と合わない所。読む側（meter-usage-read.ts）が
+ * 一つのまとまり（見出しから見出しまで、または表の一行）ごとに、語彙表 meter-reading-label の名前の付いた値を集めて渡す。
+ * 今回・前回・使用量が一つずつそろい、どれも単位が読めて食い違わないときだけ比べる。今回が前回より小さいのは、メーターが
+ * 一巡したと書いてあるとき（同じ節で打ち消していないとき）だけ、前回の桁数の上限を足して読む。乗率が書いてあって読めないとき、メーターを取り替えたと書いて
+ * あるときは比べない。使用量は書いた桁までの丸め（切り捨て・四捨五入・切り上げ）を認める。Pure.
+ */
+export type MeterKind = "current" | "previous" | "usage" | "multiplier";
+
+export type MeterEntry = {
+  readonly kind: MeterKind;
+  /** The value as written after its label, or the cell's text. */
+  readonly value: string;
+  /** Where the value starts in the document. */
+  readonly offset: number;
+  /** The unit a table heading gives its column ("kWh"), when it gives one. */
+  readonly headerUnit?: string;
+};
+
+/** One bill's readings: the named values of a section or a table row, and the section's text (for a stated rollover). */
+export type MeterGroup = { readonly entries: readonly MeterEntry[]; readonly text: string };
+
+export type MeterUnitWord = { readonly pattern: string; readonly unit: string };
+
+export type MeterWords = {
+  /** Unit words and the unit they name (meter-unit): "m³" and "立方メートル" are both m3. */
+  readonly units: readonly MeterUnitWord[];
+  /** Words saying the meter went past its last figure (meter-event, group rollover). */
+  readonly rollover: readonly string[];
+  /** Words after a rollover word, in its clause, that deny it (「一巡していません」): meter-event, group rollover-negation-after. */
+  readonly rolloverNegationAfter: readonly string[];
+  /** Words before a rollover word, in its clause, that deny it ("has not rolled over"): group rollover-negation-before. */
+  readonly rolloverNegationBefore: readonly string[];
+  /** Words saying the meter was replaced (meter-event, group replaced): the two readings are of different meters. */
+  readonly replaced: readonly string[];
+};
+
+/** A number as written: its value in units of its last digit, and how many decimals it has. */
+type Reading = {
+  readonly scaled: bigint;
+  readonly decimals: number;
+  readonly digits: number;
+  readonly unit: string;
+  readonly grouped: boolean;
+  readonly written: string;
+};
+
+const LEADING_NUMBER = /^(\d{1,3}(?:,\d{3})+|\d+)(?:\.(\d+))?(?![\d,])/u;
+const MULTIPLIER = /^[×x*]?\s*(\d+(?:\.\d+)?)\s*(?:倍|times)?$/u;
+const TEN = 10n;
+
+const normal = (text: string): string => text.normalize("NFKC").replace(/[*_`]/gu, "").trim();
+
+/** "36m3 (2か月分)" → "36m3": the bracket a value or a name ends with is a note. Brackets are ASCII once NFKC-normalised. */
+export const withoutTrailingNote = (text: string): string => {
+  const open = text.lastIndexOf("(");
+  return text.endsWith(")") && open >= 0 ? text.slice(0, open).trimEnd() : text;
+};
+
+const unitOf = (word: string, words: MeterWords): string | undefined => {
+  const wanted = word.toLowerCase();
+  if (wanted === "") return "";
+  return words.units.find((unit) => unit.pattern.normalize("NFKC").toLowerCase() === wanted)?.unit;
+};
+
+/** "12,640", "350kWh", "36m³（2か月分）". Undefined when the value is not one number, or its word is not a meter unit. */
+export const readingOf = (entry: MeterEntry, words: MeterWords): Reading | undefined => {
+  const written = normal(entry.value);
+  const number = withoutTrailingNote(written);
+  const match = LEADING_NUMBER.exec(number);
+  if (match === null) return undefined;
+  const [matched, whole = "", fraction = ""] = match;
+  const own = unitOf(number.slice(matched.length).trim(), words);
+  if (own === undefined) return undefined;
+  const digits = whole.replaceAll(",", "");
+  return {
+    scaled: BigInt(`${digits}${fraction}`),
+    decimals: fraction.length,
+    digits: digits.length,
+    unit: own === "" ? (entry.headerUnit ?? "") : own,
+    grouped: whole.includes(","),
+    written,
+  };
+};
+
+/** The multiplier as a scaled number ("×10" → 10, "1.5" → 15 with one decimal); undefined when it cannot be read. */
+export const multiplierOf = (value: string): { readonly scaled: bigint; readonly decimals: number } | undefined => {
+  const match = MULTIPLIER.exec(normal(value).toLowerCase());
+  if (match === null) return undefined;
+  const [whole = "", fraction = ""] = (match[1] ?? "").split(".");
+  return { scaled: BigInt(`${whole}${fraction}`), decimals: fraction.length };
+};
+
+const rescaled = (scaled: bigint, from: number, to: number): bigint => scaled * TEN ** BigInt(to - from);
+
+const ofKind = (entries: readonly MeterEntry[], kind: MeterKind): MeterEntry[] => entries.filter((entry) => entry.kind === kind);
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase().replaceAll("\u2019", "'");
+
+const mentions = (text: string, phrases: readonly string[]): boolean => {
+  const lowered = folded(text);
+  return phrases.some((phrase) => lowered.includes(folded(phrase)));
+};
+
+/** A negation across one of these is about something else: 「一巡しましたが、交換はしていません」. */
+const CLAUSE_END = /[、。,.;:!?\n]/u;
+const LATIN_LETTER = /\p{Script=Latin}/u;
+
+const startsOf = (text: string, phrase: string): number[] =>
+  phrase === "" ? [] : [...text.matchAll(new RegExp(escapeRegExp(phrase), "gu"))].map((match) => match.index);
+
+/** A Latin edge of the phrase must not run on into a letter: "not" is not in "notice", "never" not in "whenever". */
+const isWordAt = (text: string, phrase: string, start: number): boolean => {
+  const joins = (edge: string, neighbour: string): boolean => LATIN_LETTER.test(edge) && LATIN_LETTER.test(neighbour);
+  return !joins(phrase.at(0) ?? "", text[start - 1] ?? "") && !joins(phrase.at(-1) ?? "", text[start + phrase.length] ?? "");
+};
+
+/** "has not yet rolled over"; in "was not replaced and rolled over" the "not" is about something else. */
+const MAX_WORDS_AFTER_NEGATION = 1;
+
+type Reach = (text: string, end: number) => boolean;
+
+const anywhere: Reach = () => true;
+
+const nextToEnd: Reach = (text, end) =>
+  text
+    .slice(end)
+    .split(/\s+/u)
+    .filter((word) => word !== "").length <= MAX_WORDS_AFTER_NEGATION;
+
+const hasWord = (text: string, phrases: readonly string[], reaches: Reach): boolean =>
+  phrases.some((phrase) => {
+    const wanted = folded(phrase);
+    return startsOf(text, wanted).some((start) => isWordAt(text, wanted, start) && reaches(text, start + wanted.length));
+  });
+
+/** The rollover word at start is denied by a negation in its own clause: after it, or (in English) just before it. */
+const isDenied = (text: string, start: number, length: number, words: MeterWords): boolean => {
+  const before = text.slice(0, start).split(CLAUSE_END).at(-1) ?? "";
+  const after = text.slice(start + length).split(CLAUSE_END)[0] ?? "";
+  return hasWord(after, words.rolloverNegationAfter, anywhere) || hasWord(before, words.rolloverNegationBefore, nextToEnd);
+};
+
+/** Some rollover word is written and not denied in its clause. */
+export const statesRollover = (text: string, words: MeterWords): boolean => {
+  const lowered = folded(text);
+  return words.rollover.some((phrase) => {
+    const wanted = folded(phrase);
+    return startsOf(lowered, wanted).some((start) => !isDenied(lowered, start, wanted.length, words));
+  });
+};
+
+/** The units of the three agree: each is unstated or the same one. */
+const unitsAgree = (readings: readonly Reading[]): boolean => new Set(readings.map((reading) => reading.unit).filter((unit) => unit !== "")).size <= 1;
+
+/** current − previous at the readings' common scale; a stated rollover adds the previous reading's next power of ten. */
+const difference = (current: Reading, previous: Reading, scale: number, group: MeterGroup, words: MeterWords): bigint | undefined => {
+  const plain = rescaled(current.scaled, current.decimals, scale) - rescaled(previous.scaled, previous.decimals, scale);
+  if (plain >= 0n) return plain;
+  if (!statesRollover(group.text, words)) return undefined;
+  return plain + rescaled(TEN ** BigInt(previous.digits), 0, scale);
+};
+
+/** Usage is written to its last digit, so any value within one step of it, either side, is a rounding of it. */
+const withinRounding = (expected: bigint, usage: Reading, scale: number): boolean => {
+  const gap = expected - rescaled(usage.scaled, usage.decimals, scale);
+  const step = TEN ** BigInt(scale - usage.decimals);
+  return gap < step && gap > -step;
+};
+
+const shown = (scaled: bigint, decimals: number, grouped: boolean): string => {
+  const text = scaled.toString().padStart(decimals + 1, "0");
+  const whole = text.slice(0, text.length - decimals);
+  const groupedWhole = grouped ? BigInt(whole).toLocaleString("en-US") : whole;
+  return decimals === 0 ? groupedWhole : `${groupedWhole}.${text.slice(text.length - decimals)}`;
+};
+
+type Parts = { readonly current: MeterEntry; readonly previous: MeterEntry; readonly usage: MeterEntry; readonly multiplier: MeterEntry | undefined };
+
+/** One of each of the three, and at most one multiplier; two meters in one place are not told apart. */
+const partsOf = (group: MeterGroup): Parts | undefined => {
+  const [current, ...moreCurrent] = ofKind(group.entries, "current");
+  const [previous, ...morePrevious] = ofKind(group.entries, "previous");
+  const [usage, ...moreUsage] = ofKind(group.entries, "usage");
+  const [multiplier, ...moreMultiplier] = ofKind(group.entries, "multiplier");
+  if (current === undefined || previous === undefined || usage === undefined) return undefined;
+  if (moreCurrent.length + morePrevious.length + moreUsage.length + moreMultiplier.length > 0) return undefined;
+  return { current, previous, usage, multiplier };
+};
+
+const groupIssue = (group: MeterGroup, words: MeterWords): StructureIssue[] => {
+  const parts = partsOf(group);
+  if (parts === undefined || mentions(group.text, words.replaced)) return [];
+  const current = readingOf(parts.current, words);
+  const previous = readingOf(parts.previous, words);
+  const usage = readingOf(parts.usage, words);
+  const factor = parts.multiplier === undefined ? { scaled: 1n, decimals: 0 } : multiplierOf(parts.multiplier.value);
+  if (current === undefined || previous === undefined || usage === undefined || factor === undefined) return [];
+  if (!unitsAgree([current, previous, usage])) return [];
+  const readScale = Math.max(current.decimals, previous.decimals);
+  const diff = difference(current, previous, readScale, group, words);
+  if (diff === undefined) return [];
+  const scale = Math.max(readScale + factor.decimals, usage.decimals);
+  const expected = rescaled(diff * factor.scaled, readScale + factor.decimals, scale);
+  if (withinRounding(expected, usage, scale)) return [];
+  const times = parts.multiplier === undefined ? "" : ` × ${shown(factor.scaled, factor.decimals, false)}`;
+  return [
+    {
+      offset: parts.current.offset,
+      values: {
+        current: current.written,
+        previous: previous.written,
+        times,
+        expected: shown(expected, scale, current.grouped || usage.grouped),
+        usage: usage.written,
+      },
+    },
+  ];
+};
+
+export const meterUsageMismatches = (groups: readonly MeterGroup[], words: MeterWords): StructureIssue[] => groups.flatMap((group) => groupIssue(group, words));