chaffjs 0.30.0 → 0.31.0

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,
+      },
+    },
+  ];
+};

package/src/detectors/structure-tree.ts

@@ -6,8 +6,11 @@ import { weekdayMismatches } from "../structure/weekday.ts";
 import { documentDateOf } from "./document-date.ts";
 import { dateOrderBreaks } from "../structure/date-order.ts";
 import { totalMismatches, type Amount } from "../structure/total.ts";
+import { isTotalLine } from "../structure/total-line.ts";
 import { proseTotalMismatches } from "../structure/prose-total.ts";
 import { countedAmounts, type SummedCounter } from "../structure/counted-amounts.ts";
+import { measuredAmounts, type MeasureMarks, type SummedMeasure } from "../structure/measured-amounts.ts";
+import { measureUnitsOf } from "../facts/measure-units.ts";
 import { rangeFrameOf, reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
 import { afterLabel } from "../structure/stated-period.ts";
 import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
@@ -184,11 +187,33 @@ const summableAmountsOf = (doc: ProseDocument, tree: NonNullable<ProseDocument["
   return [...known, ...countedAmounts(doc.source, summedCountersOf(doc), known)].toSorted((left, right) => left.offset - right.offset);
 };
 
-/** 合計の行と内訳の行、文の中の合計と内訳。同じ金額は一度だけ言う。 */
+/** 合計の行で足す量の種類。換算の倍率は語彙表の weight。 */
+const SUMMED_DIMENSIONS = ["unit-mass", "unit-volume", "unit-length"] as const;
+
+/** 足す単位。零点のずれた単位（°F）は足せないので除く。 */
+const summedMeasuresOf = (doc: ProseDocument): SummedMeasure[] =>
+  measureUnitsOf(doc).filter((unit) => unit.zero === 0 && SUMMED_DIMENSIONS.some((dimension) => dimension === unit.dimension));
+
+const positionedOf = (doc: ProseDocument, lexicon: string, position: "before" | "after"): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => (entry.position ?? "before") === position).map((entry) => entry.pattern);
+
+const measureMarksOf = (doc: ProseDocument): MeasureMarks => ({
+  roughBefore: positionedOf(doc, "approximate-marker", "before"),
+  roughAfter: positionedOf(doc, "approximate-marker", "after"),
+  connectors: patternsOf(doc, "range-connector"),
+  perMarks: patternsOf(doc, "measure-per-mark"),
+});
+
+/** 表と箇条書きの合計で足す数量。金額と助数詞の数に、単位の付いた量（300 mg、0.5 g）を加える。 */
+const lineAmountsOf = (doc: ProseDocument, amounts: readonly Amount[]): Amount[] =>
+  [...amounts, ...measuredAmounts(doc.source, summedMeasuresOf(doc), measureMarksOf(doc), amounts)].toSorted((left, right) => left.offset - right.offset);
+
+/** 合計の行と内訳の行、文の中の合計と内訳。同じ金額は一度だけ言う。単位の付いた量は、表と箇条書きの合計だけで足す。 */
 const totalIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["structure"]>): StructureIssue[] => {
   const amounts = summableAmountsOf(doc, tree);
-  const lines = totalMismatches(doc.source, amounts, patternsOf(doc, "total-label"));
-  const words = {
+  const words = { labels: patternsOf(doc, "total-label"), qualifiers: doc.lexicons["total-label-qualifier"] ?? [] };
+  const lines = totalMismatches(doc.source, lineAmountsOf(doc, amounts), (text) => isTotalLine(text, words));
+  const phrases = {
     totals: patternsOf(doc, "total-phrase"),
     breakdowns: patternsOf(doc, "breakdown-phrase"),
     discounts: patternsOf(doc, "discount-word"),
@@ -198,7 +223,7 @@ const totalIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["struct
     doc.source,
     doc.sentences.map((sentence) => sentence.span),
     amounts,
-    words,
+    phrases,
   );
   return [...lines, ...prose.filter((issue) => !lines.some((line) => line.offset === issue.offset))];
 };
@@ -219,7 +244,7 @@ export const totalMismatch: Detector = (doc): Finding[] =>
         values: { ...issue.values, offset: issue.offset },
       }));
 
-const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
+export const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
   connectors: (doc.lexicons["range-connector"] ?? []).map((entry) => entry.pattern),
   openers: (doc.lexicons["range-opener"] ?? []).map((entry) => entry.pattern),
   closers: (doc.lexicons["range-closer"] ?? []).map((entry) => entry.pattern),

package/src/detectors/structure.ts

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

package/src/detectors/technical-docs.ts

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

package/src/detectors/time-order.ts

@@ -7,7 +7,8 @@ import { scheduleDays, timeOrderBreaks } from "../structure/time-order.ts";
 import { arrivalOffsets, arrivalsBeforeDeparture } from "../structure/leg-times.ts";
 import { shortConnections, type TravelLength, type TravelWords } from "../structure/connection-times.ts";
 import { timeLengths } from "../derived/time-lengths.ts";
-import { quoteAt } from "./structure-tree.ts";
+import { reversedTimeRanges } from "../structure/time-range.ts";
+import { quoteAt, rangeWordsOf } from "./structure-tree.ts";
 
 // 一日の予定の時刻の順番（time-order）、発より前の着（arrival-before-departure）、移動の時間より短い乗り継ぎ（connection-time-short）。時刻は compare/clock-time.ts が読み、
 // 発着・翌日・時間帯の語は言語パッケージの語彙表（leg-mark、leg-column、day-shift-mark、time-zone、local-time-mark）から取る。
@@ -49,6 +50,9 @@ const detectorOf =
 
 export const timeOrder: Detector = detectorOf("time-order", timeOrderBreaks);
 export const arrivalBeforeDeparture: Detector = detectorOf("arrival-before-departure", arrivalsBeforeDeparture);
+export const timeRangeReversed: Detector = detectorOf("time-range-reversed", (source, times, _dates, words, doc) =>
+  reversedTimeRanges(source, times, rangeWordsOf(doc), words),
+);
 
 const SECONDS_PER_HOUR = 3600;
 const SECONDS_PER_MINUTE = 60;

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/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/facts/approximate-tolerance.ts

@@ -0,0 +1,19 @@
+import type { Measured, Tolerance } from "./measures.ts";
+
+const HALF = 0.5;
+const DECIMAL_BASE = 10;
+
+/** 目安の量（約1.2kg）が言える幅を、基準の単位で。書いた最後の桁の半分（約1.2kg は 1.15〜1.25 kg）。 */
+const writtenHalfStep = (value: Measured): number => {
+  const step = HALF * DECIMAL_BASE ** -value.decimals;
+  return step * Math.max(...value.factors);
+};
+
+/**
+ * 目安と書いた量を含む二つを比べるときの、合うとみなす差。目安の量は書いた桁までしか言っていないので、その桁の半分までの差は合う。
+ * 量の種類ごとの差（tolerance）のほうが広ければ、そちら。
+ */
+export const approximateTolerance = (tolerance: Tolerance, approximate: readonly Measured[]): Tolerance => ({
+  relative: tolerance.relative,
+  absolute: Math.max(tolerance.absolute, ...approximate.map(writtenHalfStep)),
+});

package/src/facts/item-amounts.ts

@@ -0,0 +1,94 @@
+import { linesOf, type Line } from "../structure/lines.ts";
+import { sameMeasure, sameUnit, type Measured } from "./measures.ts";
+import { cellsOf, tablesOf, type Cell } from "./table-facts.ts";
+import { withoutEdgeMarks } from "./trim-marks.ts";
+import { toleranceOf } from "./unit-tolerance.ts";
+
+/**
+ * 表に量を書いた品物（材料の表の「しょうゆ｜大さじ1」）を、本文で違う単位の量と一緒に書いた所（しょうゆ30ml、30 ml of soy sauce）。
+ * 表の量は、行の最初の量（人数ごとの列があれば、手順が従う最初の列）。本文の量が表の量より多いときだけ言う。本文の名前は、量のすぐ前（空白一つまで）か、つなぐ語（の、of）と
+ * 冠詞（the）を挟んで量の後ろ。名前は語の切れ目で始まり終わる（「濃口しょうゆ」の しょうゆ は切れ目で始まるが、「強力粉」の 力粉 は始まらない）。
+ */
+export type ItemConflict = { readonly name: string; readonly measured: Measured; readonly other: Measured };
+
+export type ItemWords = { readonly links: readonly string[]; readonly determiners: readonly string[] };
+
+type ItemAmount = { readonly name: string; readonly key: string; readonly measured: Measured };
+
+const LETTER = /\p{L}/u;
+const SCRIPTS = [/\p{Script=Hiragana}/u, /[\p{Script=Katakana}ー]/u, /\p{Script=Han}/u, /\p{Script=Latin}/u];
+const NAME_WINDOW = 80;
+
+const keyOf = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+const scriptOf = (char: string): number => SCRIPTS.findIndex((script) => script.test(char));
+
+/** 二つの字の間が語の切れ目か。字でない側があるか、字の種類（仮名、漢字、英字）が変わる所。英字どうしは続いている。 */
+const isBoundary = (left: string, right: string): boolean =>
+  left === "" || right === "" || !LETTER.test(left) || !LETTER.test(right) || scriptOf(left) !== scriptOf(right);
+
+const cellValue = (cell: Cell, source: string, measured: readonly Measured[]): Measured | undefined =>
+  measured.find((value) => value.start >= cell.start && value.end <= cell.end && source.slice(value.start, value.end) === withoutEdgeMarks(cell.text));
+
+/** 表の行の見出しと、その行の最初の量。同じ名前の行が二つあれば最初の行。 */
+const tableAmounts = (source: string, rows: readonly Line[], measured: readonly Measured[]): ItemAmount[] => {
+  const amounts = rows.flatMap((row): ItemAmount[] => {
+    const [first, ...rest] = cellsOf(row);
+    const name = first === undefined ? "" : withoutEdgeMarks(first.text);
+    const value = rest.map((cell) => cellValue(cell, source, measured)).find((found) => found !== undefined);
+    if (first === undefined || value === undefined || !LETTER.test(name) || cellValue(first, source, measured) !== undefined) return [];
+    return [{ name, key: keyOf(name), measured: value }];
+  });
+  return amounts.filter((amount, index) => amounts.findIndex((other) => other.key === amount.key) === index);
+};
+
+/** 量のすぐ前に名前があるか（しょうゆ大さじ1、soy sauce 30 ml）。 */
+const namedBefore = (source: string, value: Measured, key: string): boolean => {
+  const end = source.charAt(value.start - 1) === " " ? value.start - 1 : value.start;
+  const head = keyOf(source.slice(Math.max(0, end - NAME_WINDOW), end));
+  return head.endsWith(key) && isBoundary(head.charAt(head.length - key.length - 1), key.charAt(0));
+};
+
+const skipSpace = (text: string): string => (text.startsWith(" ") ? text.slice(1) : text);
+
+/** 頭の語を一つ落とす。英字の語は、後ろに空白が要る（of は offer の頭ではない）。 */
+const dropWord = (text: string, words: readonly string[]): string | undefined => {
+  const word = words.map(keyOf).find((candidate) => text.startsWith(candidate) && isBoundary(candidate.slice(-1), text.charAt(candidate.length)));
+  return word === undefined ? undefined : skipSpace(text.slice(word.length));
+};
+
+/** つなぐ語を挟んで、量の後ろに名前があるか（30mlのしょうゆ、30 ml of the soy sauce）。 */
+const namedAfter = (source: string, value: Measured, key: string, words: ItemWords): boolean => {
+  const linked = dropWord(skipSpace(keyOf(source.slice(value.end, value.end + NAME_WINDOW))), words.links);
+  if (linked === undefined) return false;
+  const rest = dropWord(linked, words.determiners) ?? linked;
+  return rest.startsWith(key) && isBoundary(key.slice(-1), rest.charAt(key.length));
+};
+
+/** 本文の量が、表の量をどう換算しても超えるか。表より少ない量は、その一部を使う所（牛乳の半分を先に）かもしれない。 */
+const exceeds = (value: Measured, listed: Measured): boolean =>
+  value.factors.every((a) => listed.factors.every((b) => (value.amount - value.zero) * a > (listed.amount - listed.zero) * b));
+
+const inTable = (value: Measured, rows: readonly Line[]): boolean => rows.some((row) => value.start >= row.start && value.end <= row.start + row.text.length);
+
+/** 本文の量のうち、表の同じ品物の量と単位が違い、換算すると合わないもの。 */
+export const itemConflicts = (source: string, measured: readonly Measured[], words: ItemWords): ItemConflict[] => {
+  const rows = tablesOf(linesOf(source)).flatMap((table) => [table.header, ...table.rows]);
+  const amounts = tableAmounts(source, rows, measured);
+  if (amounts.length === 0) return [];
+  return measured
+    .filter((value) => !inTable(value, rows))
+    .flatMap((value): ItemConflict[] => {
+      const item = amounts.find(
+        ({ key, measured: listed }) => listed.dimension === value.dimension && (namedBefore(source, value, key) || namedAfter(source, value, key, words)),
+      );
+      if (
+        item === undefined ||
+        sameUnit(item.measured, value) ||
+        sameMeasure(item.measured, value, toleranceOf(value.dimension)) ||
+        !exceeds(value, item.measured)
+      )
+        return [];
+      return [{ name: item.name, measured: value, other: item.measured }];
+    });
+};