chaffjs 0.30.0 → 0.32.0

package/src/detectors/unit-consistency.ts

@@ -1,55 +1,67 @@
 import type { Detector, Finding, 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 { labelledFacts } from "../facts/labelled-facts.ts";
 import { tableFacts } from "../facts/table-facts.ts";
 import { scopedFacts } from "../facts/fact-scope.ts";
-import { measuredValues, type Measured, type MeasureUnit } from "../facts/measures.ts";
+import type { Measured } from "../facts/measures.ts";
 import { unitConflicts } from "../facts/unit-conflicts.ts";
+import { unitPairs } from "../facts/unit-equivalents.ts";
+import { itemConflicts } from "../facts/item-amounts.ts";
 import { factWordsOf } from "./fact-consistency.ts";
+import { measuredOf, valuesWith } from "./measured-facts.ts";
 import { quoteAt } from "./structure-tree.ts";
 
-/** 量の種類ごとの語彙表。weight が基準の単位への倍率で、同じ単位を二度書けば倍率が二つ（GB の 10^9 と 2^30）。 */
-const DIMENSIONS = ["unit-length", "unit-mass", "unit-time", "unit-volume", "unit-data"] as const;
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
-const unitsOf = (doc: ProseDocument): MeasureUnit[] =>
-  DIMENSIONS.flatMap((dimension) => {
-    const factors = new Map<string, number[]>();
-    (doc.lexicons[dimension] ?? []).forEach((entry) => {
-      if (entry.weight !== undefined) factors.set(entry.pattern, [...(factors.get(entry.pattern) ?? []), entry.weight]);
-    });
-    return [...factors.entries()].map(([pattern, weights]) => ({ pattern, dimension, factors: weights }));
-  });
+type Mismatch = { readonly label: string; readonly measured: Measured; readonly other: Measured; readonly variant?: string };
 
-/** fact-conflict と同じ値に、単位の付いた量を足す。量と重なる値（量の数だけを読んだもの）は量に置き換える。 */
-const valuesWith = (tree: StructureNode, doc: ProseDocument, measured: readonly Measured[]): 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);
+/** 同じ範囲の同じ名前の量（「距離：5 km」と「距離：3000 m」）。名前と量のあいだの目安の語（「重さは約1.2kg」）は外して読む。 */
+const labelledMismatches = (doc: ProseDocument, tree: StructureNode, measured: readonly Measured[]): Mismatch[] => {
+  const byStart = new Map(measured.map((value) => [value.start, value]));
+  const values = valuesWith(tree, doc, measured);
+  const words = { ...factWordsOf(doc), valueLeads: patternsOf(doc, "measure-value-lead") };
+  const facts = [...labelledFacts(doc.source, values, words), ...tableFacts(doc.source, values)];
+  const scoped = scopedFacts(facts, tree, doc.source, []);
+  return unitConflicts(scoped, (fact) => byStart.get(fact.value.start), doc.source).map((conflict) => ({
+    label: conflict.fact.label,
+    measured: conflict.measured,
+    other: conflict.other,
+  }));
 };
 
-/** 同じ名前の量を、違う単位で書いて、換算すると合わない。 */
+const mismatchesOf = (doc: ProseDocument, tree: StructureNode, measured: readonly Measured[]): Mismatch[] => [
+  ...labelledMismatches(doc, tree, measured),
+  ...unitPairs(doc.source, measured, patternsOf(doc, "unit-equivalent-hedge")).map((pair) => ({ label: "", ...pair, variant: "bracket" })),
+  ...itemConflicts(doc.source, measured, { links: patternsOf(doc, "unit-item-link"), determiners: patternsOf(doc, "fact-label-drop") }).map((conflict) => ({
+    label: conflict.name,
+    measured: conflict.measured,
+    other: conflict.other,
+    variant: "item",
+  })),
+];
+
+const findingOf = (doc: ProseDocument, mismatch: Mismatch): Finding => ({
+  rule: "unit-mismatch",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, mismatch.measured.start),
+  values: {
+    label: mismatch.label,
+    value: doc.source.slice(mismatch.measured.start, mismatch.measured.end),
+    other: doc.source.slice(mismatch.other.start, mismatch.other.end),
+    offset: mismatch.measured.start,
+  },
+  ...(mismatch.variant === undefined ? {} : { variant: mismatch.variant }),
+});
+
+/** 同じ量を、違う単位で書いて、換算すると合わない。一つの量は一度だけ言う。 */
 export const unitMismatch: Detector = (doc): Finding[] => {
   const tree = doc.structure;
   if (tree === undefined) return [];
-  const measured = measuredValues(doc.source, unitsOf(doc));
+  const measured = measuredOf(doc);
   if (measured.length === 0) return [];
-  const byStart = new Map(measured.map((value) => [value.start, value]));
-  const values = valuesWith(tree, doc, measured);
-  const facts = [...labelledFacts(doc.source, values, factWordsOf(doc)), ...tableFacts(doc.source, values)];
-  const scoped = scopedFacts(facts, tree, doc.source, []);
-  return unitConflicts(scoped, (fact) => byStart.get(fact.value.start)).map((conflict) => ({
-    rule: "unit-mismatch",
-    severity: "warning",
-    line: 0,
-    column: 0,
-    quote: quoteAt(doc.source, conflict.measured.start),
-    values: {
-      label: conflict.fact.label,
-      value: doc.source.slice(conflict.measured.start, conflict.measured.end),
-      other: doc.source.slice(conflict.other.start, conflict.other.end),
-      offset: conflict.measured.start,
-    },
-  }));
+  const mismatches = mismatchesOf(doc, tree, measured);
+  return mismatches
+    .filter((mismatch, index) => mismatches.findIndex((other) => other.measured.start === mismatch.measured.start) === index)
+    .map((mismatch) => findingOf(doc, mismatch));
 };

package/src/detectors/unlisted-items.ts

@@ -0,0 +1,72 @@
+// unlisted-item-used: a numbered step uses a thing the document's list of what is needed does not name
+// (structure/unlisted-items.ts). The words are the language package's item-list-heading, item-use, item-amount,
+// item-at-hand and enumeration-joiner.
+import type { Detector, Finding, ProseDocument, Token } from "../plugin.ts";
+import { itemLists, unlistedItems, type ItemStep, type ItemToken, type ItemWords, type UseGroup, type UseMarker } from "../structure/unlisted-items.ts";
+import { quoteAround } from "./quote-around.ts";
+
+const USE_GROUPS: readonly UseGroup[] = ["object", "place", "instrument"];
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
+
+const markersOf = (doc: ProseDocument): UseMarker[] =>
+  (doc.lexicons["item-use"] ?? []).flatMap((entry) => {
+    const group = USE_GROUPS.find((use) => use === entry.group);
+    return group === undefined || entry.position === undefined ? [] : [{ word: entry.pattern, group, position: entry.position }];
+  });
+
+const wordsOf = (doc: ProseDocument): ItemWords => ({
+  ingredientHeadings: patternsOf(doc, "item-list-heading", "ingredient"),
+  toolHeadings: patternsOf(doc, "item-list-heading", "tool"),
+  markers: markersOf(doc),
+  verbs: Object.fromEntries(USE_GROUPS.map((group) => [group, patternsOf(doc, "item-use", `${group}-verb`)])),
+  negations: patternsOf(doc, "item-use", "negation"),
+  actions: patternsOf(doc, "item-use", "action"),
+  joiners: patternsOf(doc, "enumeration-joiner"),
+  partitives: patternsOf(doc, "item-use", "partitive"),
+  amounts: patternsOf(doc, "item-amount"),
+  atHand: patternsOf(doc, "item-at-hand"),
+});
+
+const NUMBERED_LINE = /^[ \t]*\d+[.)．）][ \t]+/gmu;
+
+const itemToken = (token: Token): ItemToken => ({
+  surface: token.surface,
+  pos: token.pos,
+  lemma: token.lemma ?? token.surface,
+  start: token.span.start,
+  end: token.span.end,
+});
+
+/** Each numbered line, with the words of the sentences that start on it. */
+const stepsOf = (doc: ProseDocument): ItemStep[] =>
+  [...doc.source.matchAll(NUMBERED_LINE)].map((match) => {
+    const lineEnd = doc.source.indexOf("\n", match.index);
+    const end = lineEnd === -1 ? doc.source.length : lineEnd;
+    const sentences = doc.sentences.filter((sentence) => sentence.span.start >= match.index && sentence.span.start < end);
+    return { start: match.index, tokens: sentences.flatMap((sentence) => (sentence.tokens ?? []).map(itemToken)) };
+  });
+
+const headingsOf = (doc: ProseDocument): string[] => doc.sections.filter((section) => section.depth > 0).map((section) => section.heading);
+
+/** Every word the tagger read, in the text and in the table cells (a list of ingredients is often a table). */
+const wordsWritten = (doc: ProseDocument): ItemToken[] => [
+  ...doc.sentences.flatMap((sentence) => (sentence.tokens ?? []).map(itemToken)),
+  ...(doc.tableCells?.() ?? []).flatMap((cell) => (cell.tokens ?? []).map(itemToken)),
+];
+
+export const unlistedItemUsed: Detector = (doc): Finding[] => {
+  const words = wordsOf(doc);
+  const headings = headingsOf(doc);
+  // Reading every table cell is not free; a document without a list heading needs none of it.
+  if (itemLists(headings, words).length === 0) return [];
+  return unlistedItems({ source: doc.source, words: wordsWritten(doc) }, headings, stepsOf(doc), words).map((item) => ({
+    rule: "unlisted-item-used",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(doc.source, item.offset, item.offset + item.item.length),
+    values: { item: item.item, list: item.list, offset: item.offset },
+  }));
+};

package/src/detectors/use-count-words.ts

@@ -0,0 +1,32 @@
+import type { ProseDocument } from "../plugin.ts";
+import type { Mark } from "../structure/time-marks.ts";
+import type { CountWord, LimitWords, PeriodCountWords, PeriodWord } from "../derived/period-counts.ts";
+
+// 期間あたりの回数の語（use-count-word）と、語で書いた数（count-number）。product-exceeds-maximum と interval-count-mismatch が読む。
+
+const entriesOf = (doc: ProseDocument, lexicon: string, group?: string) =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group);
+
+export const marksOf = (doc: ProseDocument, lexicon: string, group?: string): Mark[] =>
+  entriesOf(doc, lexicon, group).map((entry) => ({ pattern: entry.pattern, position: entry.position, group: entry.group }));
+
+const periodsOf = (doc: ProseDocument): PeriodWord[] =>
+  entriesOf(doc, "use-count-word", "period").map((entry) => ({ pattern: entry.pattern, position: entry.position, hours: entry.weight ?? 0 }));
+
+/** one, two, …: the position in count-number is the value. once, twice: the weight in use-count-word. */
+const numberWordsOf = (doc: ProseDocument): CountWord[] => [
+  ...entriesOf(doc, "count-number").map((entry, index) => ({ pattern: entry.pattern, value: index + 1, alone: false })),
+  ...entriesOf(doc, "use-count-word", "alone").map((entry) => ({ pattern: entry.pattern, value: entry.weight ?? 0, alone: true })),
+];
+
+export const periodCountWordsOf = (doc: ProseDocument): PeriodCountWords => ({
+  periods: periodsOf(doc),
+  counters: entriesOf(doc, "use-count-word", "counter").map((entry) => entry.pattern),
+  numberWords: numberWordsOf(doc),
+});
+
+/** The limit words, the ones that need a negation before them ("more than"), and the negations. */
+export const limitWordsOf = (doc: ProseDocument): LimitWords => ({
+  limits: [...marksOf(doc, "use-count-word", "limit"), ...marksOf(doc, "use-count-word", "limit-negated")],
+  negations: marksOf(doc, "use-count-word", "negation").map((mark) => mark.pattern),
+});

package/src/detectors/use-interval.ts

@@ -0,0 +1,51 @@
+import type { Detector, Finding, ProseDocument, Span } from "../plugin.ts";
+import { intervalCountMismatches, type IntervalMismatch, type IntervalWords } from "../derived/use-interval.ts";
+import { paragraphsOf } from "../derived/period-counts.ts";
+import { timeLengths, type TimeLength } from "../derived/time-lengths.ts";
+import { limitWordsOf, marksOf, periodCountWordsOf } from "./use-count-words.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+// 使う間隔の下限と期間あたりの回数の上限が両立しない、または表の回数と合わない（interval-count-mismatch）。
+// 語は use-count-word と use-interval-word、長さの単位は unit-time から取る。
+
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_MINUTE = 60;
+
+const patternsOf = (doc: ProseDocument, lexicon: string, weight?: number): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => weight === undefined || entry.weight === weight).map((entry) => entry.pattern);
+
+const lengthsOf = (doc: ProseDocument): TimeLength[] =>
+  timeLengths(doc.source, {
+    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"),
+  });
+
+const wordsOf = (doc: ProseDocument): IntervalWords => ({
+  ...periodCountWordsOf(doc),
+  ...limitWordsOf(doc),
+  minimum: marksOf(doc, "use-interval-word", "minimum"),
+  cues: marksOf(doc, "use-interval-word", "cue").map((mark) => mark.pattern),
+  columns: (doc.lexicons["use-interval-word"] ?? [])
+    .filter((entry) => entry.group === "column")
+    .map((entry) => ({ pattern: entry.pattern, hours: entry.weight ?? 0 })),
+});
+
+const written = (doc: ProseDocument, span: Span): string => doc.source.slice(span.start, span.end);
+
+const valuesOf = (doc: ProseDocument, mismatch: IntervalMismatch): Record<string, string | number> =>
+  mismatch.kind === "interval"
+    ? { count: written(doc, mismatch.count), interval: written(doc, mismatch.interval), needed: mismatch.neededHours, hours: mismatch.count.hours }
+    : { count: written(doc, mismatch.count), column: mismatch.column, table: mismatch.tableCount };
+
+export const intervalCountMismatch: Detector = (doc): Finding[] =>
+  intervalCountMismatches(doc.source, paragraphsOf(doc.source), lengthsOf(doc), wordsOf(doc)).map((mismatch) => ({
+    rule: "interval-count-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, mismatch.count.start),
+    values: { ...valuesOf(doc, mismatch), offset: mismatch.count.start },
+    ...(mismatch.kind === "table" ? { variant: "table" } : {}),
+  }));

package/src/detectors/use-maximum.ts

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

package/src/detectors/variance.ts

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

package/src/detectors/walk-time-distance-mismatch.ts

@@ -0,0 +1,45 @@
+// A walking time that does not match the stated distance at the document's walking speed (walk-time-distance-mismatch).
+// The words come from the language package (walk-word, walk-rate, unit-length, unit-time, unit-equivalent-hedge); the speed
+// used when the document states none comes from its profile (profiles/listing.yaml).
+import { walkTimeMismatches, type WalkMark, type WalkRate, type WalkWords } from "../structure/walk-time.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+const marksOf = (doc: ProseDocument, lexicon: string, group?: string): WalkMark[] =>
+  (doc.lexicons[lexicon] ?? [])
+    .filter((entry) => group === undefined || entry.group === group)
+    .map((entry) => ({ pattern: entry.pattern, position: entry.position, weight: entry.weight }));
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] => marksOf(doc, lexicon, group).map((mark) => mark.pattern);
+
+const walkWords = (doc: ProseDocument): WalkWords => ({
+  walks: marksOf(doc, "walk-word", "walk"),
+  gaps: patternsOf(doc, "walk-word", "gap"),
+  bounds: marksOf(doc, "walk-word", "bound"),
+  ranges: patternsOf(doc, "walk-word", "range"),
+  fillers: patternsOf(doc, "walk-word", "filler"),
+  lengths: marksOf(doc, "unit-length"),
+  times: marksOf(doc, "unit-time"),
+  hedges: patternsOf(doc, "unit-equivalent-hedge"),
+  perTimes: marksOf(doc, "walk-rate", "per"),
+  roundUps: patternsOf(doc, "walk-rate", "round-up"),
+  notRoundUps: patternsOf(doc, "walk-rate", "not-round-up"),
+});
+
+/** The speed the document's profile walks at when the document states none (a real-estate listing: 80 m a minute, rounded up). */
+const profileRate = (doc: ProseDocument): WalkRate | undefined => {
+  const rate = doc.profile?.walkRate;
+  return rate === undefined ? undefined : { metresPerMinute: rate.metresPerMinute, rounding: rate.roundUp ? "up" : "any" };
+};
+
+/** The prose with its tables put back, so code is not read; offsets are the source's. */
+export const walkTimeDistanceMismatch: Detector = (doc): Finding[] =>
+  walkTimeMismatches(proseAndTablesOf(doc), walkWords(doc), profileRate(doc)).map((issue) => ({
+    rule: "walk-time-distance-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));

package/src/detectors/whole-count-findings.ts

@@ -0,0 +1,48 @@
+import type { Finding, ProseDocument } from "../plugin.ts";
+import { wholeCountConflicts, type CountWord, type CountWords, type MarkWord, type WholeCountConflict } from "../facts/whole-counts.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const countWordsAt = (doc: ProseDocument, id: string): CountWord[] =>
+  (doc.lexicons[id] ?? []).map((entry): CountWord => ({ pattern: entry.pattern, group: entry.group ?? "" }));
+
+const markWordsAt = (doc: ProseDocument, id: string): MarkWord[] =>
+  (doc.lexicons[id] ?? []).map((entry): MarkWord => ({ pattern: entry.pattern, position: entry.position ?? "before" }));
+
+const countWordsOf = (doc: ProseDocument): CountWords => ({
+  columns: countWordsAt(doc, "fact-count-column"),
+  counters: countWordsAt(doc, "fact-count-counter"),
+  separateRows: patternsOf(doc, "fact-count-separate-rows"),
+  wholeMarks: markWordsAt(doc, "fact-count-whole"),
+  notWhole: markWordsAt(doc, "fact-count-not-whole"),
+  restating: patternsOf(doc, "fact-count-restating"),
+  totalLabels: (doc.lexicons["total-label"] ?? []).filter((entry) => entry.group !== "subtotal").map((entry) => entry.pattern),
+  subtotalLabels: (doc.lexicons["total-label"] ?? []).filter((entry) => entry.group === "subtotal").map((entry) => entry.pattern),
+});
+
+const wholeCountFinding =
+  (doc: ProseDocument) =>
+  (conflict: WholeCountConflict): Finding => {
+    const value = doc.source.slice(conflict.start, conflict.end);
+    return {
+      rule: "fact-conflict",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, conflict.start),
+      variant: conflict.table.sum ? "whole-count-sum" : "whole-count",
+      values: {
+        label: conflict.heading,
+        value,
+        other: `${String(conflict.table.count)}${value.slice(conflict.written.length)}`,
+        offset: conflict.start,
+      },
+    };
+  };
+
+/** 文が全体として書いた数（合計4枚）と、表のその数を数える列の全体の数。 */
+export const wholeCountFindings = (doc: ProseDocument): Finding[] => {
+  const sentences = doc.sentences.map((sentence) => ({ ...sentence.span, text: doc.source.slice(sentence.span.start, sentence.span.end) }));
+  return wholeCountConflicts(doc.source, sentences, countWordsOf(doc)).map(wholeCountFinding(doc));
+};

package/src/detectors/working-hours-findings.ts

@@ -0,0 +1,100 @@
+import type { Finding, ProseDocument, Span } from "../plugin.ts";
+import { timeLengths, type LengthWords, type TimeLength } from "../derived/time-lengths.ts";
+import { clockRanges, workingHoursMismatches, type WorkingHoursMismatch, type WorkingHoursWords } from "../derived/working-hours.ts";
+import { timesheetHoursMismatches, type TimesheetMismatch } from "../derived/timesheet-hours.ts";
+import { computedLength, type ComputedLength } from "../derived/hours-and-minutes.ts";
+import { cellMinutes, showsOvernightWork } from "../structure/shift-times.ts";
+import { clockTimes } from "../compare/clock-time.ts";
+import { secondsOf, type TimeSpan } from "../structure/time-marks.ts";
+import { marksOf } from "./use-count-words.ts";
+
+// duration-mismatch の勤務時間: 文の中の「9:00〜17:30、休憩1時間、実働8時間」と、勤務表の行（始業 | 終業 | 休憩 | 実働）。
+
+/** duration-mismatch の指摘を作る関数（derived-numbers.ts の finding）。 */
+type FindingOf = (doc: ProseDocument, offset: number, values: Record<string, string | number>, variant?: string) => Finding;
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const sentencesOf = (doc: ProseDocument): Span[] => doc.sentences.map((sentence) => sentence.span);
+
+const written = (doc: ProseDocument, span: Span): string => doc.source.slice(span.start, span.end);
+
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_MINUTE = 60;
+
+/** The hour and minute units of unit-time, told apart by their weight in seconds. */
+const unitsWeighing = (doc: ProseDocument, seconds: number): string[] =>
+  (doc.lexicons["unit-time"] ?? []).filter((entry) => entry.weight === seconds).map((entry) => entry.pattern);
+
+const lengthWords = (doc: ProseDocument): LengthWords => ({
+  hourUnits: unitsWeighing(doc, SECONDS_PER_HOUR),
+  minuteUnits: unitsWeighing(doc, SECONDS_PER_MINUTE),
+  halves: patternsOf(doc, "length-half"),
+  numberWords: patternsOf(doc, "count-number"),
+});
+
+export const lengthsOf = (doc: ProseDocument, text: string): TimeLength[] => timeLengths(text, lengthWords(doc));
+
+/** The variant suffix for each way of writing the computed length: 4時間15分 takes none, 7時間 "-hours", 45分 "-minutes". */
+const SHAPE_SUFFIX: Readonly<Record<ComputedLength["shape"], string>> = { "hours-minutes": "", hours: "-hours", minutes: "-minutes" };
+
+const workingHoursFinding = (doc: ProseDocument, mismatch: WorkingHoursMismatch, finding: FindingOf): Finding[] => {
+  const length = computedLength(mismatch.expected, mismatch.total.minutes);
+  if (length === undefined) return [];
+  const values = {
+    start: written(doc, mismatch.start),
+    end: written(doc, mismatch.end),
+    break: written(doc, mismatch.break),
+    total: written(doc, mismatch.total),
+    ...length.values,
+  };
+  return [finding(doc, mismatch.total.start, values, `working-hours${SHAPE_SUFFIX[length.shape]}`)];
+};
+
+const workingHoursWords = (doc: ProseDocument): WorkingHoursWords => ({
+  joiners: patternsOf(doc, "clock-range-joiner"),
+  dayShifts: marksOf(doc, "day-shift-mark"),
+  breaks: marksOf(doc, "working-hours-break"),
+  totals: marksOf(doc, "working-hours-total"),
+  approximate: marksOf(doc, "approximate-marker"),
+});
+
+const timesIn = (text: string): TimeSpan[] => clockTimes(text).map((time) => ({ start: time.start, end: time.end, seconds: secondsOf(time.key) }));
+
+/** 始業から終業まで、休憩を除いた時間が、書いた実働と合わない。 */
+const workingHoursOf = (doc: ProseDocument, text: string, finding: FindingOf): Finding[] =>
+  workingHoursMismatches(text, doc.source, sentencesOf(doc), timesIn(text), lengthsOf(doc, text), workingHoursWords(doc)).flatMap((mismatch) =>
+    workingHoursFinding(doc, mismatch, finding),
+  );
+
+const timesheetFinding = (doc: ProseDocument, mismatch: TimesheetMismatch, finding: FindingOf): Finding[] => {
+  const times = { start: written(doc, mismatch.start), end: written(doc, mismatch.end), break: written(doc, mismatch.break) };
+  if (mismatch.total === undefined) return [finding(doc, mismatch.break.start, times, "working-hours-break-longer")];
+  const length = computedLength(mismatch.expected, mismatch.total.minutes);
+  if (length === undefined) return [];
+  return [
+    finding(doc, mismatch.total.start, { ...times, total: written(doc, mismatch.total), ...length.values }, `working-hours${SHAPE_SUFFIX[length.shape]}`),
+  ];
+};
+
+/** 勤務表の行（始業 | 終業 | 休憩 | 実働）の実働が、終わりから始まりと休憩を引いた長さと合わない。 */
+const timesheetHoursOf = (doc: ProseDocument, text: string, finding: FindingOf): Finding[] => {
+  const times = timesIn(text);
+  const words = workingHoursWords(doc);
+  const timeWords = { legs: [], columns: [], dayShifts: words.dayShifts, zones: [] };
+  return timesheetHoursMismatches({
+    text,
+    times,
+    ranges: clockRanges(text, times, words),
+    columns: marksOf(doc, "shift-column"),
+    overnight: showsOvernightWork(text, times, marksOf(doc, "overnight-work-mark"), timeWords),
+    lengthOf: (cell, bareHours) => cellMinutes(cell, lengthsOf(doc, cell), bareHours),
+  }).flatMap((mismatch) => timesheetFinding(doc, mismatch, finding));
+};
+
+/** 文の中の勤務時間と勤務表の行。同じ実働を両方から読んでも一度だけ言う。 */
+export const workingHoursFindings = (doc: ProseDocument, text: string, finding: FindingOf): Finding[] => {
+  const inline = workingHoursOf(doc, text, finding);
+  const said = new Set(inline.map((found) => found.values?.["offset"]));
+  return [...inline, ...timesheetHoursOf(doc, text, finding).filter((found) => !said.has(found.values?.["offset"]))];
+};