chaffjs 0.29.0 → 0.31.0

package/src/detectors/structure-tree.ts

@@ -6,9 +6,13 @@ 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";
 import { proseShareMismatches } from "../structure/percent-sum-prose.ts";
 import { isQuotedAlone } from "../quoted-span.ts";
@@ -183,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"),
@@ -197,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))];
 };
@@ -218,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),
@@ -227,11 +253,21 @@ const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
   weekdays: (doc.lexicons["weekday"] ?? []).map((entry) => entry.pattern),
 });
 
+/** その位置が、期間の語（period-label）で始まる行の、語より後ろにあるか。 */
+const labelledAt =
+  (doc: ProseDocument) =>
+  (offset: number): boolean => {
+    const lineStart = doc.source.lastIndexOf("\n", offset - 1) + 1;
+    const lineEnd = doc.source.indexOf("\n", offset);
+    const after = afterLabel(doc.source.slice(lineStart, lineEnd === -1 ? doc.source.length : lineEnd), patternsOf(doc, "period-label"));
+    return after !== undefined && offset >= lineStart + after;
+  };
+
 /** 期間の終わりが始まりより前。範囲の記号と語は言語パッケージの語彙表（range-connector、range-opener、range-closer）から取る。 */
 export const dateRangeReversed: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
   const dates = datedSpans(doc.structure);
-  return reversedRanges(doc.source, dates, rangeWordsOf(doc))
+  return reversedRanges(doc.source, dates, rangeWordsOf(doc), labelledAt(doc))
     .filter((issue) => {
       const start = dateAt(dates, issue.offset);
       return !quotedDates(doc, dates[start], dates[start + 1]);

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

@@ -3,11 +3,14 @@ import type { StructureIssue } from "../structure/issues.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
 import { clockTimes } from "../compare/clock-time.ts";
 import { secondsOf, type DateSpan, type Mark, type TimeSpan, type TimeWords } from "../structure/time-marks.ts";
-import { timeOrderBreaks } from "../structure/time-order.ts";
-import { arrivalsBeforeDeparture } from "../structure/leg-times.ts";
-import { quoteAt } from "./structure-tree.ts";
+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 { reversedTimeRanges } from "../structure/time-range.ts";
+import { quoteAt, rangeWordsOf } from "./structure-tree.ts";
 
-// 一日の予定の時刻の順番（time-order）と、発より前の着（arrival-before-departure）。時刻は compare/clock-time.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）から取る。
 
 const marksOf = (doc: ProseDocument, lexicon: string): Mark[] =>
@@ -29,13 +32,13 @@ const datesOf = (doc: ProseDocument): DateSpan[] =>
 
 const timesOf = (text: string): TimeSpan[] => clockTimes(text).map((time) => ({ start: time.start, end: time.end, seconds: secondsOf(time.key) }));
 
-type Finder = (source: string, times: readonly TimeSpan[], dates: readonly DateSpan[], words: TimeWords) => StructureIssue[];
+type Finder = (source: string, times: readonly TimeSpan[], dates: readonly DateSpan[], words: TimeWords, doc: ProseDocument) => StructureIssue[];
 
 /** 表と箇条書きを行のまま読むので、原文を渡す（doc.prose は表を覆う）。 */
 const detectorOf =
   (rule: string, find: Finder): Detector =>
   (doc): Finding[] =>
-    find(doc.source, timesOf(doc.source), datesOf(doc), timeWordsOf(doc)).map((issue) => ({
+    find(doc.source, timesOf(doc.source), datesOf(doc), timeWordsOf(doc), doc).map((issue) => ({
       rule,
       severity: "warning",
       line: 0,
@@ -47,3 +50,39 @@ 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;
+
+const patternsOf = (doc: ProseDocument, lexicon: string, weight?: number): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => weight === undefined || entry.weight === weight).map((entry) => entry.pattern);
+
+/** 時間と分の長さ（約10分、about 40 minutes）。単位は unit-time の重さ（秒）で時間と分に分ける。 */
+const travelLengthsOf = (doc: ProseDocument): TravelLength[] =>
+  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 travelWordsOf = (doc: ProseDocument): TravelWords => {
+  const marks = marksOf(doc, "travel-time-word");
+  return { cues: marks.filter((mark) => mark.group === "travel"), bounds: marks.filter((mark) => mark.group === "bound") };
+};
+
+export const connectionTimeShort: Detector = detectorOf("connection-time-short", (source, times, dates, words, doc) =>
+  shortConnections({
+    source,
+    times,
+    dates,
+    words,
+    travel: travelWordsOf(doc),
+    lengths: travelLengthsOf(doc),
+    arrivals: arrivalOffsets(source, times, dates, words),
+    days: scheduleDays(source, times, dates, words),
+  }),
+);

package/src/detectors/undefined-term.ts

@@ -6,6 +6,7 @@
 import { definedTerms } from "../structure/definition-use.ts";
 import { prefixGroupsOf, prefixVariants } from "../structure/term-prefix.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { capitalisedTerms, namedWords, readableText, setApartSpans, type Defined } from "./capitalised-term.ts";
 import type { Detector, Finding, ProseDocument, Token } from "../plugin.ts";
 
 export type UndefinedTerm = { readonly offset: number; readonly term: string };
@@ -89,15 +90,31 @@ const findingOf = (doc: ProseDocument, use: UndefinedTerm): Finding => ({
   values: { term: use.term, offset: use.offset },
 });
 
+const NAME_LISTS = ["proper-name-word", "place-region", "calendar-name", "month-name", "company-form", "party-role"] as const;
+
+/** Capitalised terms, for a language whose package lists the words that join one name (name-joiner); Japanese has none. */
+const capitalisedUses = (doc: ProseDocument, sentences: readonly (readonly Token[])[], defined: readonly Defined[]): UndefinedTerm[] => {
+  if (doc.lexicons["name-joiner"] === undefined) return [];
+  const words = {
+    names: NAME_LISTS.flatMap((id) => patternsOf(doc, id)),
+    divisions: patternsOf(doc, "numbered-division"),
+    joiners: patternsOf(doc, "name-joiner"),
+  };
+  const marked = [...(doc.markup?.headings ?? []), ...doc.links, ...setApartSpans(doc.source)];
+  return capitalisedTerms({ source: doc.source, readable: readableText(doc.source), sentences, defined, named: namedWords(doc.source), marked, words });
+};
+
 export const undefinedTerm: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
   const prefixEntries = doc.lexicons["defined-term-prefix"] ?? [];
   const sentences = doc.sentences.map((sentence) => sentence.tokens ?? []);
-  const defined = definedTerms(doc.structure).map((term) => term.term);
-  return undefinedTerms(doc.source, sentences, defined, {
+  const definitions = definedTerms(doc.structure);
+  const defined = definitions.map((term) => term.term);
+  const prefixed = undefinedTerms(doc.source, sentences, defined, {
     prefixes: prefixEntries.map((entry) => entry.pattern),
     prefixGroups: prefixGroupsOf(prefixEntries),
     selfNouns: [...patternsOf(doc, "self-reference-noun"), ...patternsOf(doc, "document-kind")],
     isQuoted: (term) => QUOTE_PAIRS.some(([open, close]) => doc.source.includes(`${open}${term}${close}`)),
-  }).map((use) => findingOf(doc, use));
+  });
+  return [...prefixed, ...capitalisedUses(doc, sentences, definitions)].map((use) => findingOf(doc, use));
 };

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

@@ -25,6 +25,7 @@ import { cutTextSpans } from "./span-cut.ts";
 import { markdownFigures } from "./text-figures.ts";
 import { documentMarkup } from "./markup.ts";
 import { BARE_URL } from "./bare-url.ts";
+import { lazyCells, tableCellsOf } from "./table-cells.ts";
 import type { BulletList, LanguageAdapter, Markup, Paragraph, ProseDocument, Sentence, Span, StructureNode, DocumentProfile } from "./plugin.ts";
 
 /**
@@ -355,7 +356,7 @@ const documentOf = (path: string, source: string, adapter: LanguageAdapter, team
     markdown,
     profile,
   }));
-  return {
+  const doc: ProseDocument = {
     path,
     source,
     language: adapter.id,
@@ -381,7 +382,9 @@ const documentOf = (path: string, source: string, adapter: LanguageAdapter, team
     get markup(): Markup {
       return documentMarkup(root, source, markdown, [...emailLayout.replyQuotes, ...syntax]);
     },
+    tableCells: lazyCells(() => tableCellsOf(doc, (text) => adapter.segment(text))),
   };
+  return doc;
 };
 
 /**

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