chaffjs 0.19.0 → 0.21.0

package/src/detectors/impossible-time.ts

@@ -0,0 +1,151 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 時計に無い時刻（午後13時、13 PM、10:75、9時75分）。午前・午後が付けば時は 12 まで、分と秒は 59 まで。
+// 午前・午後の語とその置き場所は語彙表 clock-meridiem、時・分・秒の単位は date-time-unit（大きい順の四つ目から）が言う。
+// 午前・午後の無い「25:00」は、深夜の番組表のように 24 を超えて数える書き方があるので言わない。
+
+/** 時刻を読むのに要る語。before は時刻の前に書く午前・午後、after は後ろに書く AM・PM、units は時・分・秒の単位。 */
+export type ClockWords = { readonly before: readonly string[]; readonly after: readonly string[]; readonly units: readonly string[] };
+
+/** 時計に無い時刻 1 つ。reason は、午前・午後の付いた時が 12 を超える（hour）か、分か秒が 59 を超える（minute）か。 */
+export type ImpossibleTime = { readonly offset: number; readonly written: string; readonly reason: "hour" | "minute" };
+
+const DIGIT = "[0-9０-９]";
+const COLON = "[:：]";
+/** 数の前後に来ない字。英字の語や番号の中（abc10:75、v10:75）は時刻ではない。日本語の字のすぐ後ろ（会議は10:75）は読む。 */
+const NOT_AFTER_CLOCK = "(?<![A-Za-z0-9０-９_:：.])";
+const NOT_BEFORE_CLOCK = "(?![A-Za-z0-9０-９_:：])";
+const HALF_DAY = 12;
+const MINUTES_IN_HOUR = 60;
+/** 午前・午後の付いた時で、時刻の書き損じと読む上限。50 pm（ピコメートル）のような量を時刻と読まない。 */
+const HOURS_IN_DAY = 24;
+const FULLWIDTH_OFFSET = 0xfee0;
+
+const halfWidth = (text: string): string => text.replace(/[０-９]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - FULLWIDTH_OFFSET));
+
+type Groups = Readonly<Record<string, string | undefined>>;
+
+const numberIn = (groups: Groups, name: string): number | undefined => {
+  const written = groups[name];
+  return written === undefined ? undefined : Number(halfWidth(written));
+};
+
+/** 分か秒が 59 を超えるか。 */
+const isPastMinute = (groups: Groups): boolean =>
+  ["m", "colonMinute", "s"].some((name) => {
+    const value = numberIn(groups, name);
+    return value !== undefined && value >= MINUTES_IN_HOUR;
+  });
+
+/** 午前・午後の付いた時が 12 を超えるか（24 まで）。 */
+const isPastHalfDay = (groups: Groups): boolean => {
+  const hour = numberIn(groups, "h") ?? 0;
+  return hour > HALF_DAY && hour <= HOURS_IN_DAY;
+};
+
+/** 時刻の書き方と、その中の書き損じの見分け方。 */
+type Shape = { readonly pattern: RegExp; readonly problem: (groups: Groups, text: string, at: number) => ImpossibleTime["reason"] | undefined };
+
+const withMeridiem = (groups: Groups): ImpossibleTime["reason"] | undefined => {
+  if (isPastHalfDay(groups)) return "hour";
+  return isPastMinute(groups) ? "minute" : undefined;
+};
+
+const minutesOnly = (groups: Groups): ImpossibleTime["reason"] | undefined => (isPastMinute(groups) ? "minute" : undefined);
+
+/** 「Genesis 24:67」「Science, 12:75」のような章と節、巻と頁は時刻ではない。頭が大文字の語や区切りの印のすぐ後ろは読まない。 */
+const isCitationBefore = (before: string): boolean => {
+  const trimmed = before.trimEnd();
+  if ([",", ";", "."].includes(trimmed.slice(-1))) return true;
+  const lastWord = trimmed.split(/\s/u).at(-1) ?? "";
+  return /^\p{Lu}/u.test(lastWord);
+};
+
+/** 時を 2 以上か 0 埋め（09:75）で書いた、時と分だけの時刻。1:75 は縮尺や比。 */
+const bareClock = (groups: Groups, text: string, at: number): ImpossibleTime["reason"] | undefined => {
+  const hourText = groups["h"] ?? "";
+  const hour = Number(halfWidth(hourText));
+  const looksLikeClock = hour <= HOURS_IN_DAY && (hour >= 2 || /^[0０]/u.test(hourText));
+  if (!looksLikeClock || isCitationBefore(text.slice(Math.max(0, at - HALF_DAY), at))) return undefined;
+  return minutesOnly(groups);
+};
+
+const alternation = (words: readonly string[]): string => words.map(escapeRegExp).join("|");
+
+const meridiemShapes = (words: ClockWords): Shape[] => {
+  const [hourUnit, minuteUnit] = words.units.map(escapeRegExp);
+  const before = alternation(words.before);
+  const after = alternation(words.after);
+  const minuteTail = minuteUnit === undefined ? "" : `(?:\\s?(?<m>${DIGIT}{1,2})${minuteUnit})?`;
+  const unitTail = hourUnit === undefined ? "" : `${hourUnit}${minuteTail}|`;
+  return [
+    ...(after === ""
+      ? []
+      : [
+          {
+            pattern: new RegExp(`${NOT_AFTER_CLOCK}(?<![,])(?<h>${DIGIT}{1,2})(?:${COLON}(?<m>${DIGIT}{2}))?\\s?(?:${after})(?![\\p{L}\\p{N}])`, "gu"),
+            problem: withMeridiem,
+          },
+        ]),
+    ...(before === ""
+      ? []
+      : [{ pattern: new RegExp(`(?:${before})\\s?(?<h>${DIGIT}{1,2})(?:${unitTail}[:：](?<colonMinute>${DIGIT}{2}))`, "gu"), problem: withMeridiem }]),
+  ];
+};
+
+const unitShapes = (words: ClockWords): Shape[] => {
+  const [hourUnit, minuteUnit, secondUnit] = words.units.map(escapeRegExp);
+  if (hourUnit === undefined || minuteUnit === undefined) return [];
+  const seconds = secondUnit === undefined ? "" : `(?:\\s?(?<s>${DIGIT}{1,2})${secondUnit})?`;
+  return [{ pattern: new RegExp(`(?<!${DIGIT})(?<h>${DIGIT}{1,2})${hourUnit}\\s?(?<m>${DIGIT}{1,2})${minuteUnit}${seconds}`, "gu"), problem: minutesOnly }];
+};
+
+const shapesOf = (words: ClockWords): Shape[] => [
+  ...meridiemShapes(words),
+  ...unitShapes(words),
+  {
+    pattern: new RegExp(`${NOT_AFTER_CLOCK}(?<h>${DIGIT}{1,3})${COLON}(?<m>${DIGIT}{2})${COLON}(?<s>${DIGIT}{2})${NOT_BEFORE_CLOCK}`, "gu"),
+    problem: minutesOnly,
+  },
+  { pattern: new RegExp(`${NOT_AFTER_CLOCK}(?<![,/])(?<h>${DIGIT}{1,2})${COLON}(?<m>${DIGIT}{2})${NOT_BEFORE_CLOCK}`, "gu"), problem: bareClock },
+];
+
+const impossibleIn = (text: string, shape: Shape): ImpossibleTime[] =>
+  [...text.matchAll(shape.pattern)].flatMap((match) => {
+    const reason = shape.problem(match.groups ?? {}, text, match.index);
+    return reason === undefined ? [] : [{ offset: match.index, written: match[0].trim(), reason }];
+  });
+
+const overlaps = (left: ImpossibleTime, right: ImpossibleTime): boolean =>
+  left.offset < right.offset + right.written.length && right.offset < left.offset + left.written.length;
+
+/** 文字列の中の、時計に無い時刻。重なる所に二つの形が当たれば、先の形（午前・午後の付いたもの）だけ。 */
+export const impossibleTimes = (text: string, words: ClockWords): ImpossibleTime[] =>
+  shapesOf(words)
+    .flatMap((shape) => impossibleIn(text, shape))
+    .reduce<ImpossibleTime[]>((kept, found) => (kept.some((earlier) => overlaps(earlier, found)) ? kept : [...kept, found]), [])
+    .toSorted((left, right) => left.offset - right.offset);
+
+const meridiemOf = (doc: ProseDocument, position: "before" | "after"): string[] =>
+  (doc.lexicons["clock-meridiem"] ?? []).filter((entry) => entry.position === position).map((entry) => entry.pattern);
+
+export const clockWordsOf = (doc: ProseDocument): ClockWords => ({
+  before: meridiemOf(doc, "before"),
+  after: meridiemOf(doc, "after"),
+  units: (doc.lexicons["date-time-unit"] ?? []).map((entry) => entry.pattern).slice(3),
+});
+
+export const impossibleTime: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  return impossibleTimes(text, clockWordsOf(doc)).map((found) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, found.offset, found.offset + found.written.length),
+    values: { written: found.written, offset: found.offset },
+    variant: found.reason,
+  }));
+};

package/src/detectors/index.ts

@@ -1,152 +1,20 @@
-import type { Detector } from "../plugin.ts";
-import { countPerSection } from "./count-per-section.ts";
-import { sentenceLength } from "./sentence-length.ts";
-import { headingEcho } from "./heading-echo.ts";
-import { repeatedHead } from "./repeated-head.ts";
-import { sentenceRhythm } from "./sentence-rhythm.ts";
-import { phraseCount, phraseMatch } from "./phrase-match.ts";
-import { agentlessPassive } from "./agentless-passive.ts";
-import { doubledWord } from "./doubled-word.ts";
-import { agreementSlip } from "./agreement-slip.ts";
-import { sentenceEnding } from "./sentence-ending.ts";
-import { doubledParticle, nounEnding } from "./token-shape.ts";
-import { kanjiRun, middleDot } from "./char-shape.ts";
-import { adverbDensity, conjunctionRun, expletive, titleCaseMix } from "./en-shape.ts";
-import { oxfordComma } from "./oxford-comma.ts";
-import { paragraphLength, paragraphVariance, preambleLength, ruleOfThree, sectionUniformity } from "./structure.ts";
-import { concreteEvidence, dashDensity, emojiDensity, ngramRepetition, undefinedAcronym } from "./signals.ts";
-import { aiTell, contractionMix, cushionDensity, hedging, repeatedConjunction, unqualifiedSuperlative } from "./lexicon.ts";
-import { internalJargon, properNounDensity, requiredSections } from "./team.ts";
-import { nameVariant } from "./name-variant.ts";
-import { latinSpacing, preferredTerm } from "./orthography.ts";
-import { straySpace } from "./stray-space.ts";
-import { announcedCount } from "./announced-count.ts";
-import { outsideAnnouncedList } from "./outside-announced-list.ts";
-import { danglingFigure } from "./dangling-figure.ts";
-import { nominalization } from "./nominalization.ts";
-import { requirementSmell } from "./requirement-smell.ts";
-import { requirementModal } from "./requirement-modal.ts";
-import { modalConflict } from "./modal-conflict.ts";
-import { vagueFigurePointer } from "./vague-figure-pointer.ts";
-import {
-  danglingReference,
-  dateOrder,
-  dateRangeReversed,
-  dateWeekdayMismatch,
-  duplicateDefinition,
-  numberingGap,
-  percentSumMismatch,
-  totalMismatch,
-} from "./structure-tree.ts";
-import { headingLevelSkip } from "./heading-level-skip.ts";
-import { imageAltText } from "./image-alt-text.ts";
-import { brokenLink } from "./broken-link.ts";
-import { urlRunOn } from "./url-run-on.ts";
-import { unbalancedBracket } from "./unbalanced-bracket.ts";
-import { doubledPunctuation } from "./doubled-punctuation.ts";
-import { kutotenConsistency } from "./kutoten-consistency.ts";
-import { hankakuKana } from "./hankaku-kana.ts";
-import { invisibleCharacter } from "./invisible-character.ts";
-import { spaceBeforePunctuation } from "./space-before-punctuation.ts";
-import { duplicateHeading } from "./duplicate-heading.ts";
-import { emptySection } from "./empty-section.ts";
-import { fullwidthAlnum } from "./fullwidth-alnum.ts";
-import { spellingVariety } from "./spelling-variety.ts";
-import { raNuki } from "./ra-nuki.ts";
-import { katakanaLongVowel } from "./long-vowel.ts";
-import { customPattern, customTokens, customWords } from "./custom.ts";
-import { boldLabelList } from "./bold-label.ts";
-import { acronymExpansionConflict, unusedDefinition, useBeforeDefinition } from "./definition-use.ts";
-import { assistantResidue, colonLeadIn, contrastFraming, openerDensity, openerPile, unfilledPlaceholder } from "./ai-phrasing.ts";
+import { extname, join } from "node:path";
+import type { CrossDetector, Detector } from "../plugin.ts";
+import { loadRegistry } from "./registry-load.ts";
+
+// Each detector is registered by its own file, registry/<how_to_find>.ts, so a new rule adds a file and edits no shared
+// list. A rule that compares the documents of one run registers in cross-registry/<how_to_find>.ts instead.
+
+const isDetector = (value: unknown): value is Detector => typeof value === "function";
+
+const isCrossDetector = (value: unknown): value is CrossDetector => typeof value === "function";
 
 /** rule 定義の how_to_find がここを引く。rule 側は実装を知らない。 */
-export const DETECTORS: Readonly<Record<string, Detector>> = {
-  "count-per-section": countPerSection,
-  "sentence-length": sentenceLength,
-  "heading-echo": headingEcho,
-  "repeated-head": repeatedHead,
-  "sentence-rhythm": sentenceRhythm,
-  "phrase-match": phraseMatch,
-  "phrase-count": phraseCount,
-  "agentless-passive": agentlessPassive,
-  "sentence-ending": sentenceEnding,
-  "noun-ending": nounEnding,
-  "doubled-particle": doubledParticle,
-  "doubled-word": doubledWord,
-  "agreement-slip": agreementSlip,
-  "kanji-run": kanjiRun,
-  "middle-dot": middleDot,
-  "adverb-density": adverbDensity,
-  expletive: expletive,
-  "conjunction-run": conjunctionRun,
-  "title-case-mix": titleCaseMix,
-  "oxford-comma": oxfordComma,
-  "paragraph-length": paragraphLength,
-  "paragraph-variance": paragraphVariance,
-  "section-uniformity": sectionUniformity,
-  "rule-of-three": ruleOfThree,
-  "preamble-length": preambleLength,
-  "emoji-density": emojiDensity,
-  "dash-density": dashDensity,
-  "ngram-repetition": ngramRepetition,
-  "undefined-acronym": undefinedAcronym,
-  "concrete-evidence": concreteEvidence,
-  hedging: hedging,
-  "cushion-density": cushionDensity,
-  "unqualified-superlative": unqualifiedSuperlative,
-  "repeated-conjunction": repeatedConjunction,
-  "ai-tell": aiTell,
-  "contrast-framing": contrastFraming,
-  "stock-transition": openerDensity,
-  "opener-pile": openerPile,
-  "colon-lead-in": colonLeadIn,
-  "assistant-residue": assistantResidue,
-  "unfilled-placeholder": unfilledPlaceholder,
-  "contraction-mix": contractionMix,
-  "internal-jargon": internalJargon,
-  "required-sections": requiredSections,
-  "proper-noun-density": properNounDensity,
-  "name-variant": nameVariant,
-  "preferred-term": preferredTerm,
-  "latin-spacing": latinSpacing,
-  "stray-space": straySpace,
-  "katakana-long-vowel": katakanaLongVowel,
-  "custom-words": customWords,
-  "custom-pattern": customPattern,
-  "custom-tokens": customTokens,
-  "dangling-reference": danglingReference,
-  "date-weekday-mismatch": dateWeekdayMismatch,
-  "date-order": dateOrder,
-  "total-mismatch": totalMismatch,
-  "numbering-gap": numberingGap,
-  "duplicate-definition": duplicateDefinition,
-  "announced-count": announcedCount,
-  "outside-announced-list": outsideAnnouncedList,
-  "dangling-figure": danglingFigure,
-  nominalization: nominalization,
-  "requirement-smell": requirementSmell,
-  "requirement-modal": requirementModal,
-  "modal-conflict": modalConflict,
-  "vague-figure-pointer": vagueFigurePointer,
-  "date-range-reversed": dateRangeReversed,
-  "percent-sum-mismatch": percentSumMismatch,
-  "heading-level-skip": headingLevelSkip,
-  "image-alt-text": imageAltText,
-  "broken-link": brokenLink,
-  "url-run-on": urlRunOn,
-  "unbalanced-bracket": unbalancedBracket,
-  "doubled-punctuation": doubledPunctuation,
-  "kutoten-consistency": kutotenConsistency,
-  "hankaku-kana": hankakuKana,
-  "invisible-character": invisibleCharacter,
-  "space-before-punctuation": spaceBeforePunctuation,
-  "duplicate-heading": duplicateHeading,
-  "empty-section": emptySection,
-  "fullwidth-alnum": fullwidthAlnum,
-  "spelling-variety": spellingVariety,
-  "ra-nuki": raNuki,
-  "bold-label-list": boldLabelList,
-  "unused-definition": unusedDefinition,
-  "use-before-definition": useBeforeDefinition,
-  "acronym-expansion-conflict": acronymExpansionConflict,
-};
+export const DETECTORS: Readonly<Record<string, Detector>> = loadRegistry(join(import.meta.dirname, "registry"), extname(import.meta.filename), isDetector);
+
+/** The detectors of the rules that compare the documents of one run (requires: [documents]), by how_to_find. */
+export const CROSS_DETECTORS: Readonly<Record<string, CrossDetector>> = loadRegistry(
+  join(import.meta.dirname, "cross-registry"),
+  extname(import.meta.filename),
+  isCrossDetector,
+);

package/src/detectors/invisible-character.ts

@@ -80,8 +80,8 @@ const CANCEL_TAG = String.fromCodePoint(0xe007f);
 
 /** タグ文字の並びをさかのぼった先が黒い旗で、並びが取り消しのタグ（U+E007F）で閉じていれば、地域の旗の中。 */
 const isInFlag = (source: string, at: number): boolean => {
-  const before = [...source.slice(Math.max(0, at - FLAG_REACH), at)];
-  const after = [...source.slice(at, at + FLAG_REACH)];
+  const before = Array.from(source.slice(Math.max(0, at - FLAG_REACH), at));
+  const after = Array.from(source.slice(at, at + FLAG_REACH));
   const closing = after.findIndex((char) => !TAG.test(char) || char === CANCEL_TAG);
   return before[before.findLastIndex((char) => !TAG.test(char))] === BLACK_FLAG && after[closing] === CANCEL_TAG;
 };
@@ -185,6 +185,6 @@ export const invisibleCharacter: Detector = (doc): Finding[] =>
     line: 0,
     column: 0,
     quote: visibleQuote(doc.source, run.span),
-    values: { code: run.codes.join(" "), count: [...doc.source.slice(run.span.start, run.span.end)].length, offset: run.span.start },
+    values: { code: run.codes.join(" "), count: Array.from(doc.source.slice(run.span.start, run.span.end)).length, offset: run.span.start },
     variant: run.kind,
   }));

package/src/detectors/katakana-density.ts

@@ -0,0 +1,62 @@
+import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
+import { proseText } from "../measure.ts";
+import { rateOver } from "./lexicon.ts";
+
+/** A katakana word, full or half width: two or more katakana, not starting with the long-vowel mark. A middle dot (ジョン・スミス) splits it. */
+const KATAKANA_WORD = /[ァ-ヴ][ァ-ヴー]+|[ｦ-ﾝ][ｦ-ﾟ]+/gu;
+
+/** A line break inside a katakana word (アジェ↵ンダ): a wrapped line, not two words. */
+const WRAP_IN_WORD = /(?<=[ァ-ヴーｦ-ﾟ])[^\S\n]*\n[^\S\n]*(?=[ァ-ヴーｦ-ﾟ])/gu;
+
+/** How many of the most frequent words the message names. */
+const NAMED_WORDS = 3;
+
+type KatakanaWord = { readonly sentence: Sentence; readonly word: string };
+
+/** The text with each of the team's names (chaff.yaml names:) blanked out, longest first: a name is not a loanword to trim. */
+const withoutNames = (text: string, names: readonly string[]): string =>
+  names
+    .filter((name) => name !== "")
+    .toSorted((left, right) => right.length - left.length)
+    .reduce((rest, name) => rest.replaceAll(name, " "), text);
+
+/** The katakana words of one sentence's text, a line wrapped inside a word joined back, the team's names left out. */
+export const katakanaWordsIn = (text: string, names: readonly string[]): string[] =>
+  [...withoutNames(text.replace(WRAP_IN_WORD, ""), names).matchAll(KATAKANA_WORD)].map((match) => match[0]);
+
+/** The words used most, most frequent first; ties keep the order they first appear in. */
+export const mostFrequent = (words: readonly string[], count: number): string[] => {
+  const tally = words.reduce((counts, word) => counts.set(word, (counts.get(word) ?? 0) + 1), new Map<string, number>());
+  return [...tally.entries()]
+    .toSorted((left, right) => right[1] - left[1])
+    .slice(0, count)
+    .map(([word]) => word);
+};
+
+const wordsOfDocument = (doc: ProseDocument): KatakanaWord[] =>
+  doc.sentences.flatMap((sentence) => katakanaWordsIn(sentence.text, doc.names ?? []).map((word) => ({ sentence, word })));
+
+/**
+ * Katakana loanwords per 1000 characters, over the whole document. Reported once, at the first sentence holding one, with the
+ * words used most: those are the ones a Japanese word could replace first. Short documents are not measured.
+ */
+export const katakanaDensity: Detector = (doc, options): Finding[] => {
+  const found = wordsOfDocument(doc);
+  const density = rateOver(doc, found.length, options.limit);
+  const first = found[0];
+  if (density === undefined || first === undefined) return [];
+  const words = mostFrequent(
+    found.map((hit) => hit.word),
+    NAMED_WORDS,
+  );
+  return [
+    {
+      rule: "katakana-density",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: proseText(first.sentence),
+      values: { count: found.length, density, limit: options.limit, words: words.join("、"), offset: first.sentence.span.start },
+    },
+  ];
+};

package/src/detectors/known-correction.ts

@@ -0,0 +1,89 @@
+import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence } from "../plugin.ts";
+import { entryRanges } from "./lexicon-match.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { correctionIn, editBetween, type Correction, type Edit } from "../correction-edit.ts";
+
+/** 語彙表の一組。pattern が誤った形、instead_of が正しい形。 */
+type Pair = { readonly entry: LexiconEntry; readonly wrong: string; readonly edit: Edit };
+
+/** 見つけた誤り 1 つ。offset は文書の上の位置。 */
+type Hit = { readonly sentence: Sentence; readonly offset: number; readonly correction: Correction };
+
+const pairsOf = (entries: readonly LexiconEntry[]): Pair[] =>
+  entries.flatMap((entry) =>
+    entry.instead_of === undefined || entry.pattern === "" ? [] : [{ entry, wrong: entry.pattern, edit: editBetween(entry.pattern, entry.instead_of) }],
+  );
+
+const LATIN_EDGE = /[A-Za-z0-9]/u;
+
+/** 英字の語は語の途中に当てない（"teh" は "Tehran" の中に無い）。かなと漢字は字で語の切れ目を決められないので、品詞が無ければ字の並びで照らす。 */
+const wordPattern = (wrong: string): RegExp => {
+  const before = LATIN_EDGE.test(wrong.charAt(0)) ? "(?<![\\p{L}\\p{N}])" : "";
+  const after = LATIN_EDGE.test(wrong.charAt(wrong.length - 1)) ? "(?![\\p{L}\\p{N}])" : "";
+  return new RegExp(`${before}${escapeRegExp(wrong)}${after}`, "giu");
+};
+
+const hitAt = (sentence: Sentence, start: number, correction: Correction | undefined): Hit[] =>
+  correction === undefined ? [] : [{ sentence, offset: start, correction }];
+
+/** 品詞が無い文。字の並びで、英字の語の切れ目を守って照らす。指すのは当たった字全体。 */
+const textHits = (sentence: Sentence, pair: Pair): Hit[] =>
+  [...sentence.text.matchAll(wordPattern(pair.wrong))].flatMap((match) =>
+    hitAt(sentence, sentence.span.start + match.index, correctionIn(match[0], pair.wrong, pair.edit, [match[0].length])),
+  );
+
+/** 品詞のある文。語の並びで照らすので、語の途中には当たらない（「ですすべて」の「ですす」）。指すのは違う所を含む語まで。 */
+const tokenHits = (sentence: Sentence, pair: Pair, source: string): Hit[] => {
+  const tokens = sentence.tokens ?? [];
+  return entryRanges(sentence, pair.entry).flatMap((range) => {
+    const words = tokens.slice(range.start, range.end);
+    const start = words[0]?.span.start ?? 0;
+    const written = source.slice(start, words.at(-1)?.span.end ?? start);
+    const boundaries = words.map((word) => word.span.end - start);
+    return written === "" ? [] : hitAt(sentence, start, correctionIn(written, pair.wrong, pair.edit, boundaries));
+  });
+};
+
+/** 字の並びで当たった所のうち、両端が文の語の切れ目にあるもの。語彙表の語を解析器が文の中と違う切り方にした（「ますす」）ときの拾い直し。 */
+const alignedTextHits = (sentence: Sentence, pair: Pair): Hit[] => {
+  const tokens = sentence.tokens ?? [];
+  const starts = new Set(tokens.map((token) => token.span.start));
+  const ends = new Set(tokens.map((token) => token.span.end));
+  return textHits(sentence, pair).filter((hit) => starts.has(hit.offset) && ends.has(hit.offset + pair.wrong.length));
+};
+
+const hitsIn = (sentence: Sentence, pair: Pair, source: string): Hit[] => {
+  if (sentence.tokens === undefined || (pair.entry.tokens?.length ?? 0) === 0) return textHits(sentence, pair);
+  return [...tokenHits(sentence, pair, source), ...alignedTextHits(sentence, pair)];
+};
+
+/** チームが names に並べた名前の中の字（「黒ひげ危機一発」の「危機一発」）は、その字のまま正しい。 */
+const isInTeamName = (doc: ProseDocument, hit: Hit): boolean =>
+  (doc.names ?? []).some((name) =>
+    [...hit.sentence.text.matchAll(new RegExp(escapeRegExp(name), "giu"))].some((match) => {
+      const start = hit.sentence.span.start + match.index;
+      return start <= hit.offset && hit.offset + hit.correction.matched.length <= start + match[0].length;
+    }),
+  );
+
+/** 一つの所に二つの組が当たったら、語彙表で先に書いた組だけ。 */
+const firstAtEachOffset = (hits: readonly Hit[]): Hit[] => hits.filter((hit, at) => hits.findIndex((other) => other.offset === hit.offset) === at);
+
+/**
+ * 誤りと正しい形の組の語彙表（pattern が誤り、instead_of が正しい形）。文書の中で誤った形を見つけ、正しい形を添えて言う。
+ * どの組を誤りとするかは語彙表が決め、detector は語の切れ目と大文字と、組のどこが違うかだけを扱う。
+ */
+export const knownCorrection: Detector = (doc, options): Finding[] => {
+  const pairs = pairsOf(options.lexicon ?? []);
+  const hits = doc.sentences.flatMap((sentence) => pairs.flatMap((pair) => hitsIn(sentence, pair, doc.source)));
+  return firstAtEachOffset(hits.toSorted((left, right) => left.offset - right.offset))
+    .filter((hit) => !isInTeamName(doc, hit))
+    .map((hit) => ({
+      rule: "",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: hit.sentence.text.trim(),
+      values: { matched: hit.correction.matched, suggestion: hit.correction.suggestion, offset: hit.offset },
+    }));
+};

package/src/detectors/lexicon-match.ts

@@ -81,7 +81,7 @@ export const entryOpens = (sentence: Sentence, entry: LexiconEntry): boolean =>
 };
 
 /** Marks and closing brackets that may follow the last word of a sentence (こと。」, must.). */
-const TRAILING_MARKS = new Set([..." \t\n。．.!！?？」』)）\"'”’"]);
+const TRAILING_MARKS = new Set(" \t\n。．.!！?？」』)）\"'”’");
 
 const withoutTrailingMarks = (text: string): string => {
   const chars = [...text];

package/src/detectors/lexicon.ts

@@ -66,6 +66,9 @@ const densityRule =
 
 const hedgingDensity = densityRule("excessive-hedging");
 export const cushionDensity = densityRule("cushion-phrase-density", "at-floor");
+/** 語彙表の語の密度だけを見る rule が共通で使う。rule の id は実行側が入れる。 */
+export const phraseDensity = densityRule("");
+export const vagueDensity = densityRule("vague-word-density");
 
 /** 書いたとおりの字。行の折り返しをまたいでいたら空白 1 つに。 */
 const writtenAt = (source: string, span: Span): string => source.slice(span.start, span.end).replace(/\s+/gu, " ").trim();

package/src/detectors/link-shape.ts

@@ -0,0 +1,70 @@
+import type { Detector, Finding, Markup, ProseDocument, Span } from "../plugin.ts";
+import { findingAt, markupOf, quoteOf } from "./markup-finding.ts";
+import { linkTextOf } from "../link-text.ts";
+import { bareUrls } from "../bare-url.ts";
+import { isFileNameAlt, isUrlText, mismatchedHost } from "../link-shape.ts";
+import { minorityWithin } from "../orthography.ts";
+import { readMarkdown, spansOfType } from "../markdown-read.ts";
+
+/** A bare URL is reported only while bare URLs are at most this share of the document's links; past it, bare is a style. */
+const BARE_SHARE_PERCENT = 25;
+
+/** The link text, or undefined for an autolink, a definition or a link whose text is itself an address. */
+const wordedText = (source: string, link: Span): string | undefined => {
+  const text = linkTextOf(source.slice(link.start, link.end));
+  return text === undefined || text.trim() === "" || isUrlText(text) ? undefined : text;
+};
+
+/** An inline link the reader clicks on words (`[text](url)`). A reference definition's span does not show the words used with it, so it is not counted. */
+const isWorded = (source: string, link: Span): boolean => wordedText(source, link) !== undefined;
+
+/** A link destination the parser gave up on (`[a](https://…/{{ page }})`, a space in it): what is left is a link, not a bare URL. */
+const FAILED_DESTINATION = "](";
+
+const inside = (span: Span, regions: readonly Span[]): boolean => regions.some((region) => span.start >= region.start && span.start < region.end);
+
+/**
+ * The bare URLs the reader sees as text (outside links, code and quotations). A URL in a table cell is a value the table lists
+ * (an example request, a field's content), not a link the prose points to, so tables are left out.
+ */
+const bareUrlSpans = (source: string, markup: Markup): Span[] => {
+  const tables = spansOfType(readMarkdown(source).root, "table");
+  return markup.texts.flatMap((text) =>
+    bareUrls(source.slice(text.start, text.end))
+      .map((url) => ({ start: text.start + url.start, end: text.start + url.end }))
+      .filter((url) => !source.startsWith(FAILED_DESTINATION, url.start - FAILED_DESTINATION.length) && !inside(url, tables)),
+  );
+};
+
+type Address = Span & { readonly bare: boolean };
+
+/**
+ * A URL written bare (`https://…`) in a document whose other links are words (`[the guide](https://…)`). Reported only when the
+ * document has at least `limit` worded links and the bare ones are the few; a document that writes its URLs bare throughout is not.
+ */
+export const bareUrlMix: Detector = (doc: ProseDocument, options): Finding[] => {
+  const markup = markupOf(doc);
+  if (markup === undefined) return [];
+  const worded: Address[] = markup.links.filter((link) => isWorded(doc.source, link)).map((link) => ({ ...link, bare: false }));
+  if (worded.length < options.limit) return [];
+  const bare: Address[] = bareUrlSpans(doc.source, markup).map((url) => ({ ...url, bare: true }));
+  return minorityWithin([...worded, ...bare], (address) => address.bare, BARE_SHARE_PERCENT)
+    .filter((address) => address.bare)
+    .map((address) => findingAt(doc, address, { url: quoteOf(doc.source, address), count: worded.length }));
+};
+
+/** A link whose text is an address on one host and whose destination is on another (`[https://a.example](https://b.example)`). */
+export const linkTextUrlMismatch: Detector = (doc): Finding[] =>
+  (markupOf(doc)?.links ?? []).flatMap((link) => {
+    const text = linkTextOf(doc.source.slice(link.start, link.end));
+    const hosts = text === undefined ? undefined : mismatchedHost(text, link.destination);
+    return hosts === undefined ? [] : [findingAt(doc, link, hosts)];
+  });
+
+/** An image whose alt text is its file's name (`IMG_1234.png`, `Screenshot 2026-04-01`). The name prefixes come from the lexicon. */
+export const imageFileNameAlt: Detector = (doc, options): Finding[] => {
+  const prefixes = (options.lexicon ?? []).map((entry) => entry.pattern);
+  return (markupOf(doc)?.images ?? []).flatMap((image) =>
+    image.alt !== undefined && isFileNameAlt(image.alt, prefixes) ? [findingAt(doc, image, { alt: image.alt.trim() })] : [],
+  );
+};