chaffjs 0.22.0 → 0.24.0

package/src/detectors/ime-residue.ts

@@ -0,0 +1,37 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// A single Latin letter left inside a Japanese word by the input method (おもしrおい, 対応sた): a key pressed and not converted.
+
+/** One stray letter, and where it is in the text. */
+export type StrayLetter = { readonly offset: number; readonly letter: string };
+
+// Hiragana or kanji before (after katakana a letter is a label: サイズm, プランb), kana after.
+const STRAY = /(?<=[\p{Script=Hiragana}\p{Script=Han}々])[a-z](?=[\p{Script=Hiragana}\p{Script=Katakana}ー])/gu;
+/** Marks that make the run around the letter a path, an address or an assignment (/docs/あaい, a=b). */
+const PATH_MARK = /[/\\=@#]/u;
+
+const runBefore = (text: string, offset: number): string => text.slice(0, offset).split(/\s/u).at(-1) ?? "";
+
+/**
+ * One lower-case letter between Japanese: hiragana or kanji before, kana after. A letter followed by a particle names
+ * something (変数xが, まずxを, をxで), so it is left alone; the particles come from the lexicon.
+ */
+export const strayLettersIn = (text: string, particles: readonly string[]): StrayLetter[] =>
+  [...text.matchAll(STRAY)].flatMap((match) => {
+    const namesSomething = particles.some((particle) => text.startsWith(particle, match.index + 1));
+    return namesSomething || PATH_MARK.test(runBefore(text, match.index)) ? [] : [{ offset: match.index, letter: match[0] }];
+  });
+
+export const imeResidue: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const particles = (doc.lexicons["case-particle"] ?? []).map((entry) => entry.pattern);
+  return strayLettersIn(text, particles).map((stray) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, stray.offset, stray.offset + 1),
+    values: { letter: stray.letter, offset: stray.offset },
+  }));
+};

package/src/detectors/lexicon.ts

@@ -212,15 +212,24 @@ export const repeatedConjunction: Detector = (doc, options): Finding[] => {
     });
 };
 
+/**
+ * 書き手が書いた語。引用符の中だけの語（words such as "delves" and "pivotal"）は、例に挙げたか人の言葉を引いたもの。
+ * 品詞があれば当たった語の並びごとに見る（活用した形も原形で当たる）。無ければ字で照らす。
+ */
+const writtenIn = (sentence: Sentence, entry: LexiconEntry): boolean =>
+  sentence.tokens === undefined || entry.tokens === undefined || entry.tokens.length === 0
+    ? entryIn(sentence, entry) && !onlyQuoted(sentence, entry)
+    : entryRanges(sentence, entry).some((range) => !quotedRange(sentence, range));
+
 /**
  * AI 生成の signal。1 つでは何も言えないので、重みを足し合わせて文書の点にする。
  * 単独で断じない。§20.2 の複合シグナルの入口で、これだけで「AI が書いた」とは言わない。
  */
 export const aiTell: Detector = (doc, options): Finding[] => {
   const entries = [...new Map((options.lexicon ?? []).map((entry) => [entry.pattern.toLowerCase(), entry])).values()];
-  const found = entries.filter((entry) => doc.sentences.some((sentence) => entryIn(sentence, entry)));
+  const found = entries.filter((entry) => doc.sentences.some((sentence) => writtenIn(sentence, entry)));
   const score = Math.round(found.reduce((sum, entry) => sum + (entry.weight ?? 1), 0) * 10);
-  const first = doc.sentences.find((sentence) => found.some((entry) => entryIn(sentence, entry)));
+  const first = doc.sentences.find((sentence) => found.some((entry) => writtenIn(sentence, entry)));
   if (first === undefined || score <= options.limit) return [];
   return [
     {

package/src/detectors/lookalike-character.ts

@@ -0,0 +1,75 @@
+import type { Detector, Finding, Span } from "../plugin.ts";
+import { codePointName } from "./invisible-character.ts";
+
+/**
+ * A character that looks like a common one but is another code point, so search, sorting and a dictionary miss it.
+ * radical: a Kangxi or supplementary radical (⼈ U+2F08 for 人), from PDF text or an input method's radical list.
+ * compatibility: a CJK compatibility ideograph (or one of its supplement) that Unicode maps to a unified one (樂 U+F914 for 樂).
+ * decomposed: a letter and a separate combining mark (か + U+3099 for が, e + U+0301 for é), from file names or text
+ * copied on macOS. spacing-mark: kana followed by the spacing ゛ or ゜, typed in place of the combined letter.
+ */
+export type LookalikeKind = "radical" | "compatibility" | "decomposed" | "spacing-mark";
+
+export type Lookalike = { readonly span: Span; readonly kind: LookalikeKind; readonly written: string; readonly usual: string };
+
+const RADICAL = /[\u2E80-\u2EFF\u2F00-\u2FDF]/u;
+const COMPATIBILITY = /[\uF900-\uFAFF\u{2F800}-\u{2FA1F}]/u;
+/** A letter or mark base and the combining marks after it. */
+const WITH_MARKS = /\P{M}\p{M}+/gu;
+/** Kana followed by the spacing voiced or semi-voiced mark (か゛, は゜). */
+const SPACING_MARK = /[\p{Script=Hiragana}\p{Script=Katakana}][゛゜]/gu;
+const COMBINING_OF: Readonly<Record<string, string>> = { "゛": "゙", "゜": "゚" };
+const SINGLE_CHAR = /[\u2E80-\u2EFF\u2F00-\u2FDF\uF900-\uFAFF\u{2F800}-\u{2FA1F}]/gu;
+
+/** A radical or compatibility ideograph, with the unified ideograph it stands for. One that maps to nothing is left alone. */
+const singleLookalikes = (source: string): Lookalike[] =>
+  [...source.matchAll(SINGLE_CHAR)].flatMap((match) => {
+    const written = match[0];
+    const radical = RADICAL.test(written);
+    const usual = written.normalize(radical ? "NFKC" : "NFC");
+    if (usual === written || (!radical && !COMPATIBILITY.test(written))) return [];
+    return [{ span: { start: match.index, end: match.index + written.length }, kind: radical ? "radical" : "compatibility", written, usual }];
+  });
+
+/** A base and combining marks that compose into one precomposed letter. Marks with no precomposed form are writing, not a slip. */
+const decomposedLookalikes = (source: string): Lookalike[] =>
+  [...source.matchAll(WITH_MARKS)].flatMap((match) => {
+    const usual = match[0].normalize("NFC");
+    if (Array.from(usual).length >= Array.from(match[0]).length) return [];
+    return [{ span: { start: match.index, end: match.index + match[0].length }, kind: "decomposed", written: match[0], usual }];
+  });
+
+/** Kana and a spacing ゛ or ゜ whose combining form makes one letter (か゛ → が). */
+const spacingMarkLookalikes = (source: string): Lookalike[] =>
+  [...source.matchAll(SPACING_MARK)].flatMap((match) => {
+    const [kana = "", mark = ""] = Array.from(match[0]);
+    const usual = `${kana}${COMBINING_OF[mark] ?? ""}`.normalize("NFC");
+    if (Array.from(usual).length !== 1) return [];
+    return [{ span: { start: match.index, end: match.index + match[0].length }, kind: "spacing-mark", written: match[0], usual }];
+  });
+
+export const lookalikesIn = (source: string): Lookalike[] =>
+  [...singleLookalikes(source), ...decomposedLookalikes(source), ...spacingMarkLookalikes(source)].toSorted(
+    (left, right) => left.span.start - right.span.start,
+  );
+
+const QUOTE_REACH = 20;
+
+const quoteOf = (source: string, span: Span): string =>
+  source
+    .slice(Math.max(0, span.start - QUOTE_REACH), span.end + QUOTE_REACH)
+    .replace(/\s+/gu, " ")
+    .trim();
+
+const codesOf = (text: string): string => Array.from(text).map(codePointName).join(" ");
+
+export const lookalikeCharacter: Detector = (doc): Finding[] =>
+  lookalikesIn(doc.source).map((lookalike) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteOf(doc.source, lookalike.span),
+    values: { written: lookalike.written, usual: lookalike.usual, code: codesOf(lookalike.written), offset: lookalike.span.start },
+    variant: lookalike.kind,
+  }));

package/src/detectors/lowercase-name.ts

@@ -0,0 +1,58 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// A word English always capitalises (a weekday, a month) written in lower case ("on monday"). The words come from the rule's
+// lexicon "calendar-name"; the pattern is the capitalised form.
+
+export type LowercaseName = { readonly offset: number; readonly written: string; readonly usual: string };
+
+/** Characters that make the word part of a name in code, a path, an address or a tag (monday.md, /july/, @friday, #june). */
+const NOT_PROSE_BESIDE = /[\p{L}\p{N}_/.@#:=-]/u;
+
+/** A period or colon ends the sentence or clause unless a name continues after it (monday.md, june:2). */
+const SENTENCE_STOP = /[.:]/u;
+const WORD_CHAR = /[\p{L}\p{N}_]/u;
+
+const joinsAfter = (text: string, end: number): boolean =>
+  SENTENCE_STOP.test(text.charAt(end)) ? WORD_CHAR.test(text.charAt(end + 1)) : NOT_PROSE_BESIDE.test(text.charAt(end));
+
+/** A value after a key or a field marker (day: monday, day = monday, "day": "monday", * * monday) is data, not prose. */
+const VALUE_MARK = /[:=*]/u;
+const STRAIGHT_QUOTE = /["']/u;
+const SPACE_OR_QUOTE = /[\s"']/u;
+/** How far back to look past spaces and quotes for the key's mark. */
+const VALUE_REACH = 8;
+
+const markBefore = (text: string, start: number): string =>
+  Array.from(text.slice(Math.max(0, start - VALUE_REACH), start))
+    .reverse()
+    .find((char) => !SPACE_OR_QUOTE.test(char)) ?? "";
+
+const isValue = (text: string, start: number): boolean => STRAIGHT_QUOTE.test(text.charAt(start - 1)) || VALUE_MARK.test(markBefore(text, start));
+
+const capitalOf = (word: string): string => `${word.charAt(0).toUpperCase()}${word.slice(1)}`;
+
+export const lowercaseNamesIn = (text: string, names: readonly string[]): LowercaseName[] => {
+  const lower = new Map(names.map((name) => [name.toLowerCase(), capitalOf(name)]));
+  return [...text.matchAll(/\p{Ll}+/gu)].flatMap((match) => {
+    const usual = lower.get(match[0]);
+    const end = match.index + match[0].length;
+    if (usual === undefined || NOT_PROSE_BESIDE.test(text.charAt(match.index - 1)) || isValue(text, match.index) || joinsAfter(text, end)) return [];
+    return [{ offset: match.index, written: match[0], usual }];
+  });
+};
+
+export const lowercaseName: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  return lowercaseNamesIn(
+    text,
+    (doc.lexicons["calendar-name"] ?? []).map((entry) => entry.pattern),
+  ).map((name) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, name.offset, name.offset + name.written.length),
+    values: { written: name.written, usual: name.usual, offset: name.offset },
+  }));
+};

package/src/detectors/registry/bare-comparative.ts

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

package/src/detectors/registry/calendar-name-case.ts

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

package/src/detectors/registry/ellipsis-consistency.ts

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

package/src/detectors/registry/generic-heading.ts

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

package/src/detectors/registry/ime-residue.ts

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

package/src/detectors/registry/lookalike-character.ts

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

package/src/detectors/registry/unit-spacing-consistency.ts

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

package/src/detectors/signals.ts

@@ -11,6 +11,7 @@ import { evidenceSpans, hasNumeral, startsWithin } from "./concrete-evidence.ts"
 import { letteredIndexEntries } from "./lettered-index.ts";
 import { hasPredicateIn } from "./gram-predicate.ts";
 import { nameSpans, touchesAny } from "../team-names.ts";
+import { referenceListSpans } from "../reference-lists.ts";
 import type { Detector, Finding, ProseDocument, Section, Sentence } from "../plugin.ts";
 
 const PER = 1000;
@@ -250,9 +251,12 @@ const firstHits = (hits: readonly AcronymHit[]): Map<string, Hit> => {
   return seen;
 };
 
-/** 日付の中の月（SEP 01, 2022）は略語ではない。 */
-const outsideDates = (hits: readonly AcronymHit[], dates: readonly Span[]): AcronymHit[] =>
-  hits.filter(({ hit }) => !dates.some((span) => span.start <= hit.offset && hit.offset < span.end));
+/**
+ * 範囲の外の略語。日付の中の月（SEP 01, 2022）は略語ではない。文献一覧の誌名や会議名（Appeared in: LREC 2008.）は
+ * 引いた文献の書き方で、本文が説明する略語ではない。
+ */
+const outsideSpans = (hits: readonly AcronymHit[], spans: readonly Span[]): AcronymHit[] =>
+  hits.filter(({ hit }) => !spans.some((span) => span.start <= hit.offset && hit.offset < span.end));
 
 /**
  * どこか 1 か所で展開してあればよい。初出が節の見出し代わりの語（「5.3. DPA.」）で、
@@ -300,11 +304,11 @@ export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const headings = doc.sections.map((section) => section.heading);
   const explainedAlone = (word: string): boolean =>
     common.has(word) || entries.has(word) || isExpanded(body, word, expandedAt) || headings.some((heading) => expandsInHeading(heading, word, expandedAt));
-  const hits = acronymsOf(doc, notationOf(doc));
+  const hits = outsideSpans(acronymsOf(doc, notationOf(doc)), referenceListSpans(doc.source, patternsOf(doc, "reference-list-heading")));
   const unexplained = new Set([...firstHits(hits).keys()].filter((acronym) => !isExplained(acronym, explainedAlone)));
   // 日付を読むには文書の木を作る。上限に届かない文書では作らない。
   if (unexplained.size < options.limit) return [];
-  const bare = [...firstHits(outsideDates(hits, dateSpans(doc)))].filter(([acronym]) => unexplained.has(acronym));
+  const bare = [...firstHits(outsideSpans(hits, dateSpans(doc)))].filter(([acronym]) => unexplained.has(acronym));
   if (bare.length < options.limit) return [];
   return bare.map(([acronym, hit]) => ({
     rule: "undefined-acronym",

package/src/detectors/structure-tree.ts

@@ -6,6 +6,7 @@ import { dateOrderBreaks } from "../structure/date-order.ts";
 import { totalMismatches, type Amount } from "../structure/total.ts";
 import { rangeFrameOf, reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
 import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
+import { isQuotedAlone } from "../quoted-span.ts";
 
 const QUOTE_LENGTH = 80;
 
@@ -42,22 +43,43 @@ const dayName = (doc: ProseDocument, day: unknown): string => {
   return doc.lexicons["weekday"]?.[index]?.pattern ?? String(index);
 };
 
-export const dateWeekdayMismatch: Detector = (doc): Finding[] =>
-  doc.structure === undefined
-    ? []
-    : weekdayMismatches(doc.structure).map((issue) => ({
-        rule: "date-weekday-mismatch",
-        severity: "error",
-        line: 0,
-        column: 0,
-        quote: quoteAt(doc.source, issue.offset),
-        values: {
-          date: String(issue.values["date"]),
-          written: dayName(doc, issue.values["written"]),
-          actual: dayName(doc, issue.values["actual"]),
-          offset: issue.offset,
-        },
-      }));
+const datedSpans = (tree: NonNullable<ProseDocument["structure"]>): DatedSpan[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
+
+/** 引用符の中で日付の横にあってよい語は、曜日の一語だけ（"Monday, December 5, 2026"、「2026年12月5日（月）」）。 */
+const WEEKDAY_WORDS = 1;
+
+/**
+ * 引用符で日付だけを挙げたもの（"Monday, December 5, 2026" falls on a Saturday）は、誤りの例で、文書の日付ではない。
+ * from から until の日付の終わりまでを見る。
+ */
+const quotedDates = (doc: ProseDocument, from: DatedSpan | undefined, until: DatedSpan | undefined, wordsBesides = 0): boolean =>
+  from !== undefined && until !== undefined && isQuotedAlone(doc.source, { start: from.offset, end: until.end }, wordsBesides);
+
+const dateAt = (dates: readonly DatedSpan[], offset: number): number => dates.findIndex((date) => date.offset === offset);
+
+export const dateWeekdayMismatch: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const dates = datedSpans(doc.structure);
+  return weekdayMismatches(doc.structure)
+    .filter((issue) => {
+      const date = dates[dateAt(dates, issue.offset)];
+      return !quotedDates(doc, date, date, WEEKDAY_WORDS);
+    })
+    .map((issue) => ({
+      rule: "date-weekday-mismatch",
+      severity: "error",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: {
+        date: String(issue.values["date"]),
+        written: dayName(doc, issue.values["written"]),
+        actual: dayName(doc, issue.values["actual"]),
+        offset: issue.offset,
+      },
+    }));
+};
 
 /** 木の日付を、原文の位置と一緒に並べる。 */
 const datedPoints = (tree: NonNullable<ProseDocument["structure"]>): { offset: number; value: string }[] =>
@@ -99,9 +121,6 @@ export const totalMismatch: Detector = (doc): Finding[] =>
         values: { ...issue.values, offset: issue.offset },
       }));
 
-const datedSpans = (tree: NonNullable<ProseDocument["structure"]>): DatedSpan[] =>
-  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
-
 const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
   connectors: (doc.lexicons["range-connector"] ?? []).map((entry) => entry.pattern),
   openers: (doc.lexicons["range-opener"] ?? []).map((entry) => entry.pattern),
@@ -111,17 +130,23 @@ const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
 });
 
 /** 期間の終わりが始まりより前。範囲の記号と語は言語パッケージの語彙表（range-connector、range-opener、range-closer）から取る。 */
-export const dateRangeReversed: Detector = (doc): Finding[] =>
-  doc.structure === undefined
-    ? []
-    : reversedRanges(doc.source, datedSpans(doc.structure), rangeWordsOf(doc)).map((issue) => ({
-        rule: "date-range-reversed",
-        severity: "warning",
-        line: 0,
-        column: 0,
-        quote: quoteAt(doc.source, issue.offset),
-        values: { ...issue.values, offset: issue.offset },
-      }));
+export const dateRangeReversed: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const dates = datedSpans(doc.structure);
+  return reversedRanges(doc.source, dates, rangeWordsOf(doc))
+    .filter((issue) => {
+      const start = dateAt(dates, issue.offset);
+      return !quotedDates(doc, dates[start], dates[start + 1]);
+    })
+    .map((issue) => ({
+      rule: "date-range-reversed",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: { ...issue.values, offset: issue.offset },
+    }));
+};
 
 const shareWordsOf = (doc: ProseDocument): ShareWords => ({
   labels: (doc.lexicons["share-label"] ?? []).map((entry) => entry.pattern),

package/src/detectors/technical-docs.ts

@@ -4,6 +4,7 @@
 // shell-prompt lexicons.
 import { codeFences, codeSpans, type CodeFence } from "./code-fences.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { escapeRegExp } from "../orthography.ts";
 import type { Detector, Finding, ProseDocument, Span, Token } from "../plugin.ts";
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
@@ -112,10 +113,22 @@ export const commandsIn = (heading: string): string[] => {
 const collapse = (text: string): string => text.replace(/\s+/gu, " ");
 const OPTION_CHAR = /[A-Za-z0-9_-]/u;
 
+/**
+ * A command with arguments whose program the code runs under its package's name: chaff grade as npx chaffjs grade,
+ * python -m venv as python3 -m venv. The arguments must follow as written.
+ */
+const showsUnderPackageName = (text: string, wanted: string): boolean => {
+  const [program = "", ...rest] = wanted.split(" ");
+  if (rest.length === 0) return false;
+  const pattern = `(?<![A-Za-z0-9_.-])${escapeRegExp(program)}[A-Za-z0-9_.-]* ${rest.map(escapeRegExp).join(" ")}(?![A-Za-z0-9_-])`;
+  return new RegExp(pattern, "u").test(text);
+};
+
 /** Whether the code holds the command as a whole word: --force is not --force-with-lease, init is not initial. */
 export const showsCommand = (code: string, command: string): boolean => {
   const text = collapse(code);
   const wanted = collapse(command.trim());
+  if (showsUnderPackageName(text, wanted)) return true;
   const state = { at: text.indexOf(wanted) };
   while (state.at !== -1) {
     const before = text.charAt(state.at - 1);

package/src/detectors/unit-spacing.ts

@@ -0,0 +1,71 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { formMinority } from "./form-minority.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// One document writing a number and a unit symbol both with a space between them ("5 GB") and without ("5GB"). Neither is
+// called right; per unit, the less common way is reported. The symbols come from each language's lexicon "unit-symbol".
+
+/** A number and its unit as written. form is "spaced" or "touching". */
+export type WrittenQuantity = { readonly offset: number; readonly written: string; readonly unit: string; readonly form: string };
+
+/** The less common way for one unit, with an example of the usual way and how many quantities of that unit there are. */
+export type UnitMinority = { readonly odd: WrittenQuantity; readonly usual: string; readonly count: number; readonly of: number };
+
+// Grouping commas, then at most one decimal point: 1.2.3 is a version, not a number.
+const NUMBER = "[0-9]+(?:,[0-9]{3})*(?:\\.[0-9]+)?";
+// A plain space, a no-break space or a narrow no-break space (the SI brochure's thin space between number and unit).
+const GAP = "[ \\u00A0\\u202F]?";
+
+/**
+ * Numbers followed by a unit symbol, at most one space between. The number must not be part of a word, a version or an
+ * address (v1.2GB, x86, 1.2.3GB), nor follow a hyphen: "10-8 cm" is as often a lost exponent as a range (5–10 GB, with
+ * an en dash, is read). The symbol must not run on into a word, a rate or a file name (5 GBit, 5 GB/s, 5GB.zip).
+ */
+export const quantitiesIn = (text: string, symbols: readonly string[]): WrittenQuantity[] => {
+  if (symbols.length === 0) return [];
+  const units = symbols
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+  const pattern = new RegExp(`(?<![A-Za-z0-9_.,/:#-])${NUMBER}(?<gap>${GAP})(?<unit>${units})(?![A-Za-z0-9_/]|\\.[A-Za-z0-9_])`, "gu");
+  return [...text.matchAll(pattern)].map((match) => ({
+    offset: match.index,
+    written: match[0],
+    unit: match.groups?.["unit"] ?? "",
+    form: match.groups?.["gap"] === "" ? "touching" : "spaced",
+  }));
+};
+
+const minorityOf = (ofUnit: readonly WrittenQuantity[], limit: number): UnitMinority[] => {
+  const minority = formMinority(ofUnit, limit);
+  if (minority === undefined) return [];
+  return minority.odd.map((quantity) => ({ odd: quantity, usual: minority.usual.written, count: minority.odd.length, of: ofUnit.length }));
+};
+
+/** Per unit, the quantities written the less common way. "5 GB" and "500ms" in one document are two units, each consistent. */
+export const unitMinorities = (quantities: readonly WrittenQuantity[], limit: number): UnitMinority[] =>
+  [...new Set(quantities.map((quantity) => quantity.unit))]
+    .flatMap((unit) =>
+      minorityOf(
+        quantities.filter((quantity) => quantity.unit === unit),
+        limit,
+      ),
+    )
+    .toSorted((left, right) => left.odd.offset - right.odd.offset);
+
+export const unitSpacing: Detector = (doc, options): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const quantities = quantitiesIn(
+    text,
+    (doc.lexicons["unit-symbol"] ?? []).map((entry) => entry.pattern),
+  );
+  return unitMinorities(quantities, options.limit).map(({ odd, usual, count, of }) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, odd.offset, odd.offset + odd.written.length),
+    values: { written: odd.written, usual, count, of, offset: odd.offset },
+  }));
+};

package/src/extension/load.ts

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import type { Config } from "../config/load.ts";
 import type { Detector, Lexicon, RuleDefinition } from "../plugin.ts";
 import type { StyleDefinition } from "../style-parse.ts";
+import type { GuideLayer } from "../genre-guide/layer.ts";
 import { customRulesOf } from "../custom/load.ts";
 import { withStyle } from "../config/style.ts";
 import { moduleDetector } from "./module-detector.ts";
@@ -33,6 +34,8 @@ export type Extensions = {
   readonly lexicons: Readonly<Record<string, Readonly<Record<string, Lexicon>>>>;
   /** The plugins' house styles. */
   readonly styles: readonly StyleDefinition[];
+  /** The plugins' changes to the genre guides, in the order chaff.yaml lists the plugins. */
+  readonly guides?: readonly GuideLayer[];
   readonly problems: readonly LoadProblem[];
   readonly pluginProblems: readonly PluginProblem[];
 };
@@ -85,6 +88,7 @@ const loadExtensions = async (config: Config): Promise<Extensions> => {
     rules: plugins.flatMap((plugin) => plugin.rules),
     lexicons: lexiconsByLanguage(plugins),
     styles: plugins.flatMap((plugin) => plugin.styles),
+    guides: plugins.flatMap((plugin) => (plugin.guide === undefined ? [] : [plugin.guide])),
     problems: modules.flatMap((entry) => ("problem" in entry.loaded ? [entry.loaded.problem] : [])),
     pluginProblems,
   };

package/src/extension/pack-read.ts

@@ -123,6 +123,7 @@ export const readPack = (dir: string, manifest: Readonly<Record<string, unknown>
       rules: rules.value,
       lexicons: lexicons.value,
       styles: styles.value,
+      ...(manifest["guide"] === undefined ? {} : { guide: manifest["guide"] }),
     },
   };
 };

package/src/extension/plugin-load.ts

@@ -19,7 +19,7 @@ export type LoadedPlugins = { readonly plugins: readonly ParsedPlugin[]; readonl
 /** pack: the folder of a rule pack (YAML only), which is read rather than imported. */
 type Located = { readonly origin: PluginOrigin; readonly pack?: string } | { readonly problem: PluginProblem };
 
-const problemOf = (kind: Exclude<PluginProblem["kind"], "rule">, plugin: string, detail = ""): { problem: PluginProblem } => ({
+const problemOf = (kind: Exclude<PluginProblem["kind"], "rule" | "guide">, plugin: string, detail = ""): { problem: PluginProblem } => ({
   problem: { kind, plugin, detail },
 });
 

package/src/extension/plugin-parse.ts

@@ -7,6 +7,7 @@ import type { UntrustedDetector } from "./module-detector.ts";
 import { describeValue } from "./returned-findings.ts";
 import { isPluginName } from "./plugin-name.ts";
 import { knownGenres } from "../known-genres.ts";
+import { guideLayerOf, type GuideLayer, type GuideProblem } from "../genre-guide/layer.ts";
 
 // What a plugin package exports (api.ts PluginSpec), read into what chaff runs: its rules with ids under the plugin's
 // name, their detectors, its word lists and its house styles. A rule is read exactly like a rule in custom_rules, with
@@ -32,7 +33,8 @@ type PluginProblemKind =
 /** plugin: as chaff.yaml writes it. detail: what was there instead, the name expected, the rule, list or style at fault. */
 export type PluginProblem =
   | { readonly kind: PluginProblemKind; readonly plugin: string; readonly detail: string }
-  | { readonly kind: "rule"; readonly plugin: string; readonly problem: CustomProblem };
+  | { readonly kind: "rule"; readonly plugin: string; readonly problem: CustomProblem }
+  | { readonly kind: "guide"; readonly plugin: string; readonly problem: GuideProblem };
 
 /** Where a plugin came from: as chaff.yaml writes it, the file imported, and the name its package's name gives (none for a path). */
 export type PluginOrigin = { readonly written: string; readonly file: string; readonly expectedName: string | undefined };
@@ -47,11 +49,13 @@ export type ParsedPlugin = {
   /** Word lists by language, then by name with the plugin's prefix. */
   readonly lexicons: Readonly<Record<string, Readonly<Record<string, Lexicon>>>>;
   readonly styles: readonly StyleDefinition[];
+  /** Its changes to the genre guides, applied whenever the plugin is loaded: under a style's and chaff.yaml's. */
+  readonly guide?: GuideLayer | undefined;
 };
 
 export type PluginRead = { readonly plugin: ParsedPlugin | undefined; readonly problems: readonly PluginProblem[] };
 
-type Problem = (kind: Exclude<PluginProblem["kind"], "rule">, detail: string) => PluginProblem;
+type Problem = (kind: Exclude<PluginProblem["kind"], "rule" | "guide">, detail: string) => PluginProblem;
 
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
 
@@ -215,6 +219,16 @@ const stylesOf = (raw: unknown, name: string, problem: Problem): Styles => {
   };
 };
 
+// ───────── guide ─────────
+
+type Guide = { readonly guide: GuideLayer | undefined; readonly problems: readonly PluginProblem[] };
+
+const guideOf = (raw: unknown, name: string, written: string): Guide => {
+  if (raw === undefined) return { guide: undefined, problems: [] };
+  const read = guideLayerOf(raw, `plugins: ${name}`, knownGenres());
+  return { guide: read.layer, problems: read.problems.map((problem) => ({ kind: "guide", plugin: written, problem })) };
+};
+
 // ───────── the plugin ─────────
 
 /** A plugin's default export, read. Every problem is reported; a plugin with any is left out whole, and the run is stopped. */
@@ -229,8 +243,17 @@ export const parsePlugin = (exported: unknown, origin: PluginOrigin, useFor: rea
   const lexicons = lexiconsOf(exported["lexicons"], name, problem);
   const rules = rulesOf(exported["rules"], { name, origin, useFor, lists: lexicons.lists });
   const styles = stylesOf(exported["styles"], name, problem);
-  const problems = [...rules.problems, ...lexicons.problems, ...styles.problems];
+  const guide = guideOf(exported["guide"], name, origin.written);
+  const problems = [...rules.problems, ...lexicons.problems, ...styles.problems, ...guide.problems];
   if (problems.length > 0) return { plugin: undefined, problems };
-  const plugin = { name, written: origin.written, rules: rules.rules, detectors: rules.detectors, lexicons: lexicons.lexicons, styles: styles.styles };
+  const plugin = {
+    name,
+    written: origin.written,
+    rules: rules.rules,
+    detectors: rules.detectors,
+    lexicons: lexicons.lexicons,
+    styles: styles.styles,
+    ...(guide.guide === undefined ? {} : { guide: guide.guide }),
+  };
   return { plugin, problems: [] };
 };