chaffjs 0.33.0 → 0.34.0

package/src/detectors/orthography.ts

@@ -1,18 +1,26 @@
-import type { Detector, Finding, ProseDocument, Sentence, Span } from "../plugin.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } from "../plugin.ts";
+import { conjugatedStartsOutside } from "./conjugated-entry.ts";
 import { calendarRuns, calendarUnitsOf, type CalendarUnits } from "../calendar-number.ts";
 import { escapeRegExp, latinBoundaries, occurrencesOutside, type Boundary, type SpacingKind } from "../orthography.ts";
-import { minorityReport } from "../spacing-minority.ts";
+import { minorityReport, withoutSideOnTie } from "../spacing-minority.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { digitRunAround, endsWithDivisionLabel, isNumberName, sequenceLabelStarts, type NameContext } from "../number-name.ts";
 import { isSpacedLocationPart, type FloorWords } from "../location-part.ts";
-import { isNameSeparator, type OrganizationWords } from "../name-separator.ts";
+import { isFieldSeparator, isNameSeparator, type OrganizationWords } from "../name-separator.ts";
 import { addressSpans, clockTimeSpans, identifierSpans, isInsideSpan } from "../spacing-code.ts";
 
+/** 書いた形の出現に、動詞の活用した形（行う → 行います）を足したもの。同じ位置は一度だけ。 */
+const avoidedStarts = (sentence: Sentence, entry: LexiconEntry, use: string): number[] => {
+  const written = occurrencesOutside(sentence.text, entry.pattern, use);
+  const conjugated = conjugatedStartsOutside(sentence, entry, use).filter((at) => !written.includes(at));
+  return [...written, ...conjugated].toSorted((left, right) => left - right);
+};
+
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
 export const preferredTerm: Detector = (doc, options): Finding[] => {
-  const pairs = (options.lexicon ?? []).flatMap((entry) => (entry.instead_of === undefined ? [] : [{ avoid: entry.pattern, use: entry.instead_of }]));
+  const pairs = (options.lexicon ?? []).flatMap((entry) => (entry.instead_of === undefined ? [] : [{ entry, avoid: entry.pattern, use: entry.instead_of }]));
   const hits = doc.sentences.flatMap((sentence) =>
-    pairs.flatMap((pair) => occurrencesOutside(sentence.text, pair.avoid, pair.use).map((at) => ({ sentence, at, pair }))),
+    pairs.flatMap((pair) => avoidedStarts(sentence, pair.entry, pair.use).map((at) => ({ sentence, at, pair }))),
   );
   if (hits.length === 0 || hits.length < options.limit) return [];
   return hits.map((hit) => ({
@@ -91,7 +99,7 @@ type SentenceCodes = {
  * 日付・時刻は前の境目（「は 9月」「午後3時」「令和 3 年」）も数えない。日付はまとめて一つの書き方で、数量の空け方の票にはしない。コロンで書いた時刻（13:30）も同じ。
  * メールアドレス・URL の前後の境目も数えない（spacing-code.ts）。「予約番号 MN-48215 を」の番号の前後も、番号を文から区切る空白なので数えない。
  * 「本社 5階」のように名前の後ろに空白で区切った階・部屋の番号の前の空白も、所在の組の区切りなので数えない（location-part.ts）。
- * 「経営企画部 IR担当」のように名前だけを並べた行で、名前と名前を分ける空白も数えない（name-separator.ts）。
+ * 「経営企画部 IR担当」のように名前だけを並べた行で、名前と名前を分ける空白も、「所属：経済学科 1年」のように項目の値の組を分ける空白も数えない（name-separator.ts）。
  */
 const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, codes: SentenceCodes): boolean => {
   if (followsItemNumber(sentence.text, boundary, context.itemNumbers) || besideSpan(codes.identifiers, boundary)) return false;
@@ -103,6 +111,7 @@ const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContex
   if (run === undefined) return true;
   if (codes.calendar.has(run.start)) return false;
   if (boundary.kind === "before-digit" && isSpacedLocationPart(sentence.text, run, sentence.tokens, sentence.span.start, context.floors)) return false;
+  if (isFieldSeparator(sentence.text, boundary, sentence.tokens, sentence.span.start)) return false;
   return !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start, context);
 };
 
@@ -135,9 +144,9 @@ const findingAt = (entry: Located, values: Finding["values"], variant?: string):
   values: { ...values, offset: entry.sentence.span.start + entry.offset },
 });
 
-/** 一つの種類の境目の指摘。少ないほうを 1 箇所ずつか、書き方が二通りあれば 1 件で（spacing-minority.ts）。 */
+/** 一つの種類の境目の指摘。少ないほうを 1 箇所ずつか、書き方が二通りあれば 1 件で（spacing-minority.ts）。同数ならどちらの側にも立たない。 */
 const findingsOf = (kind: SpacingKind, ofKind: readonly Located[], limit: number): Finding[] => {
-  const report = minorityReport(ofKind, limit);
+  const report = withoutSideOnTie(minorityReport(ofKind, limit), ofKind);
   if (report === undefined) return [];
   if (report.mode === "mixed") {
     const { first, odd, spaced, touching } = report;

package/src/detectors/per-unit-words.ts

@@ -0,0 +1,24 @@
+import type { ProseDocument, StructureNode } from "../plugin.ts";
+import { withPerUnits, type PerUnitMark, type PerUnitTemplate, type PerUnitWords } from "../facts/per-unit.ts";
+import { factValues, type FactValue } from "../facts/fact-values.ts";
+import { nameSpans } from "../compare/proper-nouns.ts";
+
+const marksOf = (doc: ProseDocument, id: string): PerUnitMark[] =>
+  (doc.lexicons[id] ?? []).map((entry): PerUnitMark => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
+
+/** 何あたりかの語: 決まった印（per-unit-mark）、型（fact-per-unit）、単位の語（rate-unit）、読まない百分率（percent-unit）、単価の列の見出し（unit-price-column）。 */
+const perUnitWordsOf = (doc: ProseDocument): PerUnitWords => ({
+  marks: marksOf(doc, "per-unit-mark"),
+  templates: (doc.lexicons["fact-per-unit"] ?? []).map((entry): PerUnitTemplate => ({ pattern: entry.pattern, position: entry.position ?? "before" })),
+  units: marksOf(doc, "rate-unit"),
+  percentUnits: (doc.lexicons["percent-unit"] ?? []).map((entry) => entry.pattern),
+  priceHeadings: (doc.lexicons["unit-price-column"] ?? []).map((entry) =>
+    entry.group === undefined ? { pattern: entry.pattern } : { pattern: entry.pattern, group: entry.group },
+  ),
+});
+
+/** 文書の値に、何あたりか（1kmあたり15円 の km）を付ける。 */
+export const perUnitsOf = <T extends FactValue>(doc: ProseDocument, values: readonly T[]): T[] => withPerUnits(doc.source, values, perUnitWordsOf(doc));
+
+/** 木の数量と日付と固有名詞（factValues）に、何あたりかを付けたもの。 */
+export const perUnitValues = (doc: ProseDocument, tree: StructureNode): FactValue[] => perUnitsOf(doc, factValues(tree, doc.source, nameSpans(doc)));

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

@@ -4,11 +4,9 @@
 // number-word (digit), and a range of counts is joined by range-connector or amount-range-word.
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { periodMultipleMismatches, type PeriodMultipleWords } from "../structure/period-multiple.ts";
-import type { StatedAmount } from "../structure/stated-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";
+import { statedAmountsOf } from "./stated-amounts.ts";
 
 const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
   (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
@@ -27,23 +25,9 @@ const wordsOf = (doc: ProseDocument): PeriodMultipleWords => ({
   numberWords: numberWordsOf(doc),
 });
 
-const amountsOf = (text: string, doc: ProseDocument): StatedAmount[] => {
-  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 periodMultipleMismatch: Detector = (doc): Finding[] => {
   const text = proseAndTablesOf(doc);
-  return periodMultipleMismatches(text, amountsOf(text, doc), wordsOf(doc)).map((issue) => ({
+  return periodMultipleMismatches(text, statedAmountsOf(text, doc), wordsOf(doc)).map((issue) => ({
     rule: "period-multiple-mismatch",
     severity: "warning",
     line: 0,

package/src/detectors/reference-number-variant.ts

@@ -1,13 +1,14 @@
 // reference-number-variant: a document's own reference number written with two neighbouring characters swapped somewhere
 // else in the document, after a label of the same kind (reference-numbers.ts), or with no label where only one labelled
-// code swaps to it (unlabelled-references.ts); and the document's one vehicle plate written
+// code swaps to it (unlabelled-references.ts), or as the one code a product document is about (subject-codes.ts); and the document's one vehicle plate written
 // once with one character of its serial changed (vehicle-plates.ts).
-import { labelledReferenceNumbers, referenceVariants, type ReferenceNumber } from "../reference-numbers.ts";
+import { labelledReferenceNumbers, referenceVariants, type ReferenceNumber, type ReferenceVariant } from "../reference-numbers.ts";
 import { labelledPlates, plateVariants } from "../vehicle-plates.ts";
-import { tableCodes, tableLabelledCodes, unlabelledVariants } from "../unlabelled-references.ts";
+import { isCodeWith, tableCodes, tableLabelledCodes, unlabelledVariants } from "../unlabelled-references.ts";
+import { isSubjectCode, MIN_SUBJECT_DIGITS, subjectCodeVariants } from "../subject-codes.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAt } from "./structure-tree.ts";
-import type { Detector, Finding, OptionValue } from "../plugin.ts";
+import type { Detector, Finding, OptionValue, ProseDocument } from "../plugin.ts";
 
 const PLATE_SHAPES = "vehicle-plate";
 const SUBSTITUTED = "substituted";
@@ -25,6 +26,18 @@ const finding = (number: ReferenceNumber, other: ReferenceNumber, source: string
 /** Kinds a document lists many of (item codes): two labelled ones are two things, so only a code with no label is compared with them. */
 const listedKindsOf = (value: OptionValue | undefined): readonly string[] => (typeof value === "object" ? value : []);
 
+const TITLE_DEPTH = 1;
+
+/** The title as the source writes it, where it starts: the prose masks a heading's line. */
+const titleOf = (doc: ProseDocument): { start: number; text: string } | undefined => {
+  const title = doc.markup?.headings.find((heading) => heading.depth === TITLE_DEPTH);
+  return title === undefined ? undefined : { start: title.start, text: doc.source.slice(title.start, title.end) };
+};
+
+/** One finding per place, the first reading kept: a code may be read both as an unlabelled item code and as the document's own. */
+const firstAtEachOffset = (variants: readonly ReferenceVariant[]): ReferenceVariant[] =>
+  variants.filter((variant, index) => variants.findIndex((other) => other.number.offset === variant.number.offset) === index);
+
 export const referenceNumberVariant: Detector = (doc, options): Finding[] => {
   const labels = options.lexicon ?? [];
   if (labels.length === 0) return [];
@@ -36,9 +49,18 @@ export const referenceNumberVariant: Detector = (doc, options): Finding[] => {
   const listed = new Set(listedKindsOf(options.settings?.["listed_kinds"]));
   const withTables = proseAndTablesOf(doc);
   const labelled = [...numbers, ...tableLabelledCodes(withTables, labels)];
+  const subjectCodes = subjectCodeVariants({
+    prose: text,
+    title: titleOf(doc),
+    labels,
+    listed,
+    tabled: tableLabelledCodes(withTables, labels, isSubjectCode),
+    known: tableCodes(withTables, isCodeWith(MIN_SUBJECT_DIGITS)),
+  });
+  const unlabelled = firstAtEachOffset([...unlabelledVariants(text, labelled, tableCodes(withTables)), ...subjectCodes]);
   return [
     ...referenceVariants(numbers.filter((number) => !listed.has(number.label))).map(({ number, other }) => finding(number, other, doc.source)),
-    ...unlabelledVariants(text, labelled, tableCodes(withTables)).map(({ number, other }) => finding(number, other, doc.source)),
+    ...unlabelled.map(({ number, other }) => finding(number, other, doc.source)),
     ...plateVariants(plates).map(({ number, other }) => finding(number, other, doc.source, SUBSTITUTED)),
   ].toSorted((a, b) => Number(a.values["offset"]) - Number(b.values["offset"]));
 };

package/src/detectors/registry/condition-toki.ts

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

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

@@ -4,11 +4,9 @@
 // range of rent is joined by range-connector or amount-range-word.
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { rentMultipleMismatches, type RentMultipleWords } from "../structure/rent-multiple.ts";
-import type { StatedAmount } from "../structure/stated-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";
+import { statedAmountsOf } from "./stated-amounts.ts";
 
 const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
   (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
@@ -30,23 +28,9 @@ const wordsOf = (doc: ProseDocument): RentMultipleWords => ({
   numberWords: numberWordsOf(doc),
 });
 
-const amountsOf = (text: string, doc: ProseDocument): StatedAmount[] => {
-  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) => ({
+  return rentMultipleMismatches(text, statedAmountsOf(text, doc), wordsOf(doc)).map((issue) => ({
     rule: "rent-multiple-mismatch",
     severity: "warning",
     line: 0,

package/src/detectors/row-sentence-amounts.ts

@@ -4,15 +4,8 @@ import { factValues, type FactValue } from "../facts/fact-values.ts";
 import { cellsOf, tablesOf } from "../facts/table-facts.ts";
 import { scopedFacts, type ScopedFact } from "../facts/fact-scope.ts";
 import { withoutEdgeMarks } from "../facts/trim-marks.ts";
-import {
-  periodOf,
-  rowSentenceConflicts,
-  type Amount,
-  type AmountRow,
-  type PeriodMark,
-  type SubjectSentence,
-  type SubjectWords,
-} from "../facts/row-sentence-amounts.ts";
+import { rowSentenceConflicts, type Amount, type AmountRow, type SubjectSentence, type SubjectWords } from "../facts/row-sentence-amounts.ts";
+import { perUnitsOf } from "./per-unit-words.ts";
 import { linesOf, type Line } from "../structure/lines.ts";
 import { quoteAt } from "./structure-tree.ts";
 
@@ -57,19 +50,11 @@ const subjectWordsOf = (doc: ProseDocument): SubjectWords => ({
   conditions: patternsOf(doc, "fact-amount-condition"),
 });
 
-const periodMarksOf = (doc: ProseDocument): PeriodMark[] =>
-  (doc.lexicons["per-unit-mark"] ?? []).map((entry): PeriodMark => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
-
-/** 金額: 通貨の語彙表の印を単位に書いた数量。前後に期間あたりの印があれば、その期間も。 */
+/** 金額: 通貨の語彙表の印を単位に書いた数量。何あたりの金額（日額、1kmあたり）は、その単位も。 */
 const amountsOf = (doc: ProseDocument, tree: StructureNode): Amount[] => {
   const currencies = new Set(patternsOf(doc, "currency-notation").map((pattern) => pattern.normalize("NFKC")));
-  const marks = periodMarksOf(doc);
-  return factValues(tree, doc.source, nameSpans(doc))
-    .filter((value) => value.kind === "quantity" && currencies.has(value.unit))
-    .map((value): Amount => {
-      const period = periodOf(doc.source, value, marks);
-      return period === undefined ? value : { ...value, period };
-    });
+  const amounts = factValues(tree, doc.source, nameSpans(doc)).filter((value) => value.kind === "quantity" && currencies.has(value.unit));
+  return perUnitsOf(doc, amounts);
 };
 
 /** 表の行の金額と、その行の見出しを主語にした文の金額の食い違い。名前付きの値として読めた文の値は、ほかの読みが比べる。 */

package/src/detectors/stated-amounts.ts

@@ -0,0 +1,20 @@
+// The amounts a document states, as the multiple and total checks read them: currency-notation's written amounts, each
+// read with amount-multiplier's words of scale (1億2,000万円 is one amount), the ones that cannot be read left out.
+import type { ProseDocument } from "../plugin.ts";
+import type { StatedAmount } from "../structure/stated-multiple.ts";
+import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
+import { amountsIn, formsOf } from "./currency-notation.ts";
+
+export const statedAmountsOf = (text: string, doc: ProseDocument): StatedAmount[] => {
+  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 }];
+  });
+};

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

@@ -3,6 +3,7 @@
 import { stepTimeSlip, type StepTimeWords } from "../structure/step-times.ts";
 import type { Mark } from "../structure/time-marks.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { withoutCodeBlocks } from "./code-fences.ts";
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 
 const SECONDS_PER_HOUR = 3600;
@@ -35,7 +36,7 @@ const wordsOf = (doc: ProseDocument): StepTimeWords => {
 };
 
 export const stepTimeSumMismatch: Detector = (doc): Finding[] => {
-  const slip = stepTimeSlip(doc.source, wordsOf(doc));
+  const slip = stepTimeSlip(withoutCodeBlocks(doc.source), wordsOf(doc));
   if (slip === undefined) return [];
   return [
     {

package/src/detectors/structure-tree.ts

@@ -265,6 +265,9 @@ const totalIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["struct
     breakdowns: patternsOf(doc, "breakdown-phrase"),
     discounts: patternsOf(doc, "discount-word"),
     joiners: patternsOf(doc, "breakdown-gap-joiner"),
+    leads: patternsOf(doc, "total-breakdown-lead"),
+    partials: patternsOf(doc, "breakdown-partial-word"),
+    backReferences: patternsOf(doc, "total-back-reference"),
   };
   const prose = proseTotalMismatches(
     doc.source,

package/src/detectors/team.ts

@@ -2,7 +2,8 @@ import { proseText } from "../measure.ts";
 import { joinWords } from "./word-list.ts";
 import { wordsOf } from "./structure.ts";
 import { nameSpans } from "../team-names.ts";
-import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
+import { conjugatedSpans } from "./conjugated-entry.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 
 /**
  * チームの言葉。社内でしか通じない語を、チームが chaff.yaml に自分で並べる。
@@ -12,19 +13,24 @@ import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "..
  */
 /**
  * 表層でも原形でも当てる。利用者は辞書形で書く（「握る」）が、本文は活用している（「握った」）。
+ * 複合動詞（「巻き取る」）は語に割れるので、語の並びで原形に照らす（「巻き取ります」）。
  * 品詞解析があれば原形で当たり、無くても表層で当たる。要求はしない。
  */
-const matches = (sentence: Sentence, word: string): boolean => {
+const matches = (sentence: Sentence, entry: LexiconEntry): boolean => {
   // 大文字小文字は区別しない。英語の文頭の「Circle back」も「circle back」として当てる。
-  const wanted = word.toLowerCase();
-  return sentence.text.toLowerCase().includes(wanted) || (sentence.tokens ?? []).some((token) => token.lemma?.toLowerCase() === wanted);
+  const wanted = entry.pattern.toLowerCase();
+  return (
+    sentence.text.toLowerCase().includes(wanted) ||
+    (sentence.tokens ?? []).some((token) => token.lemma?.toLowerCase() === wanted) ||
+    conjugatedSpans(sentence, entry).length > 0
+  );
 };
 
 export const internalJargon: Detector = (doc, options): Finding[] => {
-  const words = (options.lexicon ?? []).map((entry) => entry.pattern);
-  if (words.length === 0) return [];
+  const entries = options.lexicon ?? [];
+  if (entries.length === 0) return [];
   const hits = doc.sentences.flatMap((sentence) => {
-    const matched = words.find((word) => matches(sentence, word));
+    const matched = entries.find((entry) => matches(sentence, entry))?.pattern;
     return matched === undefined ? [] : [{ sentence, matched }];
   });
   if (hits.length < options.limit) return [];

package/src/detectors/time-order.ts

@@ -11,6 +11,7 @@ import { reversedTimeRanges } from "../structure/time-range.ts";
 import { cellMinutes, reversedShiftRows, showsOvernightWork } from "../structure/shift-times.ts";
 import { pairedTimesOutOfOrder } from "../structure/labelled-time-order.ts";
 import { quoteAt, rangeWordsOf } from "./structure-tree.ts";
+import { withoutCodeBlocks } from "./code-fences.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）から取る。
@@ -43,11 +44,12 @@ const variantOf = (issue: StructureIssue, variant: string | undefined): string |
   return "end_label" in issue.values ? "columns" : undefined;
 };
 
-/** 表と箇条書きを行のまま読むので、原文を渡す（doc.prose は表を覆う）。 */
+/** 表と箇条書きを行のまま読むので、原文を渡す（doc.prose は表を覆う）。コードブロックは例なので覆う。 */
 const detectorOf =
   (rule: string, find: Finder, variant?: string): Detector =>
-  (doc): Finding[] =>
-    find(doc.source, timesOf(doc.source), datesOf(doc), timeWordsOf(doc), doc).map((issue) => {
+  (doc): Finding[] => {
+    const source = withoutCodeBlocks(doc.source);
+    return find(source, timesOf(source), datesOf(doc), timeWordsOf(doc), doc).map((issue) => {
       const named = variantOf(issue, variant);
       return {
         rule,
@@ -59,6 +61,7 @@ const detectorOf =
         ...(named === undefined ? {} : { variant: named }),
       };
     });
+  };
 
 const timeOrderInList: Detector = detectorOf("time-order", timeOrderBreaks);
 /** 語の決まった二つの時刻（開場と開演）。語は語彙表 timed-pair-label から取る。 */

package/src/detectors/unknown-word.ts

@@ -1,5 +1,7 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { isKnownWord, isSplitWord, suggestionFor, wordsToCheck, type CheckedWord, type Speller } from "../spelling.ts";
+import { parse } from "../markdown-read.ts";
+import { eachPreOrder } from "../tree-walk.ts";
 import { quoteAt } from "./structure-tree.ts";
 
 /** これより短い語は見ない。短い語は一字違いの語が多すぎて言い直しが決まらず（tost は test か toast か）、略した語（impl）も多い。 */
@@ -24,14 +26,30 @@ const usedOnce = (words: readonly CheckedWord[]): CheckedWord[] => {
   return words.filter(({ word }) => counts.get(word) === 1);
 };
 
+const LETTERS = /\p{L}+/gu;
+
+/** 文書がコード（コードの区画と `…`）に書いた語。コードに書いた名前（`tidyq check` の tidyq）は、地の文でも打ち間違いではない。 */
+export const codeWordsOf = (source: string): Set<string> => {
+  const words = new Set<string>();
+  eachPreOrder(parse(source), (node) => {
+    if (node.type === "code" || node.type === "inlineCode")
+      (node.value ?? "")
+        .toLowerCase()
+        .match(LETTERS)
+        ?.forEach((word) => words.add(word));
+  });
+  return words;
+};
+
 /**
  * 辞書に無い英語の語で、一字違いの辞書の語があるもの（recieve → receive）。辞書は adapter が持ち、無い言語では動かない。
- * 大文字を含む語（固有名詞・略語）、コード・URL の中、頭の字を分けた語の残り、二度以上使う語、言い直しの無い語は言わない。
+ * 大文字を含む語（固有名詞・略語）、コード・URL の中、頭の字を分けた語の残り、二度以上使う語、言い直しの無い語、
+ * 文書がコードにも書いた語は言わない。
  */
 export const unknownWord: Detector = (doc): Finding[] => {
   if (doc.dictionary === undefined) return [];
   const speller = spellerOf(doc, doc.dictionary());
-  const known = new Set(patternsOf(doc, "known-misspelling"));
+  const known = new Set([...patternsOf(doc, "known-misspelling"), ...codeWordsOf(doc.source)]);
   const words = wordsToCheck(doc.prose ?? doc.source, MIN_LENGTH, MAX_LENGTH).filter(({ offset }) => !isSplitWord(doc.source, offset));
   const used = new Set(words.map(({ word }) => word).filter((word) => isKnownWord(word, speller)));
   return usedOnce(words).flatMap(({ offset, word }) => {

package/src/detectors/use-interval.ts

@@ -4,6 +4,7 @@ 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";
+import { withoutCodeBlocks } from "./code-fences.ts";
 
 // 使う間隔の下限と期間あたりの回数の上限が両立しない、または表の回数と合わない（interval-count-mismatch）。
 // 語は use-count-word と use-interval-word、長さの単位は unit-time から取る。
@@ -14,8 +15,8 @@ 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, {
+const lengthsOf = (doc: ProseDocument, text: string): TimeLength[] =>
+  timeLengths(text, {
     hourUnits: patternsOf(doc, "unit-time", SECONDS_PER_HOUR),
     minuteUnits: patternsOf(doc, "unit-time", SECONDS_PER_MINUTE),
     halves: patternsOf(doc, "length-half"),
@@ -39,8 +40,10 @@ const valuesOf = (doc: ProseDocument, mismatch: IntervalMismatch): Record<string
     ? { 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) => ({
+/** コードブロックの中の用法は例なので、覆って読む。 */
+export const intervalCountMismatch: Detector = (doc): Finding[] => {
+  const text = withoutCodeBlocks(doc.source);
+  return intervalCountMismatches(text, paragraphsOf(text), lengthsOf(doc, text), wordsOf(doc)).map((mismatch) => ({
     rule: "interval-count-mismatch",
     severity: "warning",
     line: 0,
@@ -49,3 +52,4 @@ export const intervalCountMismatch: Detector = (doc): Finding[] =>
     values: { ...valuesOf(doc, mismatch), offset: mismatch.count.start },
     ...(mismatch.kind === "table" ? { variant: "table" } : {}),
   }));
+};

package/src/detectors/use-maximum.ts

@@ -3,6 +3,7 @@ import { exceededMaxima } from "../derived/use-maximum.ts";
 import { paragraphsOf } from "../derived/period-counts.ts";
 import { limitWordsOf, marksOf, periodCountWordsOf } from "./use-count-words.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { withoutCodeBlocks } from "./code-fences.ts";
 import { isMoneySpan, type CurrencyMark } from "../derived/money-span.ts";
 
 // 1回の量 × 期間あたりの回数が、その期間の上限を超える（product-exceeds-maximum）。語は use-count-word と use-amount-word から取る。
@@ -19,7 +20,8 @@ export const productExceedsMaximum: Detector = (doc): Finding[] => {
   const marks = currencyMarksOf(doc);
   const unitOf = (span: Span): string => written(doc, span).replace(LEADING_NUMBER, "");
   const isMoney = (span: Span): boolean => isMoneySpan(doc.source, span, unitOf(span), marks);
-  const amounts = exceededMaxima(doc.source, paragraphsOf(doc.source), words).filter((exceeded) => !isMoney(exceeded.maximum) && !isMoney(exceeded.perUse));
+  const text = withoutCodeBlocks(doc.source);
+  const amounts = exceededMaxima(text, paragraphsOf(text), words).filter((exceeded) => !isMoney(exceeded.maximum) && !isMoney(exceeded.perUse));
   return amounts.map((exceeded) => ({
     rule: "product-exceeds-maximum",
     severity: "warning",

package/src/extension/document-view.ts

@@ -1,5 +1,6 @@
 import type * as Api from "../api.ts";
 import type { BulletList, Lexicon, Markup, Paragraph, ProseDocument, Section, Sentence, Span, Token } from "../plugin.ts";
+import { entriesForGenre } from "../lexicon-genres.ts";
 
 // The document as the plugin API shows it (api.ts RuleDocument): copies of only the public fields, frozen. A copy, so
 // chaff's own shapes can change without breaking a plugin; frozen, so a plugin's rule cannot change what the next rule reads.
@@ -55,7 +56,12 @@ const sectionOf = (section: Section, copy: SentenceCopies): Api.Section => ({
 const listOf = (list: BulletList): Api.List => ({ span: spanOf(list.span), itemLengths: [...list.items] });
 
 const lexiconOf = (lexicon: Lexicon): Api.Lexicon =>
-  lexicon.map((entry) => ({ pattern: entry.pattern, ...(entry.instead_of === undefined ? {} : { instead_of: entry.instead_of }) }));
+  lexicon.map((entry) => ({
+    pattern: entry.pattern,
+    ...(entry.instead_of === undefined ? {} : { instead_of: entry.instead_of }),
+    ...(entry.rewrite === undefined ? {} : { rewrite: entry.rewrite }),
+    ...(entry.genres === undefined ? {} : { genres: [...entry.genres] }),
+  }));
 
 const markupOf = (markup: Markup): Api.Markup => ({
   markdown: markup.markdown,
@@ -68,7 +74,7 @@ const markupOf = (markup: Markup): Api.Markup => ({
 
 const EMPTY_MARKUP: Markup = { markdown: false, headings: [], images: [], links: [], ids: new Set(), texts: [] };
 
-const viewOf = (doc: ProseDocument): Api.RuleDocument => {
+const viewOf = (doc: ProseDocument, genre: string | undefined): Api.RuleDocument => {
   const copy = sentenceCopier();
   const fields = deepFreeze({
     path: doc.path,
@@ -81,7 +87,7 @@ const viewOf = (doc: ProseDocument): Api.RuleDocument => {
     lists: doc.lists.map(listOf),
     listItems: doc.listSpans.map(spanOf),
     links: doc.links.map(spanOf),
-    lexicons: Object.fromEntries(Object.entries(doc.lexicons).map(([name, lexicon]) => [name, lexiconOf(lexicon)])),
+    lexicons: Object.fromEntries(Object.entries(doc.lexicons).map(([name, lexicon]) => [name, lexiconOf(entriesForGenre(lexicon, genre))])),
   });
   // The markup is read from the Markdown tree only when a rule asks for it, as chaff's own rules do.
   const markup: { value: Api.Markup | undefined } = { value: undefined };
@@ -97,13 +103,16 @@ const viewOf = (doc: ProseDocument): Api.RuleDocument => {
 /** A word list as a detector is given it (DetectorOptions.lexicon): public fields only, frozen. */
 export const frozenLexiconOf = (lexicon: Lexicon): Api.Lexicon => deepFreeze(lexiconOf(lexicon));
 
-const views = new WeakMap<ProseDocument, Api.RuleDocument>();
+// By genre too: the run, not the document, carries the genre, so one document may be run under several.
+const views = new WeakMap<ProseDocument, Map<string | undefined, Api.RuleDocument>>();
 
-/** The document as a plugin's detector sees it. Made once per document, however many plugin rules read it. */
-export const ruleDocumentOf = (doc: ProseDocument): Api.RuleDocument => {
-  const known = views.get(doc);
+/** The document as a plugin's detector sees it in a genre, its word lists holding that genre's entries. Made once per document and genre. */
+export const ruleDocumentOf = (doc: ProseDocument, genre: string | undefined): Api.RuleDocument => {
+  const byGenre = views.get(doc) ?? new Map<string | undefined, Api.RuleDocument>();
+  views.set(doc, byGenre);
+  const known = byGenre.get(genre);
   if (known !== undefined) return known;
-  const view = viewOf(doc);
-  views.set(doc, view);
+  const view = viewOf(doc, genre);
+  byGenre.set(genre, view);
   return view;
 };

package/src/extension/entry-genres.ts

@@ -0,0 +1,15 @@
+// A word-list entry's genres as a plugin writes them: a non-empty list of the genres and groups chaff knows (legal,
+// blog/tech). Pure: the known ids come in.
+
+const printed = (value: unknown): string => JSON.stringify(value) ?? String(value);
+
+/** What cannot be read in genres, printed: the whole value when it is not a non-empty list, else its unknown items. undefined when it reads. */
+export const genresProblemOf = (genres: unknown, known: ReadonlySet<string>): string | undefined => {
+  if (!Array.isArray(genres) || genres.length === 0) return printed(genres);
+  const unknown = genres.filter((genre: unknown) => typeof genre !== "string" || !known.has(genre));
+  return unknown.length === 0 ? undefined : printed(unknown);
+};
+
+/** genres when they read, as a list of ids. */
+export const readGenres = (genres: unknown, known: ReadonlySet<string>): string[] | undefined =>
+  Array.isArray(genres) && genresProblemOf(genres, known) === undefined ? genres.filter((genre: unknown) => typeof genre === "string") : undefined;

package/src/extension/module-detector.ts

@@ -1,6 +1,7 @@
 import type * as Api from "../api.ts";
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { frozenLexiconOf, ruleDocumentOf } from "./document-view.ts";
+import { entriesForGenre } from "../lexicon-genres.ts";
 import { returnedFindings, type ShapeProblem } from "./returned-findings.ts";
 
 // A detector a team or a plugin wrote, run as one of chaff's. It reads the document through the plugin API, and what it
@@ -38,8 +39,12 @@ const messageOf = (error: unknown): string => {
  * What the detector returned, as findings, or how it failed. Reading the return can run the plugin's code too (a getter,
  * a Proxy), so it is checked inside the try. A Promise is a wrong return; its rejection must not end the run later.
  */
-const findingsOf = (detect: UntrustedDetector, doc: ProseDocument, options: Api.DetectorOptions): { findings: Finding[] } | { failure: RuleFailure } => {
-  const view = ruleDocumentOf(doc);
+const findingsOf = (
+  detect: UntrustedDetector,
+  view: Api.RuleDocument,
+  doc: ProseDocument,
+  options: Api.DetectorOptions,
+): { findings: Finding[] } | { failure: RuleFailure } => {
   try {
     const returned: unknown = detect(view, options);
     if (returned instanceof Promise) returned.catch(() => undefined);
@@ -54,8 +59,8 @@ const findingsOf = (detect: UntrustedDetector, doc: ProseDocument, options: Api.
 export const moduleDetector =
   (detect: UntrustedDetector, origin: string): Detector =>
   (doc, options): Finding[] => {
-    const lexicon = options.lexicon === undefined ? undefined : frozenLexiconOf(options.lexicon);
-    const outcome = findingsOf(detect, doc, Object.freeze({ lexicon }));
+    const lexicon = options.lexicon === undefined ? undefined : frozenLexiconOf(entriesForGenre(options.lexicon, options.genre));
+    const outcome = findingsOf(detect, ruleDocumentOf(doc, options.genre), doc, Object.freeze({ lexicon }));
     if ("failure" in outcome) throw new PluginRuleFailure(outcome.failure, origin);
     return outcome.findings;
   };