chaffjs 0.29.0 → 0.31.0

package/src/detectors/quantity-range.ts

@@ -0,0 +1,47 @@
+// quantity-range-reversed: a range of measured quantities whose upper end is below its lower end (5–2 kg, 30〜10 cm,
+// 40〜-10℃), decided by structure/amount-range.ts as amount-range-reversed is. The quantities are read with the unit
+// lexicons (unit-length, unit-mass, …); the joints are range-connector, range-opener, range-closer and quantity-range-word;
+// quantity-change-word (its lead group: a word right before the range) and quantity-bound-label say what makes a pair a
+// change and what labels a bound.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { measuredValues } from "../facts/measures.ts";
+import { measureUnitsOf } from "../facts/measure-units.ts";
+import { reversedAmountRanges, type AmountRangeWords } from "../structure/amount-range.ts";
+import { quantityRangeEnds, unledRanges } from "../structure/quantity-range.ts";
+import { AMOUNT } from "./currency-notation.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAround } from "./quote-around.ts";
+
+/** A bare end may carry a minus sign (-10〜-40℃); a hyphen right after a digit or a letter is a range mark (5-10 kg). */
+const SIGNED_NUMBER = `(?:[-−－](?=[0-9０-９]))?${AMOUNT}`;
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
+
+const ungroupedOf = (doc: ProseDocument, lexicon: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => entry.group === undefined).map((entry) => entry.pattern);
+
+const wordsOf = (doc: ProseDocument): AmountRangeWords => ({
+  connectors: [...patternsOf(doc, "range-connector"), ...patternsOf(doc, "quantity-range-word")],
+  openers: patternsOf(doc, "range-opener"),
+  closers: patternsOf(doc, "range-closer"),
+  changes: ungroupedOf(doc, "quantity-change-word"),
+  lowers: patternsOf(doc, "quantity-bound-label", "lower"),
+  uppers: patternsOf(doc, "quantity-bound-label", "upper"),
+  links: patternsOf(doc, "quantity-bound-label", "link"),
+  scales: [],
+  number: SIGNED_NUMBER,
+});
+
+export const quantityRange: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  const reversed = reversedAmountRanges(text, quantityRangeEnds(text, measuredValues(text, measureUnitsOf(doc))), wordsOf(doc));
+  return unledRanges(text, reversed, patternsOf(doc, "quantity-change-word", "lead")).map((issue) => ({
+    rule: "quantity-range-reversed",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/range-band.ts

@@ -0,0 +1,125 @@
+// range-band-mismatch: neighbouring bands of one table column or one list that overlap or leave a gap (structure/range-bands.ts).
+// The words that bound a band are range-band-word's, the units range-band-unit's, and the column headings that say what bare
+// numbers count range-band-heading's.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { linesOf } from "../structure/lines.ts";
+import {
+  bandSlips,
+  headingOf,
+  parseBand,
+  runKindOf,
+  type BandMarker,
+  type BandSlip,
+  type BandWords,
+  type PlacedBand,
+  type UnitKind,
+} from "../structure/range-bands.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const MARKER_GROUPS: Readonly<Record<string, Pick<BandMarker, "side" | "kind">>> = {
+  "lower-inclusive": { side: "low", kind: "inclusive" },
+  "lower-exclusive": { side: "low", kind: "exclusive" },
+  "upper-inclusive": { side: "high", kind: "inclusive" },
+  "upper-exclusive": { side: "high", kind: "exclusive" },
+};
+
+const isUnitKind = (group: string | undefined): group is UnitKind => group === "integer" || group === "continuous";
+
+export const bandWordsOf = (lexicons: ProseDocument["lexicons"]): BandWords => {
+  const words = lexicons["range-band-word"] ?? [];
+  const patterns = (group: string): string[] => words.filter((entry) => entry.group === group).map((entry) => entry.pattern);
+  return {
+    connectors: patterns("connector"),
+    openers: words.filter((entry) => entry.group === "connector" && entry.position === "before").map((entry) => entry.pattern),
+    leads: patterns("lead"),
+    markers: words.flatMap((entry) => {
+      const marker = MARKER_GROUPS[entry.group ?? ""];
+      return marker === undefined ? [] : [{ pattern: entry.pattern, ...marker, position: entry.position ?? "after" }];
+    }),
+    units: (lexicons["range-band-unit"] ?? []).flatMap((entry) =>
+      isUnitKind(entry.group) ? [{ pattern: entry.pattern, kind: entry.group, position: entry.position ?? "after" }] : [],
+    ),
+    headings: (lexicons["range-band-heading"] ?? []).flatMap((entry) => (isUnitKind(entry.group) ? [{ pattern: entry.pattern, kind: entry.group }] : [])),
+  };
+};
+
+type Slot = { readonly text: string; readonly start: number; readonly end: number };
+
+/** Runs of consecutive slots that each state a band. A slot that is not one (合計, a blank) ends the run. */
+const bandRuns = (slots: readonly (Slot | undefined)[], words: BandWords): PlacedBand[][] =>
+  slots
+    .reduce<PlacedBand[][]>(
+      (runs, slot) => {
+        const band = slot === undefined ? undefined : parseBand(slot.text, words);
+        if (slot === undefined || band === undefined) return [...runs, []];
+        const last = runs.at(-1) ?? [];
+        return [...runs.slice(0, -1), [...last, { band, start: slot.start, end: slot.end, text: slot.text.trim() }]];
+      },
+      [[]],
+    )
+    .filter((run) => run.length > 1);
+
+const slipsOfRuns = (runs: readonly PlacedBand[][], heading: ReturnType<typeof headingOf>, words: BandWords): BandSlip[] =>
+  runs.flatMap((run) => {
+    const kind = runKindOf(
+      run.map((placed) => placed.band),
+      heading,
+      words,
+    );
+    return kind === undefined ? [] : bandSlips(run, kind);
+  });
+
+const trimmedSlot = (text: string, start: number): Slot => {
+  const lead = text.length - text.trimStart().length;
+  return { text: text.trim(), start: start + lead, end: start + lead + text.trim().length };
+};
+
+const tableSlips = (source: string, words: BandWords): BandSlip[] =>
+  tablesOf(linesOf(source)).flatMap((table) => {
+    const headings = cellsOf(table.header);
+    const rows = table.rows.map(cellsOf);
+    return headings.flatMap((heading, column) =>
+      slipsOfRuns(
+        bandRuns(
+          rows.map((cells) => {
+            const cell = cells[column];
+            return cell === undefined ? undefined : trimmedSlot(cell.text, cell.start);
+          }),
+          words,
+        ),
+        headingOf(heading.text, words),
+        words,
+      ),
+    );
+  });
+
+const LIST_MARKER = /^\s*(?:[-*+]|\d+[.)])\s+/u;
+/** Where the band at the head of a list item ends: a colon, a comma, a bracket, or a dash set off by spaces. */
+const ITEM_HEAD_END = /[:：、,，(（]|\s[-–—]\s|\t/u;
+
+const listSlips = (doc: ProseDocument, words: BandWords): BandSlip[] =>
+  doc.lists.flatMap((list) => {
+    const heads = list.itemSpans.map((span): Slot | undefined => {
+      const item = doc.source.slice(span.start, span.end).split("\n")[0] ?? "";
+      const marker = LIST_MARKER.exec(item)?.[0];
+      if (marker === undefined) return undefined;
+      const body = item.slice(marker.length);
+      const end = ITEM_HEAD_END.exec(body)?.index ?? body.length;
+      return trimmedSlot(body.slice(0, end), span.start + marker.length);
+    });
+    return slipsOfRuns(bandRuns(heads, words), undefined, words);
+  });
+
+export const rangeBand: Detector = (doc): Finding[] => {
+  const words = bandWordsOf(doc.lexicons);
+  return [...tableSlips(doc.source, words), ...listSlips(doc, words)].map((slip) => ({
+    rule: "range-band-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.later.start),
+    ...(slip.kind === "gap" ? { variant: "gap" } : {}),
+    values: { earlier: slip.earlier.text, later: slip.later.text, offset: slip.later.start },
+  }));
+};

package/src/detectors/registry/capacity-runtime-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { capacityRuntime } from "../capacity-runtime.ts";
+
+export const detector: Detector = capacityRuntime;

package/src/detectors/registry/connection-time-short.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { connectionTimeShort } from "../time-order.ts";
+
+export const detector: Detector = connectionTimeShort;

package/src/detectors/registry/contact-variant.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { contactVariant } from "../contact-variant.ts";
+
+export const detector: Detector = contactVariant;

package/src/detectors/registry/count-over-capacity.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { countOverCapacity } from "../count-over-capacity.ts";
+
+export const detector: Detector = countOverCapacity;

package/src/detectors/registry/date-stamp-order.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { dateStampOrder } from "../date-stamp-order.ts";
+
+export const detector: Detector = dateStampOrder;

package/src/detectors/registry/duration-product-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { durationProductMismatch } from "../derived-numbers.ts";
+
+export const detector: Detector = durationProductMismatch;

package/src/detectors/registry/event-deadline.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { eventDeadline } from "../event-deadline.ts";
+
+export const detector: Detector = eventDeadline;

package/src/detectors/registry/interval-count-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { intervalCountMismatch } from "../use-interval.ts";
+
+export const detector: Detector = intervalCountMismatch;

package/src/detectors/registry/layout-code-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { layoutCode } from "../layout-code.ts";
+
+export const detector: Detector = layoutCode;

package/src/detectors/registry/party-order.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { partyOrder } from "../party-order.ts";
+
+export const detector: Detector = partyOrder;

package/src/detectors/registry/quantity-range.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { quantityRange } from "../quantity-range.ts";
+
+export const detector: Detector = quantityRange;

package/src/detectors/registry/range-band-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { rangeBand } from "../range-band.ts";
+
+export const detector: Detector = rangeBand;

package/src/detectors/registry/rent-multiple-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { rentMultipleMismatch } from "../rent-multiple-mismatch.ts";
+
+export const detector: Detector = rentMultipleMismatch;

package/src/detectors/registry/requirement-lists.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { requirementLists } from "../requirement-lists.ts";
+
+export const detector: Detector = requirementLists;

package/src/detectors/registry/return-type.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { returnType } from "../return-type.ts";
+
+export const detector: Detector = returnType;

package/src/detectors/registry/scaled-quantity-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { scaledQuantityMismatch } from "../scaled-quantity.ts";
+
+export const detector: Detector = scaledQuantityMismatch;

package/src/detectors/registry/step-time-sum-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { stepTimeSumMismatch } from "../step-time-sum.ts";
+
+export const detector: Detector = stepTimeSumMismatch;

package/src/detectors/registry/time-range-reversed.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { timeRangeReversed } from "../time-order.ts";
+
+export const detector: Detector = timeRangeReversed;

package/src/detectors/registry/unlisted-item-used.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { unlistedItemUsed } from "../unlisted-items.ts";
+
+export const detector: Detector = unlistedItemUsed;

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

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { walkTimeDistanceMismatch } from "../walk-time-distance-mismatch.ts";
+
+export const detector: Detector = walkTimeDistanceMismatch;

package/src/detectors/rent-multiple-mismatch.ts

@@ -0,0 +1,56 @@
+// rent-multiple-mismatch: a deposit or key money given in months of rent beside an amount that is not that many months of
+// the rent (structure/rent-multiple.ts). The amounts are currency-notation's, read with amount-multiplier's words of scale;
+// the labels are rent-label and rent-multiple-label, the words rent-multiple-word, the counts number-word (digit), and a
+// range of rent is joined by range-connector or amount-range-word.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { rentMultipleMismatches, type RentAmount, type RentMultipleWords } from "../structure/rent-multiple.ts";
+import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
+import { amountsIn, formsOf } from "./currency-notation.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAround } from "./quote-around.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
+
+const numberWordsOf = (doc: ProseDocument): RentMultipleWords["numberWords"] =>
+  (doc.lexicons["number-word"] ?? []).flatMap((entry) =>
+    entry.group === "digit" && entry.weight !== undefined ? [{ word: entry.pattern, value: entry.weight }] : [],
+  );
+
+const wordsOf = (doc: ProseDocument): RentMultipleWords => ({
+  rents: patternsOf(doc, "rent-label", "rent"),
+  fees: patternsOf(doc, "rent-label", "fee"),
+  multiples: patternsOf(doc, "rent-multiple-label"),
+  months: patternsOf(doc, "rent-multiple-word", "month"),
+  links: patternsOf(doc, "rent-multiple-word", "link"),
+  periods: patternsOf(doc, "rent-multiple-word", "period"),
+  skips: patternsOf(doc, "rent-multiple-word", "skip"),
+  connectors: [...patternsOf(doc, "range-connector"), ...patternsOf(doc, "amount-range-word")],
+  numberWords: numberWordsOf(doc),
+});
+
+const amountsOf = (text: string, doc: ProseDocument): RentAmount[] => {
+  const scales = scaleWordsOf(doc);
+  return amountsIn(
+    text,
+    formsOf(doc),
+    scales.map((scale) => scale.word),
+  ).flatMap((amount) => {
+    const read = scaledAmountOf(text, amount, scales);
+    return read === undefined
+      ? []
+      : [{ offset: read.offset, end: amount.offset + amount.written.length, currency: read.currency, value: read.value, scale: read.unit }];
+  });
+};
+
+export const rentMultipleMismatch: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  return rentMultipleMismatches(text, amountsOf(text, doc), wordsOf(doc)).map((issue) => ({
+    rule: "rent-multiple-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/requirement-lists.ts

@@ -0,0 +1,65 @@
+// required-listed-as-preferred: the same skill under a required heading or label and again under a preferred one
+// (structure/requirement-lists.ts). The headings and labels are requirement-heading's; the length of experience is read
+// with requirement-length-unit, requirement-length-word and number-word; requirement-item-ending ends an item.
+import type { Detector, Finding, ProseDocument, Span } from "../plugin.ts";
+import { requiredListedAsPreferred, type RequirementBlock, type RequirementWords, type ValuedWord } from "../structure/requirement-lists.ts";
+import { quoteAround } from "./quote-around.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
+
+const valuedOf = (doc: ProseDocument, lexicon: string, group?: string): ValuedWord[] =>
+  (doc.lexicons[lexicon] ?? []).flatMap((entry) =>
+    entry.weight === undefined || (group !== undefined && entry.group !== group) ? [] : [{ word: entry.pattern, value: entry.weight }],
+  );
+
+const wordsOf = (doc: ProseDocument): RequirementWords => ({
+  required: patternsOf(doc, "requirement-heading", "required"),
+  preferred: patternsOf(doc, "requirement-heading", "preferred"),
+  units: valuedOf(doc, "requirement-length-unit"),
+  before: patternsOf(doc, "requirement-length-word", "before"),
+  after: patternsOf(doc, "requirement-length-word", "after"),
+  numbers: valuedOf(doc, "number-word", "digit"),
+  endings: patternsOf(doc, "requirement-item-ending"),
+});
+
+const LIST_MARKER = /^\s*(?:[-*+・•]|\d+[.)．）])\s+(?:\[[ xX]\]\s+)?/u;
+
+const headingsOf = (doc: ProseDocument): RequirementBlock[] =>
+  doc.sections
+    .filter((section) => section.depth > 0)
+    .map((section) => ({ kind: "heading", depth: section.depth, text: section.heading, offset: section.span.start }));
+
+/** An item's own lines, joined, without its marker: the lines it wraps onto, up to a nested item. */
+const itemText = (written: string): string => {
+  const [first = "", ...rest] = written.split("\n");
+  const nested = rest.findIndex((line) => LIST_MARKER.test(line));
+  return [first.replace(LIST_MARKER, ""), ...(nested === -1 ? rest : rest.slice(0, nested))].map((line) => line.trim()).join(" ");
+};
+
+const itemsOf = (doc: ProseDocument): RequirementBlock[] =>
+  doc.lists.flatMap((list) => list.itemSpans.map((span) => ({ kind: "item", text: itemText(doc.source.slice(span.start, span.end)), offset: span.start })));
+
+const inside = (offset: number, spans: readonly Span[]): boolean => spans.some((span) => offset >= span.start && offset < span.end);
+
+/** The lines outside lists, with code, headings and emphasis marks blanked out: the places a label (必須：) stands alone. */
+const linesOf = (doc: ProseDocument): RequirementBlock[] => {
+  const prose = doc.prose ?? doc.source;
+  const starts = [0, ...[...prose.matchAll(/\n/gu)].map((match) => match.index + 1)];
+  return starts.flatMap((start) => {
+    const line = prose.slice(start, prose.indexOf("\n", start) === -1 ? prose.length : prose.indexOf("\n", start));
+    return line.trim() === "" || inside(start, doc.listSpans) ? [] : [{ kind: "line", text: line, offset: start }];
+  });
+};
+
+export const requirementLists: Detector = (doc): Finding[] => {
+  const blocks = [...headingsOf(doc), ...linesOf(doc), ...itemsOf(doc)].toSorted((left, right) => left.offset - right.offset);
+  return requiredListedAsPreferred(blocks, wordsOf(doc)).map((issue) => ({
+    rule: "required-listed-as-preferred",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/return-type.ts

@@ -0,0 +1,30 @@
+// return-type-mismatch: one function's return type stated two ways on a page, the signature against a "Returns:" line, a
+// table's return column or a sentence (return-type.ts). The words come from the return-label, return-verb, return-subject,
+// return-type-word, return-clause and return-item lexicons.
+import { quoteAt } from "./structure-tree.ts";
+import { returnTypeClashes, type ReturnWords } from "../return-type.ts";
+import type { Detector, Finding, Lexicon } from "../plugin.ts";
+
+const patterns = (lexicon: Lexicon | undefined): string[] => (lexicon ?? []).map((entry) => entry.pattern);
+
+const kindsOf = (lexicon: Lexicon | undefined): Map<string, string> =>
+  new Map((lexicon ?? []).flatMap((entry): [string, string][] => (entry.group === undefined ? [] : [[entry.pattern, entry.group]])));
+
+const wordsOf = (lexicons: Readonly<Record<string, Lexicon>>): ReturnWords => ({
+  labels: patterns(lexicons["return-label"]),
+  verbs: patterns(lexicons["return-verb"]),
+  subjects: patterns(lexicons["return-subject"]),
+  kinds: kindsOf(lexicons["return-type-word"]),
+  clauses: patterns(lexicons["return-clause"]),
+  items: patterns(lexicons["return-item"]),
+});
+
+export const returnType: Detector = (doc): Finding[] =>
+  returnTypeClashes(doc.source, wordsOf(doc.lexicons)).map((clash) => ({
+    rule: "return-type-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, clash.offset),
+    values: { function: clash.fn, stated: clash.stated, signature: clash.signature, offset: clash.offset },
+  }));

package/src/detectors/scaled-quantity.ts

@@ -0,0 +1,49 @@
+// One row of a servings table (4人分 / 8人分, Serves 4 / Serves 8) that does not scale by the columns' ratio while the other rows
+// do. The column marks, the amounts left to the cook and the spellings of one unit come from the language packages.
+import { scaleSlips, type ScaleWords } from "../structure/scaled-quantities.ts";
+import type { MeasureUnit } from "../facts/measures.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+const DIMENSIONS = ["unit-mass", "unit-volume"] as const;
+
+const measuresOf = (doc: ProseDocument): MeasureUnit[] =>
+  DIMENSIONS.flatMap((dimension) =>
+    (doc.lexicons[dimension] ?? []).flatMap((entry) =>
+      entry.weight === undefined
+        ? []
+        : [{ pattern: entry.pattern, dimension, factors: [entry.weight], zero: 0, before: entry.position === "before", context: [] }],
+    ),
+  );
+
+const wordsOf = (doc: ProseDocument): ScaleWords => ({
+  columns: (doc.lexicons["servings-column"] ?? []).map((entry) => ({ pattern: entry.pattern, position: entry.position })),
+  unscaled: (doc.lexicons["unscaled-amount"] ?? []).map((entry) => entry.pattern),
+  unitForms: (doc.lexicons["scaled-unit-form"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern })),
+  measures: measuresOf(doc),
+});
+
+const DECIMALS = 1000;
+const shown = (amount: number): string => String(Math.round(amount * DECIMALS) / DECIMALS);
+
+export const scaledQuantityMismatch: Detector = (doc): Finding[] =>
+  scaleSlips(doc.source, wordsOf(doc)).map((slip) => {
+    const offset = slip.cell.start + (slip.cell.text.length - slip.cell.text.trimStart().length);
+    return {
+      rule: "scaled-quantity-mismatch",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, offset),
+      values: {
+        item: slip.item.text.trim(),
+        written: slip.cell.text.trim(),
+        column: slip.heading,
+        other: slip.other.text.trim(),
+        otherColumn: slip.otherHeading,
+        expected: shown(slip.expected),
+        scaledRows: slip.scaledRows,
+        offset,
+      },
+    };
+  });

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