chaffjs 0.30.0 → 0.32.0

package/src/detectors/installment-total-mismatch.ts

@@ -0,0 +1,68 @@
+// installment-total-mismatch: a number of payments times the amount of each that is not the stated total of payments
+// (structure/installment-total.ts). The amounts are currency-notation's, read with amount-multiplier's words of scale; the
+// labels are installment-label, the other words installment-word, approximate-marker, number-word (digit), range-connector
+// and amount-range-word.
+import type { Detector, Finding, Lexicon, ProseDocument } from "../plugin.ts";
+import { installmentTotalMismatches, type InstallmentAmount, type InstallmentWords, type PositionedWord } from "../structure/installment-total.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 entriesOf = (doc: ProseDocument, lexicon: string, group?: string): Lexicon =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group);
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] => entriesOf(doc, lexicon, group).map((entry) => entry.pattern);
+
+const markersOf = (doc: ProseDocument): PositionedWord[] =>
+  entriesOf(doc, "approximate-marker").map((entry) => ({ word: entry.pattern, position: entry.position === "after" ? "after" : "before" }));
+
+const numberWordsOf = (doc: ProseDocument): InstallmentWords["numberWords"] =>
+  entriesOf(doc, "number-word", "digit").flatMap((entry) => (entry.weight === undefined ? [] : [{ word: entry.pattern, value: entry.weight }]));
+
+const labelsOf = (doc: ProseDocument): InstallmentWords["labels"] => ({
+  count: patternsOf(doc, "installment-label", "count"),
+  each: patternsOf(doc, "installment-label", "each"),
+  first: patternsOf(doc, "installment-label", "first"),
+  last: patternsOf(doc, "installment-label", "last"),
+  total: patternsOf(doc, "installment-label", "total"),
+});
+
+const wordsOf = (doc: ProseDocument): InstallmentWords => ({
+  labels: labelsOf(doc),
+  units: patternsOf(doc, "installment-word", "unit"),
+  qualifiers: patternsOf(doc, "installment-word", "qualifier"),
+  links: patternsOf(doc, "installment-word", "link"),
+  per: patternsOf(doc, "installment-word", "per"),
+  rounding: patternsOf(doc, "installment-word", "rounding"),
+  skips: patternsOf(doc, "installment-word", "skip"),
+  markers: markersOf(doc),
+  connectors: [...patternsOf(doc, "range-connector"), ...patternsOf(doc, "amount-range-word")],
+  numberWords: numberWordsOf(doc),
+});
+
+const amountsOf = (text: string, doc: ProseDocument): InstallmentAmount[] => {
+  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 installmentTotalMismatch: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  return installmentTotalMismatches(text, amountsOf(text, doc), wordsOf(doc)).map((issue) => ({
+    rule: "installment-total-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/interest.ts

@@ -0,0 +1,43 @@
+// interest-mismatch: the reading half. Reads the document's lines outside tables and the lexicon interest-label, and
+// leaves the deciding to structure/interest.ts.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { linesOf } from "../structure/lines.ts";
+import { TABLE_ROW } from "../structure/runs.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { interestMismatches, type InterestPeriod, type InterestRole, type InterestWords, type PeriodWord } from "../structure/interest.ts";
+
+const RULE = "interest-mismatch";
+const ROLES: readonly string[] = ["interest", "base", "rate", "net"] satisfies readonly InterestRole[];
+const isRole = (group: string | undefined): group is InterestRole => group !== undefined && ROLES.includes(group);
+/** group rate-year: a rate for a year (年利, APR); interest-month: interest for a month (当月, for the month). */
+const PERIOD_GROUP = /^(rate|interest)-(year|month)$/u;
+
+const periodOf = (pattern: string, group: string | undefined): PeriodWord[] => {
+  const match = PERIOD_GROUP.exec(group ?? "");
+  const [of, period] = [match?.[1], match?.[2]];
+  return (of === "rate" || of === "interest") && (period === "year" || period === "month") ? [{ pattern, of, period: period satisfies InterestPeriod }] : [];
+};
+
+/** Lexicon interest-label: the words of the interest, the balance, the rate and after-tax interest, and the period words. */
+const interestWordsOf = (doc: ProseDocument): InterestWords => {
+  const entries = doc.lexicons["interest-label"] ?? [];
+  return {
+    labels: entries.flatMap((entry) => (isRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : [])),
+    periods: entries.flatMap((entry) => periodOf(entry.pattern, entry.group)),
+  };
+};
+
+export const interest: Detector = (doc): Finding[] => {
+  const words = interestWordsOf(doc);
+  if (words.labels.length === 0) return [];
+  const lines = linesOf(proseAndTablesOf(doc)).filter((line) => !TABLE_ROW.test(line.text) && line.text.trim() !== "");
+  return interestMismatches(lines, 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/lab-columns.ts

@@ -0,0 +1,9 @@
+// The heading words of a lab results table: lab-result-column, which every lab-table rule reads, then the words only one rule
+// reads (its own lexicon).
+import type { ProseDocument } from "../plugin.ts";
+import { isLabColumn, type LabColumnWord } from "../structure/lab-columns.ts";
+
+export const labColumnWordsOf = (doc: ProseDocument, ownLexicon: string): LabColumnWord[] =>
+  [...(doc.lexicons["lab-result-column"] ?? []), ...(doc.lexicons[ownLexicon] ?? [])].flatMap((entry) =>
+    isLabColumn(entry.group) ? [{ pattern: entry.pattern, column: entry.group }] : [],
+  );

package/src/detectors/labelled-age.ts

@@ -0,0 +1,154 @@
+// An age beside a labelled date of birth, compared with the exact age on a labelled reference date (elapsed-years-mismatch).
+import type { Detector, Finding, LexiconEntry, ProseDocument, Span, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { documentYearFindings } from "./derived-numbers.ts";
+import { calendarDateOf } from "../derived/date-arithmetic.ts";
+import {
+  ageMismatches,
+  ageVerdicts,
+  agesIn,
+  labelAfter,
+  labelBefore,
+  type AgeWords,
+  type LabelledBirth,
+  type LabelWord,
+  type LabelledReference,
+} from "../derived/age-on-date.ts";
+
+type DateNode = Span & { readonly value: string };
+
+const entriesOf = (doc: ProseDocument, id: string): readonly LexiconEntry[] => doc.lexicons[id] ?? [];
+
+const patternsAt = (doc: ProseDocument, id: string, position: "before" | "after"): string[] =>
+  entriesOf(doc, id)
+    .filter((entry) => (entry.position ?? "before") === position)
+    .map((entry) => entry.pattern);
+
+const ageWords = (doc: ProseDocument): AgeWords => ({
+  before: patternsAt(doc, "age-marker", "before"),
+  after: [...patternsAt(doc, "age-marker", "after"), ...entriesOf(doc, "age-unit").map((entry) => entry.pattern)],
+  skip: entriesOf(doc, "duration-year").map((entry) => entry.pattern),
+  approximateBefore: patternsAt(doc, "approximate-marker", "before"),
+  approximateAfter: patternsAt(doc, "approximate-marker", "after"),
+});
+
+const datesOf = (tree: StructureNode): DateNode[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ ...node.span, value: String(node.attrs["value"]) }] : []));
+
+const lineStartOf = (source: string, at: number): number => source.lastIndexOf("\n", at - 1) + 1;
+
+const lineEndOf = (source: string, at: number): number => {
+  const end = source.indexOf("\n", at);
+  return end === -1 ? source.length : end;
+};
+
+const isFullDate = (value: string): boolean => calendarDateOf(value)?.year !== undefined;
+
+/** A clause or bracket ends here: past a reference date, the age is read only up to the first of these. */
+const CLAUSE_END = /[)）\]］】。;；]/u;
+
+const blanked = (text: string, from: number, spans: readonly Span[]): string =>
+  spans.reduce((written, span) => [written.slice(0, span.start - from), " ".repeat(span.end - span.start), written.slice(span.end - from)].join(""), text);
+
+type AgeRegion = { readonly text: string; readonly passed: readonly LabelledReference[] };
+
+const referenceAt = (references: readonly LabelledReference[], date: DateNode): LabelledReference | undefined =>
+  references.find((reference) => reference.start === date.start);
+
+/** The reference dates right after a date of birth on its line, before the first date that is not one. */
+const passedReferences = (later: readonly DateNode[], references: readonly LabelledReference[]): LabelledReference[] => {
+  const stop = later.findIndex((date) => referenceAt(references, date) === undefined);
+  return later.slice(0, stop === -1 ? later.length : stop).flatMap((date) => referenceAt(references, date) ?? []);
+};
+
+/** Where the age beside a date of birth is written: up to the next date that is not a reference date, or the line end.
+ * Past a reference date ("（2026年9月30日現在、23歳）"), only to the end of its bracket or clause; its digits are blanked. */
+const ageRegionOf = (doc: ProseDocument, date: DateNode, dates: readonly DateNode[], references: readonly LabelledReference[]): AgeRegion => {
+  const lineEnd = lineEndOf(doc.source, date.end);
+  const later = dates.filter((other) => other.start >= date.end && other.start < lineEnd);
+  const passed = passedReferences(later, references);
+  const last = passed.at(-1);
+  const open = later[passed.length]?.start ?? lineEnd;
+  const clauseEnd = last === undefined ? -1 : doc.source.slice(last.end, open).search(CLAUSE_END);
+  const end = last === undefined || clauseEnd === -1 ? open : last.end + clauseEnd;
+  return { text: blanked(doc.source.slice(date.end, end), date.end, passed), passed };
+};
+
+/** The age after a labelled date of birth, in its region (ageRegionOf): one age, or none. */
+const birthOf = (doc: ProseDocument, date: DateNode, dates: readonly DateNode[], references: readonly LabelledReference[]): LabelledBirth[] => {
+  if (
+    !isFullDate(date.value) ||
+    labelBefore(doc.source.slice(lineStartOf(doc.source, date.start), date.start), entriesOf(doc, "birth-date-label")) === undefined
+  )
+    return [];
+  const { text: region, passed } = ageRegionOf(doc, date, dates, references);
+  const ages = agesIn(region, ageWords(doc));
+  const [age] = ages;
+  if (ages.length !== 1 || age === undefined) return [];
+  const lead = region.slice(0, age.start).toLowerCase();
+  const tail = region.slice(age.end).trimStart().toLowerCase();
+  const mark = entriesOf(doc, "age-time-mark").find((entry) => lead.includes(entry.pattern.toLowerCase()) || tail.startsWith(entry.pattern.toLowerCase()));
+  const group = mark?.group ?? (passed.length === 1 ? passed[0]?.group : undefined);
+  return [{ start: date.start, end: date.end, birth: date.value, age: { ...age, start: date.end + age.start, end: date.end + age.end }, group }];
+};
+
+const ownLabel = (doc: ProseDocument, date: DateNode): LabelWord | undefined => {
+  const labels = entriesOf(doc, "age-reference-label");
+  return (
+    labelBefore(doc.source.slice(lineStartOf(doc.source, date.start), date.start), labels, ageWords(doc)) ??
+    labelAfter(doc.source.slice(date.end, lineEndOf(doc.source, date.end)), labels)
+  );
+};
+
+/** Dates with a reference label. A later date on the same line without a label of its own takes the label before it
+ * ("Examination date: March 1, 2026 and March 3, 2026" is two examination dates, and the age is then undecided). */
+const referencesOf = (doc: ProseDocument, dates: readonly DateNode[]): LabelledReference[] => {
+  const labelled = dates.reduce<{ readonly line: number; readonly label: LabelWord | undefined; readonly found: LabelledReference[] }>(
+    (state, date) => {
+      const line = lineStartOf(doc.source, date.start);
+      const label = ownLabel(doc, date) ?? (line === state.line ? state.label : undefined);
+      if (label !== undefined && isFullDate(date.value))
+        state.found.push({ start: date.start, end: date.end, date: date.value, group: label.group ?? label.pattern });
+      return { line, label, found: state.found };
+    },
+    { line: -1, label: undefined, found: [] },
+  );
+  return labelled.found;
+};
+
+const recordsOf = (doc: ProseDocument, tree: StructureNode): { births: LabelledBirth[]; references: LabelledReference[] } => {
+  const dates = datesOf(tree);
+  const references = referencesOf(doc, dates);
+  return { births: dates.flatMap((date) => birthOf(doc, date, dates, references)), references };
+};
+
+/** Where the ages whose reference date was decided start: the year-only check stays silent on them. */
+const decidedAgeStarts = (doc: ProseDocument, tree: StructureNode): ReadonlySet<number> => {
+  const { births, references } = recordsOf(doc, tree);
+  return new Set(ageVerdicts(births, references).map((verdict) => verdict.birth.age.start));
+};
+
+const written = (doc: ProseDocument, span: Span): string => doc.source.slice(span.start, span.end);
+
+const labelledAgeFindings = (doc: ProseDocument, tree: StructureNode): Finding[] => {
+  const { births, references } = recordsOf(doc, tree);
+  return ageMismatches(births, references).map(({ birth, reference, expected }) => ({
+    rule: "elapsed-years-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, birth.age.start),
+    variant: "birth-date",
+    values: { written: written(doc, birth.age), birth: written(doc, birth), reference: written(doc, reference), expected, offset: birth.age.start },
+  }));
+};
+
+/** 起点の年から数えた年数が文書の日付と合わない。生年月日の横の年齢が、受診日などの満年齢と合わない。 */
+export const elapsedYearsMismatch: Detector = (doc) => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const decided = decidedAgeStarts(doc, tree);
+  const byDocumentYear = documentYearFindings(doc, tree).filter((finding) => !decided.has(Number(finding.values?.["offset"])));
+  return [...labelledAgeFindings(doc, tree), ...byDocumentYear];
+};

package/src/detectors/layout-code.ts

@@ -0,0 +1,174 @@
+// layout-code-mismatch: a listing's layout code (2LDK, "3 bedrooms") against the rooms the same listing names
+// (structure/layout-codes.ts). The code letters and counted words are layout-code's, the room names layout-room's, and the
+// field names layout-label's.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import {
+  foldWidth,
+  layoutSlip,
+  pairByScope,
+  parseBreakdown,
+  parseLayoutCode,
+  type Breakdown,
+  type LayoutCode,
+  type LayoutSlip,
+  type LayoutWords,
+  type LetterGroup,
+  type RoomGroup,
+} from "../structure/layout-codes.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+type LabelGroup = "code" | "breakdown" | "room-column";
+type Labels = ReadonlyMap<string, LabelGroup>;
+
+const LETTER_GROUPS: readonly LetterGroup[] = ["living", "dining", "kitchen", "storage", "one-room"];
+const ROOM_GROUPS: readonly RoomGroup[] = ["living", "dining", "kitchen", "room", "storage", "unclear"];
+const LABEL_GROUPS: readonly LabelGroup[] = ["code", "breakdown", "room-column"];
+
+const letterGroupOf = (group: string | undefined): LetterGroup | undefined => LETTER_GROUPS.find((known) => known === group);
+
+export const layoutWordsOf = (lexicons: ProseDocument["lexicons"]): LayoutWords => {
+  const code = lexicons["layout-code"] ?? [];
+  return {
+    letters: new Map(
+      code.flatMap((entry): [string, LetterGroup][] => {
+        const group = letterGroupOf(entry.group);
+        return group === undefined ? [] : [[entry.pattern, group]];
+      }),
+    ),
+    joiners: code.filter((entry) => entry.group === "joiner").map((entry) => entry.pattern),
+    counted: code.filter((entry) => entry.group === "counted").map((entry) => entry.pattern),
+    counters: code.filter((entry) => entry.group === "counter").map((entry) => entry.pattern),
+    rooms: (lexicons["layout-room"] ?? []).flatMap((entry) => {
+      const group = ROOM_GROUPS.find((known) => known === entry.group);
+      return group === undefined ? [] : [{ pattern: entry.pattern, group }];
+    }),
+  };
+};
+
+const labelKey = (label: string): string => foldWidth(withoutEdgeMarks(label)).toLowerCase().replace(/\s+/gu, " ");
+
+const labelsOf = (lexicons: ProseDocument["lexicons"]): Labels =>
+  new Map(
+    (lexicons["layout-label"] ?? []).flatMap((entry): [string, LabelGroup][] => {
+      const group = LABEL_GROUPS.find((known) => known === entry.group);
+      return group === undefined ? [] : [[labelKey(entry.pattern), group]];
+    }),
+  );
+
+/** A code found in the page, with the breakdown written right with it when there is one (a row, or 2LDK（洋室6帖・…）). */
+type PlacedCode = { readonly code: LayoutCode; readonly scope: number; readonly breakdown?: Breakdown | undefined };
+type PlacedBreakdown = { readonly breakdown: Breakdown; readonly scope: number };
+type Found = { readonly codes: PlacedCode[]; readonly breakdowns: PlacedBreakdown[] };
+const NOTHING: Found = { codes: [], breakdowns: [] };
+
+type Context = { readonly words: LayoutWords; readonly labels: Labels; readonly scopeOf: (offset: number) => number };
+
+const INLINE_BREAKDOWN = /^[^(（]*[(（]([^)）]+)[)）]/u;
+
+/** The breakdown written in brackets after the code, when it names a room. */
+const inlineBreakdown = (rest: string, words: LayoutWords): Breakdown | undefined => {
+  const inside = INLINE_BREAKDOWN.exec(rest)?.[1];
+  if (inside === undefined) return undefined;
+  const breakdown = parseBreakdown([inside], words);
+  return breakdown.rooms > 0 || breakdown.unclear ? breakdown : undefined;
+};
+
+const codeIn = (text: string, start: number, context: Context, breakdown?: Breakdown): PlacedCode[] => {
+  const found = parseLayoutCode(text, context.words);
+  if (found === undefined) return [];
+  const code = { ...found, start: start + found.start, end: start + found.end };
+  const written = breakdown ?? inlineBreakdown(text.slice(found.end), context.words);
+  return [{ code, scope: context.scopeOf(code.start), breakdown: written }];
+};
+
+const field = (group: LabelGroup | undefined, value: string, start: number, context: Context): Found => {
+  if (group === "code") return { codes: codeIn(value, start, context), breakdowns: [] };
+  if (group === "breakdown") return { codes: [], breakdowns: [{ breakdown: parseBreakdown([value], context.words), scope: context.scopeOf(start) }] };
+  return NOTHING;
+};
+
+const merged = (found: readonly Found[]): Found => ({
+  codes: found.flatMap((each) => each.codes),
+  breakdowns: found.flatMap((each) => each.breakdowns),
+});
+
+const groupOfCell = (cell: Cell | undefined, labels: Labels): LabelGroup | undefined => (cell === undefined ? undefined : labels.get(labelKey(cell.text)));
+
+/** A table with a layout column: one listing a row, with its breakdown column when the table has one. */
+const wideRows = (rows: readonly Cell[][], codeColumn: number, breakdownColumn: number, context: Context): Found => ({
+  codes: rows.flatMap((cells) => {
+    const code = cells[codeColumn];
+    const listed = cells[breakdownColumn];
+    const breakdown = listed === undefined ? undefined : parseBreakdown([listed.text], context.words);
+    return code === undefined ? [] : codeIn(code.text, code.start, context, breakdown);
+  }),
+  breakdowns: [],
+});
+
+const tableFound = (header: Line, rows: readonly Cell[][], context: Context): Found => {
+  const groups = cellsOf(header).map((cell) => groupOfCell(cell, context.labels));
+  const codeColumn = groups.indexOf("code");
+  if (codeColumn !== -1) return wideRows(rows, codeColumn, groups.indexOf("breakdown"), context);
+  if (groups[0] === "room-column") {
+    const breakdown = parseBreakdown(
+      rows.map((cells) => cells[0]?.text ?? ""),
+      context.words,
+    );
+    return { codes: [], breakdowns: [{ breakdown, scope: context.scopeOf(header.start) }] };
+  }
+  return merged(rows.map(([label, value]) => (value === undefined ? NOTHING : field(groupOfCell(label, context.labels), value.text, value.start, context))));
+};
+
+const tablesFound = (source: string, context: Context): Found =>
+  merged(tablesOf(linesOf(source)).map((table) => tableFound(table.header, table.rows.map(cellsOf), context)));
+
+const LIST_LEAD = /^\s*(?:(?:[-*+]|\d+[.)])\s+)?/u;
+const MAX_LABEL_LENGTH = 24;
+
+/** "間取り：2LDK", "- Rooms: Bedroom 1, Bedroom 2" outside tables: the name before the first colon, and the value after it. */
+const labelledLine = (line: Line, context: Context): Found => {
+  const colon = line.text.search(/[:：]/u);
+  if (colon === -1 || line.text.includes("|")) return NOTHING;
+  const label = line.text.slice(0, colon).replace(LIST_LEAD, "");
+  const rest = line.text.slice(colon + 1);
+  const value = rest.trimStart();
+  if (label.length > MAX_LABEL_LENGTH || value === "") return NOTHING;
+  return field(context.labels.get(labelKey(label)), value, line.start + colon + 1 + rest.length - value.length, context);
+};
+
+/** Code and markup are masked in prose, so a colon in code is not read. */
+const linesFound = (prose: string, context: Context): Found => merged(linesOf(prose).map((line) => labelledLine(line, context)));
+
+const scopeFinder =
+  (doc: ProseDocument) =>
+  (offset: number): number =>
+    doc.sections.findLastIndex((section) => section.span.start <= offset);
+
+const slipsOf = (found: Found): LayoutSlip[] => {
+  const direct = found.codes.flatMap((placed): [LayoutCode, Breakdown][] => (placed.breakdown === undefined ? [] : [[placed.code, placed.breakdown]]));
+  const pooled = found.codes.filter((placed) => placed.breakdown === undefined);
+  const paired = pairByScope(pooled, found.breakdowns).map(([placed, listed]): [LayoutCode, Breakdown] => [placed.code, listed.breakdown]);
+  return [...direct, ...paired].flatMap(([code, breakdown]) => layoutSlip(code, breakdown) ?? []);
+};
+
+export const layoutCode: Detector = (doc): Finding[] => {
+  const context: Context = { words: layoutWordsOf(doc.lexicons), labels: labelsOf(doc.lexicons), scopeOf: scopeFinder(doc) };
+  const found = merged([tablesFound(doc.source, context), linesFound(doc.prose ?? doc.source, context)]);
+  return slipsOf(found).map((slip) => ({
+    rule: "layout-code-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.code.start),
+    ...(slip.kind === "part" ? { variant: "part" } : {}),
+    values: {
+      code: slip.code.text,
+      stated: slip.code.rooms,
+      ...(slip.kind === "count" ? { listed: slip.listed } : { part: slip.entry }),
+      offset: slip.code.start,
+    },
+  }));
+};

package/src/detectors/line-amount.ts

@@ -1,10 +1,19 @@
 // line-amount-mismatch: the reading half. The column names come from the language's lexicons (quantity-column,
-// unit-price-column, line-amount-column), the units from rate-unit and per-unit-mark; the tables are read from the prose with its tables put back, so code is not.
+// unit-price-column, line-amount-column; pack-count-column and pack-price-column for a catalog's packs), the units from rate-unit, per-unit-mark and the measure lexicons (unit-volume, …); the tables are read from the prose with its tables put back, so code is not.
+// A product in an item cell's brackets is read with label-product-word, currency-notation and amount-multiplier.
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { measureUnitsOf } from "../facts/measure-units.ts";
+import { quantityWordsOf } from "./order-quantity.ts";
 import { lineAmountMismatches, type LineAmountWords } from "../structure/line-amount.ts";
 import type { UnitWord } from "../structure/line-amount-unit.ts";
+import type { StructureIssue } from "../structure/issues.ts";
 import { proseAndTablesOf } from "../table-text.ts";
+import { labelProductMismatches, type LabelProductWords } from "../structure/line-amount-label.ts";
+import { amountsIn, formsOf } from "./currency-notation.ts";
+import { scaleWordsOf } from "./amount-scale.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { pointsMismatches, type PointsRole, type PointsWords } from "../structure/line-amount-rate.ts";
+import { linesOf } from "../structure/lines.ts";
 
 const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
 
@@ -19,11 +28,57 @@ const wordsOf = (doc: ProseDocument): LineAmountWords => ({
   amount: patternsOf(doc, "line-amount-column"),
   units: unitWordsOf(doc, "rate-unit"),
   perUnitMarks: unitWordsOf(doc, "per-unit-mark"),
-  headerUnits: unitWordsOf(doc, "quantity-column", "unit-price-column"),
+  headerUnits: unitWordsOf(doc, "quantity-column", "unit-price-column", "line-amount-column"),
+  measureUnits: measureUnitsOf(doc).flatMap((unit) => (unit.before ? [] : [unit.pattern])),
+  orderRoles: quantityWordsOf(doc).columns,
+  packCount: patternsOf(doc, "pack-count-column"),
+  packPrice: patternsOf(doc, "pack-price-column"),
+  itemName: patternsOf(doc, "item-name-column"),
+  taxIncluded: patternsOf(doc, "tax-included-word"),
 });
 
+const groupOf = (doc: ProseDocument, lexicon: string, group: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => entry.group === group).map((entry) => entry.pattern);
+
+const labelWordsOf = (doc: ProseDocument): LabelProductWords => {
+  const [forms, scales] = [formsOf(doc), scaleWordsOf(doc).map((word) => word.word)];
+  return {
+    times: groupOf(doc, "label-product-word", "times"),
+    counts: groupOf(doc, "label-product-word", "count"),
+    isMoney: (text) => amountsIn(text, forms, scales).some((amount) => amount.written === text.trim()),
+  };
+};
+
+const POINTS_ROLES: readonly string[] = ["base", "rate", "earned"] satisfies readonly PointsRole[];
+const isPointsRole = (group: string | undefined): group is PointsRole => group !== undefined && POINTS_ROLES.includes(group);
+const HEADING = /^#{1,6}[ \t]/u;
+
+/** Lexicons points-earned-column (group base, rate or earned; a rate's weight is what a bare rate is per), points-unit, points-rate-joiner. */
+const pointsWordsOf = (doc: ProseDocument): PointsWords => ({
+  columns: (doc.lexicons["points-earned-column"] ?? []).flatMap((entry) =>
+    isPointsRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group, per: entry.weight }] : [],
+  ),
+  units: patternsOf(doc, "points-unit"),
+  joiners: patternsOf(doc, "points-rate-joiner"),
+});
+
+/** Where each heading of the source starts: the prose blanks headings, and a stated rate is read only in its table's section. */
+const headingStarts = (doc: ProseDocument): number[] =>
+  linesOf(doc.source)
+    .filter((line) => HEADING.test(line.text))
+    .map((line) => line.start);
+
+const mismatchesOf = (doc: ProseDocument): StructureIssue[] => {
+  const text = proseAndTablesOf(doc);
+  return [
+    ...lineAmountMismatches(text, wordsOf(doc)),
+    ...labelProductMismatches(text, labelWordsOf(doc)),
+    ...pointsMismatches(text, headingStarts(doc), pointsWordsOf(doc)),
+  ];
+};
+
 export const lineAmount: Detector = (doc): Finding[] =>
-  lineAmountMismatches(proseAndTablesOf(doc), wordsOf(doc)).map((issue) => ({
+  mismatchesOf(doc).map((issue) => ({
     rule: "line-amount-mismatch",
     severity: "error",
     line: 0,

package/src/detectors/measured-facts.ts

@@ -0,0 +1,20 @@
+import type { ProseDocument, StructureNode } from "../plugin.ts";
+import { nameSpans } from "../compare/proper-nouns.ts";
+import { overlapsAny, spanIndex } from "../compare/spans.ts";
+import { factValues, type FactValue } from "../facts/fact-values.ts";
+import { codeFences } from "./code-fences.ts";
+import { measuredValues, type Measured } from "../facts/measures.ts";
+import { measureUnitsOf } from "../facts/measure-units.ts";
+
+/** 文書の中の、単位の語彙表の単位が付いた量。コードの塊の中の量は、項目の値ではない。 */
+export const measuredOf = (doc: ProseDocument): Measured[] => {
+  const fences = codeFences(doc.source);
+  return measuredValues(doc.source, measureUnitsOf(doc)).filter((value) => !fences.some((fence) => fence.start <= value.start && value.end <= fence.end));
+};
+
+/** fact-conflict の値に、単位の付いた量を足す。量と重なる値（量の数だけを読んだもの）は量に置き換える。 */
+export const valuesWith = (tree: StructureNode, doc: ProseDocument, measured: readonly FactValue[]): FactValue[] => {
+  const taken = spanIndex(measured);
+  const others = factValues(tree, doc.source, nameSpans(doc)).filter((value) => !overlapsAny(taken, value));
+  return [...others, ...measured].toSorted((left, right) => left.start - right.start);
+};

package/src/detectors/meter-usage.ts

@@ -0,0 +1,49 @@
+// meter-usage-mismatch: the reading half. The names of the readings come from the language's meter-reading-label lexicon,
+// the units from meter-unit, the stated rollover and meter replacement from meter-event; the readings are read from the
+// prose with its tables put back, so code is not, and the document's headings split it into sections.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { lineNumberAt, linesOf } from "../structure/lines.ts";
+import { meterUsageMismatches, type MeterKind, type MeterUnitWord, type MeterWords } from "../structure/meter-usage.ts";
+import { meterGroups, type MeterLabel } from "../structure/meter-usage-read.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const KINDS: ReadonlySet<string> = new Set(["current", "previous", "usage", "multiplier"]);
+
+const isKind = (group: string | undefined): group is MeterKind => group !== undefined && KINDS.has(group);
+
+const labelsOf = (doc: ProseDocument): MeterLabel[] =>
+  (doc.lexicons["meter-reading-label"] ?? []).flatMap((entry) => (isKind(entry.group) ? [{ pattern: entry.pattern, kind: entry.group }] : []));
+
+const unitsOf = (doc: ProseDocument): MeterUnitWord[] =>
+  (doc.lexicons["meter-unit"] ?? []).flatMap((entry) => (entry.group === undefined ? [] : [{ pattern: entry.pattern, unit: entry.group }]));
+
+const eventsOf = (doc: ProseDocument, group: string): string[] =>
+  (doc.lexicons["meter-event"] ?? []).filter((entry) => entry.group === group).map((entry) => entry.pattern);
+
+const headingLinesOf = (doc: ProseDocument): number[] => {
+  const lines = linesOf(doc.source);
+  return (doc.markup?.headings ?? []).flatMap((heading) => lineNumberAt(lines, heading.start) ?? []);
+};
+
+export const meterUsage: Detector = (doc): Finding[] => {
+  const labels = labelsOf(doc);
+  if (labels.length === 0) return [];
+  const units = unitsOf(doc);
+  const words: MeterWords = {
+    units,
+    rollover: eventsOf(doc, "rollover"),
+    rolloverNegationAfter: eventsOf(doc, "rollover-negation-after"),
+    rolloverNegationBefore: eventsOf(doc, "rollover-negation-before"),
+    replaced: eventsOf(doc, "replaced"),
+  };
+  const groups = meterGroups(proseAndTablesOf(doc), headingLinesOf(doc), { labels, units });
+  return meterUsageMismatches(groups, words).map((issue) => ({
+    rule: "meter-usage-mismatch",
+    severity: "error",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/name-field.ts

@@ -0,0 +1,43 @@
+/** How many characters a line may add to the long name and still be a line that only names the party. */
+export const SLACK = 12;
+
+/** A field label on its own line, after a list marker (Attention:, 宛先：): short, and not a sentence. */
+const FIELD_LABEL = /^(?:[-*+]\s+)?[^:：。.]{1,20}[:：]\s*/u;
+/**
+ * What may follow the name in an address field: nothing, a comma and the next part (, Member Support), or a space and a part
+ * that does not go on in lower case (株式会社みなと 総務部). A particle or a verb (は支払う, shall pay) makes the line a sentence.
+ */
+const NEXT_PART = /^\.?(?:$|\s*[,、，]|\s+(?!\p{Ll}))/u;
+export const CLOSES_SENTENCE = /[.。!?！？]$/u;
+
+/** A field whose value is the name and a little more, not a sentence (Attention: Hibari Lab Inc., Member Support). */
+export const isNameField = (line: string, name: string): boolean => {
+  const label = FIELD_LABEL.exec(line);
+  const value = label === null ? "" : line.slice(label[0].length);
+  const rest = value.slice(name.length);
+  return value.startsWith(name) && NEXT_PART.test(rest) && [...rest].length <= SLACK * 2 && !CLOSES_SENTENCE.test(rest.slice(1));
+};
+
+/**
+ * After the name on a signature line, the parts of an address: each after a comma or a space, none in lower case, and no
+ * 、 (Hibari Lab Inc., Customer Support; 株式会社みなと 総務部). A lower-case word or a 、 goes on as a sentence (, as Supplier, shall pay).
+ */
+const ADDRESS_PARTS = /^\.?(?:,?\s+[^\s,、，\p{Ll}][^\s,、，]*)*$/u;
+
+/** A line with no label that is the name and the parts of an address: a signature (Hibari Lab Inc., Customer Support). */
+export const isSignatureLine = (line: string, name: string): boolean => {
+  const rest = line.slice(name.length);
+  return line.startsWith(name) && [...rest].length <= SLACK * 2 && ADDRESS_PARTS.test(rest);
+};
+
+const linesOf = (text: string): string[] => text.split(/\r?\n/u).map((line) => line.trim());
+
+/**
+ * The line from lineStart to lineEnd opens the closing block: a blank line (or nothing) before it, and no sentence after it to
+ * the end (a phone number, an address).
+ */
+export const opensClosingBlock = (source: string, lineStart: number, lineEnd: number): boolean => {
+  const before = linesOf(source.slice(0, lineStart)).slice(0, -1);
+  const after = linesOf(source.slice(lineEnd));
+  return (before.length === 0 || before.at(-1) === "") && after.every((line) => !CLOSES_SENTENCE.test(line));
+};