chaffjs 0.17.0 → 0.19.0

package/src/email-parts.ts

@@ -0,0 +1,269 @@
+import type { Lexicon, Span } from "./plugin.ts";
+import { linesOf, type Line } from "./structure/lines.ts";
+
+/**
+ * The parts of a plain-text or Markdown email that are not the writer's prose: the header, the separator lines between
+ * messages, the signature, and a quoted reply. Found by shape, in any genre; the field names and the attribution words
+ * come from the language package's lexicons.
+ */
+export type EmailVocabulary = {
+  /** Header field names, lower-cased. */
+  readonly headerFields: ReadonlySet<string>;
+  /** The fields whose value the writer types (Subject, To), lower-cased. Their value stays prose, on a line of its own. */
+  readonly writtenFields: ReadonlySet<string>;
+  /** Words an attribution line ends with, before its colon ("wrote", 「書きました」). */
+  readonly attributions: readonly string[];
+  /** How an archive's note in place of a removed attachment ends ("was scrubbed...", 「を保管しました...」). */
+  readonly attachmentNotes: readonly string[];
+};
+
+export type EmailParts = {
+  /**
+   * Header lines (all of them but a written field's value), separator lines, signatures and attribution lines: masked
+   * from prose, and paragraphs are cut around them.
+   */
+  readonly furniture: readonly Span[];
+  /** An attribution line and the quoted lines after it: someone else's words, so not this document's headings or structure. */
+  readonly replyQuotes: readonly Span[];
+};
+
+const lowerCased = (lexicon: Lexicon | undefined): ReadonlySet<string> => new Set((lexicon ?? []).map((entry) => entry.pattern.toLowerCase()));
+
+export const emailVocabulary = (lexicons: Readonly<Record<string, Lexicon>>): EmailVocabulary => ({
+  headerFields: lowerCased(lexicons["email-header-field"]),
+  writtenFields: lowerCased(lexicons["email-written-field"]),
+  attributions: (lexicons["email-attribution"] ?? []).map((entry) => entry.pattern),
+  attachmentNotes: (lexicons["email-attachment-note"] ?? []).map((entry) => entry.pattern),
+});
+
+/** A signature has at most this many lines after its "-- " line (the convention is four). More is prose again. */
+const SIGNATURE_MAX_LINES = 4;
+/** An attribution paragraph longer than this is a paragraph of the writer's that happens to end with "wrote:". */
+const ATTRIBUTION_MAX_LINES = 3;
+/** Away from the top of a message, one known field ("Date: the first Monday") is a sentence; a header names several. */
+const HEADER_MIN_FIELDS = 2;
+/** An attachment stub is its note and a few fields: Mailman's longest is the note, Name, Type, Size, Desc and URL. */
+const ATTACHMENT_STUB_MAX_LINES = 6;
+
+/** "Field: value" or 「件名：値」. A colon followed by text, as in a URL, is not a field. */
+const FIELD = /^([^\s:：]{1,40})(?::(?:[ \t]+|$)|：[ \t]*)/u;
+const FOLDED = /^[ \t]+\S/u;
+/** An mbox archive's envelope line (RFC 4155): "From ", the sender, then the date. It has no colon after From. */
+const ENVELOPE = /^From [^\s:]+ /u;
+const SIGNATURE = /^-- ?$/u;
+/** A line of dashes, underscores or equals signs, with a few words between them or none: "-----Original Message-----". */
+const SEPARATOR = /^[-_=]{3,}(?:([^-_=]{1,40})[-_=]{2,})?$/u;
+/** Two rules with only spaces or strokes between them are a drawing (an RFC's diagram), not a separator. */
+const LETTER = /\p{L}/u;
+const QUOTED = /^ {0,3}>/u;
+const QUOTED_TEXT = /^ {0,3}>[\s>]*\S/u;
+/** Gmail's attribution ends with the sender's address and a colon: 「… 山田太郎 <taro@example.com>:」. An archive writes "taro at example.com". */
+const BRACKETED_THEN_COLON = /<([^<>]*)>[ \t]*[:：]$/u;
+const ADDRESS_MARK = /@| at /u;
+const LATIN_LETTER = /[A-Za-z]/u;
+/** The stub's last field: its value is a URL alone, bare or in angle brackets. */
+const URL_VALUE = /^<?[a-z][a-z0-9+.-]*:\/\/\S+?>?$/iu;
+
+const isBlank = (line: Line | undefined): boolean => line !== undefined && line.text.trim() === "";
+const isSeparator = (line: Line | undefined): boolean => {
+  const match = line === undefined ? null : SEPARATOR.exec(line.text.trim());
+  return match !== null && (match[1] === undefined || LETTER.test(match[1]));
+};
+const isQuoted = (line: Line | undefined): boolean => line !== undefined && QUOTED.test(line.text);
+const endOf = (line: Line): number => line.start + line.text.length;
+const spanOfLines = (first: Line, last: Line): Span => ({ start: first.start, end: endOf(last) });
+
+/** The first index at or after `from` whose line meets `test`, or -1. Scans forward only, so a long document stays linear. */
+const indexFrom = (lines: readonly Line[], from: number, test: (line: Line, index: number) => boolean): number => {
+  for (let index = Math.max(0, from); index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line !== undefined && test(line, index)) return index;
+  }
+  return -1;
+};
+
+/** The last index at or before `from` whose line meets `test`, or -1. */
+const indexBackFrom = (lines: readonly Line[], from: number, test: (line: Line) => boolean): number => {
+  for (let index = Math.min(from, lines.length - 1); index >= 0; index -= 1) {
+    const line = lines[index];
+    if (line !== undefined && test(line)) return index;
+  }
+  return -1;
+};
+
+/** Runs of lines between blank lines and separator lines. */
+const blocksOf = (lines: readonly Line[]): Line[][] =>
+  lines.reduce<Line[][]>((blocks, line, index) => {
+    if (isBlank(line) || isSeparator(line) || SIGNATURE.test(line.text)) return blocks;
+    const previous = lines[index - 1];
+    if (previous !== undefined && !isBlank(previous) && !isSeparator(previous) && !SIGNATURE.test(previous.text)) blocks.at(-1)?.push(line);
+    else blocks.push([line]);
+    return blocks;
+  }, []);
+
+/** The block opens a message: nothing but blank lines before it, or before it and the nearest separator line. */
+const opensMessage = (lines: readonly Line[], first: Line): boolean => {
+  const last = indexBackFrom(lines, first.number - 2, (line) => !isBlank(line));
+  return last === -1 || isSeparator(lines[last]);
+};
+
+const knownField = (text: string, vocabulary: EmailVocabulary): boolean => {
+  const name = FIELD.exec(text)?.[1];
+  return name !== undefined && vocabulary.headerFields.has(name.toLowerCase());
+};
+
+const isHeaderLine = (line: Line, index: number): boolean =>
+  FIELD.test(line.text) || (index > 0 && FOLDED.test(line.text)) || (index === 0 && ENVELOPE.test(line.text));
+
+const isHeader = (block: readonly Line[], atTop: boolean, vocabulary: EmailVocabulary): boolean => {
+  if (!block.every(isHeaderLine)) return false;
+  const known = block.filter((line) => knownField(line.text, vocabulary)).length;
+  if (known >= HEADER_MIN_FIELDS) return true;
+  // Fewer known fields make a header only at the top of a message, and only if no other field sits beside them: "Summary:" is the writer's.
+  return atTop && known > 0 && block.every((line) => !FIELD.test(line.text) || knownField(line.text, vocabulary));
+};
+
+/** A header's fields: each line with the folded lines under it. */
+const fieldsOf = (block: readonly Line[]): Line[][] =>
+  block.reduce<Line[][]>((fields, line, index) => {
+    if (index > 0 && FOLDED.test(line.text)) fields.at(-1)?.push(line);
+    else fields.push([line]);
+    return fields;
+  }, []);
+
+/** A written field loses only its label and keeps its value; any other field, and the envelope line, go whole. */
+const fieldMask = (field: readonly Line[], vocabulary: EmailVocabulary): Span | undefined => {
+  const first = field[0];
+  const last = field.at(-1);
+  if (first === undefined || last === undefined) return undefined;
+  const label = FIELD.exec(first.text);
+  const name = label?.[1]?.toLowerCase();
+  if (label === null || name === undefined || !vocabulary.writtenFields.has(name)) return spanOfLines(first, last);
+  return { start: first.start, end: first.start + label[0].length };
+};
+
+const headerSpans = (lines: readonly Line[], vocabulary: EmailVocabulary): Span[] =>
+  blocksOf(lines).flatMap((block) => {
+    const first = block[0];
+    if (first === undefined || !isHeader(block, opensMessage(lines, first), vocabulary)) return [];
+    return fieldsOf(block).flatMap((field) => fieldMask(field, vocabulary) ?? []);
+  });
+
+const isUrlField = (line: Line | undefined): boolean => {
+  const label = line === undefined ? null : FIELD.exec(line.text);
+  return line !== undefined && label !== null && URL_VALUE.test(line.text.slice(label[0].length).trim());
+};
+
+/**
+ * An archive's note where it removed an attachment: right after a separator, a line ending as the lexicon says, then
+ * only field lines, the last one a URL. Mailman's "An HTML attachment was scrubbed..." and its "URL: <…>" line.
+ */
+const isAttachmentStub = (lines: readonly Line[], block: readonly Line[], vocabulary: EmailVocabulary): boolean => {
+  const [note, ...fields] = block;
+  if (note === undefined || block.length > ATTACHMENT_STUB_MAX_LINES) return false;
+  const noteText = note.text.trim();
+  if (!vocabulary.attachmentNotes.some((ending) => noteText.endsWith(ending))) return false;
+  return fields.every((line) => FIELD.test(line.text)) && isUrlField(fields.at(-1)) && isSeparator(lines[note.number - 2]);
+};
+
+const attachmentStubSpans = (lines: readonly Line[], vocabulary: EmailVocabulary): Span[] =>
+  blocksOf(lines).flatMap((block) => {
+    const first = block[0];
+    const last = block.at(-1);
+    return first !== undefined && last !== undefined && isAttachmentStub(lines, block, vocabulary) ? [spanOfLines(first, last)] : [];
+  });
+
+/** From the "-- " line: the blank lines right after it, then its lines up to a blank line, a separator or a quote. */
+const signatureAt = (lines: readonly Line[], delimiter: Line): Span => {
+  const firstText = indexFrom(lines, delimiter.number, (line) => !isBlank(line));
+  if (firstText === -1) return spanOfLines(delimiter, delimiter);
+  const stop = indexFrom(
+    lines,
+    firstText,
+    (line, index) => index - firstText >= SIGNATURE_MAX_LINES || isBlank(line) || isSeparator(line) || isQuoted(line) || SIGNATURE.test(line.text),
+  );
+  return spanOfLines(delimiter, lines[(stop === -1 ? lines.length : stop) - 1] ?? delimiter);
+};
+
+const signatureSpans = (lines: readonly Line[]): Span[] => lines.filter((line) => SIGNATURE.test(line.text)).map((line) => signatureAt(lines, line));
+
+const endsWithAttribution = (text: string, vocabulary: EmailVocabulary): boolean => {
+  const trimmed = text.trimEnd();
+  if (ADDRESS_MARK.test(BRACKETED_THEN_COLON.exec(trimmed)?.[1] ?? "")) return true;
+  if (!/[:：]$/u.test(trimmed)) return false;
+  const words = trimmed.slice(0, -1).trimEnd();
+  return vocabulary.attributions.some((word) => {
+    if (!words.endsWith(word)) return false;
+    const before = words.at(-word.length - 1) ?? "";
+    return !(LATIN_LETTER.test(word.charAt(0)) && LATIN_LETTER.test(before));
+  });
+};
+
+/** The paragraph that ends right before `index`, skipping blank lines: its lines, if it is short enough to be an attribution. */
+const attributionBefore = (lines: readonly Line[], index: number, vocabulary: EmailVocabulary): Line[] | undefined => {
+  const lastText = indexBackFrom(lines, index - 1, (line) => !isBlank(line));
+  if (lastText === -1) return undefined;
+  const floor = lastText - ATTRIBUTION_MAX_LINES;
+  const window = lines.slice(Math.max(0, floor), lastText + 1);
+  const opening = window.findLastIndex((line) => isBlank(line) || isSeparator(line) || isQuoted(line));
+  if (opening === -1 && floor > 0) return undefined;
+  const paragraph = window.slice(opening + 1);
+  if (paragraph.length === 0 || paragraph.length > ATTRIBUTION_MAX_LINES) return undefined;
+  return endsWithAttribution(paragraph.map((line) => line.text.trim()).join(" "), vocabulary) ? paragraph : undefined;
+};
+
+/** A quoted line, or a line with text run on from a quoted line with text (a lazy continuation, as Markdown reads it). */
+const continuesQuote = (lines: readonly Line[], index: number): boolean => {
+  const line = lines[index];
+  if (isQuoted(line)) return true;
+  const previous = lines[index - 1];
+  return line !== undefined && !isBlank(line) && !isSeparator(line) && previous !== undefined && QUOTED_TEXT.test(previous.text);
+};
+
+/** The last line of the quote that starts at `index`. Blank lines between quoted lines stay inside it. */
+const quoteEnd = (lines: readonly Line[], index: number): number => {
+  const chunk = { start: index };
+  for (;;) {
+    const next = indexFrom(lines, chunk.start + 1, (_, at) => !continuesQuote(lines, at));
+    if (next === -1) return lines.length - 1;
+    const resumes = indexFrom(lines, next, (line) => !isBlank(line));
+    if (resumes === -1 || !isQuoted(lines[resumes])) return next - 1;
+    chunk.start = resumes;
+  }
+};
+
+const quoteStarts = (lines: readonly Line[]): number[] => lines.flatMap((line, index) => (isQuoted(line) && !continuesQuote(lines, index - 1) ? [index] : []));
+
+type Reply = { readonly attribution: Span; readonly quote: Span };
+
+const repliesOf = (lines: readonly Line[], vocabulary: EmailVocabulary): Reply[] =>
+  quoteStarts(lines).reduce<Reply[]>((replies, start) => {
+    const covered = replies.at(-1);
+    const line = lines[start];
+    if (line === undefined || (covered !== undefined && line.start < covered.quote.end)) return replies;
+    const attribution = attributionBefore(lines, start, vocabulary);
+    const first = attribution?.[0];
+    const last = attribution?.at(-1);
+    if (first === undefined || last === undefined) return replies;
+    const end = lines[quoteEnd(lines, start)];
+    if (end === undefined) return replies;
+    return [...replies, { attribution: spanOfLines(first, last), quote: spanOfLines(first, end) }];
+  }, []);
+
+const bySpanStart = (left: Span, right: Span): number => left.start - right.start;
+
+export const emailParts = (source: string, vocabulary: EmailVocabulary): EmailParts => {
+  const lines = linesOf(source);
+  const replies = repliesOf(lines, vocabulary);
+  const separators = lines.filter((line) => isSeparator(line)).map((line) => spanOfLines(line, line));
+  return {
+    furniture: [
+      ...headerSpans(lines, vocabulary),
+      ...attachmentStubSpans(lines, vocabulary),
+      ...separators,
+      ...signatureSpans(lines),
+      ...replies.map((reply) => reply.attribution),
+    ].toSorted(bySpanStart),
+    replyQuotes: replies.map((reply) => reply.quote),
+  };
+};

package/src/eval.ts

@@ -1,7 +1,9 @@
 import { DETECTORS } from "./detectors/index.ts";
 import { charLength } from "./measure.ts";
-import type { ProseDocument, RuleDefinition } from "./plugin.ts";
+import type { DetectorOptions, ProseDocument, RuleDefinition } from "./plugin.ts";
+import { optionValues, settleOptions, type OptionLayer } from "./rule-options.ts";
 import { missingList } from "./declared-lists.ts";
+import { bodySectionOf } from "./body-section.ts";
 
 /**
  * 閾値の較正。
@@ -44,12 +46,12 @@ const candidates = (rule: RuleDefinition, current: number): number[] => {
   return [...new Set([...fromLevels, ...scaled, current])].toSorted((left, right) => left - right);
 };
 
-const countAt = (docs: readonly ProseDocument[], rule: RuleDefinition, limit: number): Point => {
+const countAt = (docs: readonly ProseDocument[], rule: RuleDefinition, limit: number, settings: DetectorOptions["settings"]): Point => {
   const detector = DETECTORS[rule.how_to_find];
   if (detector === undefined) return { limit, findings: 0, documents: 0, per10k: 0 };
   const perDoc = docs.map((doc) => {
     const lexicon = rule.word_list === undefined ? undefined : doc.lexicons[rule.word_list];
-    return detector(doc, { limit, lexicon, where: rule.where }).length;
+    return detector(doc, { limit, lexicon, where: rule.where, settings }).length;
   });
   const findings = perDoc.reduce((sum, count) => sum + count, 0);
   const chars = docs.reduce((sum, doc) => sum + doc.sentences.reduce((inner, sentence) => inner + charLength(sentence), 0), 0);
@@ -71,6 +73,10 @@ const meets = (need: string, docs: readonly ProseDocument[]): boolean => {
   if (need === "lemma") return capabilities?.lemma === true;
   // 木は adapter が structure を持つときだけ作れる。無いまま測ると、どの閾値でも 0 件になる。
   if (need === "structure") return docs.length > 0 && docs.every((doc) => doc.structure !== undefined);
+  // 見出しの無い文書では lint が動かない。見出しのある文書が 1 つも無ければ、どの閾値でも 0 件になる。
+  if (need === "headings") return docs.some((doc) => bodySectionOf(doc.sections) !== undefined);
+  // 記法を読む rule は Markdown の文書でしか動かない。
+  if (need === "markdown") return docs.some((doc) => doc.markup?.markdown === true);
   return false;
 };
 
@@ -80,6 +86,8 @@ const meets = (need: string, docs: readonly ProseDocument[]): boolean => {
  */
 const measurable = (rule: RuleDefinition, docs: readonly ProseDocument[], genre: string, language: string): boolean => {
   if (rule.layer === "L4" || !rule.use_for.some((target) => genre.startsWith(target))) return false;
+  // A rule with nothing to count has no limit to sweep: its levels set severity.
+  if (rule.level_sets === "severity") return false;
   if (rule.languages !== undefined && !rule.languages.includes(language)) return false;
   if (rule.from.length > 0) return false;
   if (docs.some((doc) => missingList(rule, doc.lexicons) !== undefined)) return false;
@@ -96,12 +104,14 @@ export const evaluate = (
   genre: string,
   language: string,
   limits: Readonly<Record<string, number>> = {},
+  optionLayers: readonly OptionLayer[] = [],
 ): RuleReport[] =>
   rules
     .filter((rule) => measurable(rule, docs, genre, language))
     .map((rule) => {
       const current = limits[rule.id] ?? rule.levels.normal ?? 1;
-      const sweep = candidates(rule, current).map((limit) => countAt(docs, rule, limit));
+      const settings = rule.options === undefined ? undefined : optionValues(settleOptions(rule.id, rule.options, optionLayers));
+      const sweep = candidates(rule, current).map((limit) => countAt(docs, rule, limit, settings));
       return {
         rule: rule.id,
         name: rule.name[language] ?? rule.id,

package/src/extension/document-view.ts

@@ -0,0 +1,109 @@
+import type * as Api from "../api.ts";
+import type { BulletList, Lexicon, Markup, Paragraph, ProseDocument, Section, Sentence, Span, Token } from "../plugin.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.
+
+const freezeAll = (value: unknown): void => {
+  if (typeof value !== "object" || value === null || Object.isFrozen(value)) return;
+  Object.values(value).forEach(freezeAll);
+  Object.freeze(value);
+};
+
+const deepFreeze = <T>(value: T): T => {
+  freezeAll(value);
+  return value;
+};
+
+const spanOf = (span: Span): Api.Span => ({ start: span.start, end: span.end });
+
+const tokenOf = (token: Token): Api.Token => ({
+  span: spanOf(token.span),
+  surface: token.surface,
+  pos: token.pos,
+  ...(token.lemma === undefined ? {} : { lemma: token.lemma }),
+  ...(token.reading === undefined ? {} : { reading: token.reading }),
+  ...(token.features === undefined ? {} : { features: { ...token.features } }),
+});
+
+/** Sentences are shared by the document, its paragraphs and its sections; each is copied once, so they stay one object. */
+type SentenceCopies = (sentence: Sentence) => Api.Sentence;
+
+const sentenceCopier = (): SentenceCopies => {
+  const copies = new Map<Sentence, Api.Sentence>();
+  return (sentence) => {
+    const known = copies.get(sentence);
+    if (known !== undefined) return known;
+    const copy = { span: spanOf(sentence.span), text: sentence.text, ...(sentence.tokens === undefined ? {} : { tokens: sentence.tokens.map(tokenOf) }) };
+    copies.set(sentence, copy);
+    return copy;
+  };
+};
+
+const paragraphOf = (paragraph: Paragraph, copy: SentenceCopies): Api.Paragraph => ({
+  span: spanOf(paragraph.span),
+  sentences: paragraph.sentences.map(copy),
+});
+
+const sectionOf = (section: Section, copy: SentenceCopies): Api.Section => ({
+  depth: section.depth,
+  heading: section.heading,
+  span: spanOf(section.span),
+  sentences: section.sentences.map(copy),
+});
+
+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 }) }));
+
+const markupOf = (markup: Markup): Api.Markup => ({
+  markdown: markup.markdown,
+  headings: markup.headings.map((heading) => ({ depth: heading.depth, text: heading.text, span: { start: heading.start, end: heading.end } })),
+  images: markup.images.map((image) => ({ alt: image.alt, span: { start: image.start, end: image.end } })),
+  links: markup.links.map((link) => ({ destination: link.destination, span: { start: link.start, end: link.end } })),
+  ids: [...markup.ids].toSorted((left, right) => left.localeCompare(right, "en")),
+  texts: markup.texts.map(spanOf),
+});
+
+const EMPTY_MARKUP: Markup = { markdown: false, headings: [], images: [], links: [], ids: new Set(), texts: [] };
+
+const viewOf = (doc: ProseDocument): Api.RuleDocument => {
+  const copy = sentenceCopier();
+  const fields = deepFreeze({
+    path: doc.path,
+    source: doc.source,
+    language: doc.language,
+    lengthUnit: doc.lengthUnit,
+    sentences: doc.sentences.map(copy),
+    paragraphs: doc.paragraphs.map((paragraph) => paragraphOf(paragraph, copy)),
+    sections: doc.sections.map((section) => sectionOf(section, copy)),
+    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)])),
+  });
+  // 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 };
+  return Object.freeze({
+    ...fields,
+    get markup(): Api.Markup {
+      markup.value ??= deepFreeze(markupOf(doc.markup ?? EMPTY_MARKUP));
+      return markup.value;
+    },
+  });
+};
+
+/** 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>();
+
+/** 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);
+  if (known !== undefined) return known;
+  const view = viewOf(doc);
+  views.set(doc, view);
+  return view;
+};

package/src/extension/failure-text.ts

@@ -0,0 +1,46 @@
+import type { Texts, UiLanguage } from "../ui.ts";
+import type { RuleFailure } from "./module-detector.ts";
+import type { ShapeProblem } from "./returned-findings.ts";
+
+// Why a plugin's rule is listed as not run on a document, in the reader's language. It names where the detector came
+// from, so the person who wrote it knows which file to open.
+
+type Text = {
+  readonly reason: (origin: string, what: string) => string;
+  readonly threw: (message: string) => string;
+  /** Each wrong return, with the finding's number and what was there. */
+  readonly shape: Readonly<Record<ShapeProblem["kind"], (index: string, written: string) => string>>;
+};
+
+const TEXT: Texts<Text> = {
+  ja: {
+    reason: (origin, what) => `${origin} の検出器が${what}ため`,
+    threw: (message) => `エラーを投げた（${message}）`,
+    shape: {
+      "not-a-list": (_index, written) => `指摘の並びでなく ${written} を返した`,
+      "not-a-finding": (index, written) => `${index} 番目の指摘に { start } の形でないもの（${written}）を返した`,
+      "bad-start": (index, written) => `${index} 番目の指摘の start に ${written} を返した（文書の中の位置を整数で返します）`,
+      "bad-end": (index, written) => `${index} 番目の指摘の end に ${written} を返した（start 以上、文書の長さ以下の整数で返します）`,
+      "bad-values": (index, written) => `${index} 番目の指摘の values に文字列と数でない値を入れた（${written}）`,
+    },
+  },
+  en: {
+    reason: (origin, what) => `the detector in ${origin} ${what}`,
+    threw: (message) => `threw an error (${message})`,
+    shape: {
+      "not-a-list": (_index, written) => `returned ${written}, not a list of findings`,
+      "not-a-finding": (index, written) => `returned ${written} as finding ${index}, not a { start } finding`,
+      "bad-start": (index, written) => `returned start ${written} in finding ${index} (an offset in the document, a whole number)`,
+      "bad-end": (index, written) => `returned end ${written} in finding ${index} (a whole number from start to the document's length)`,
+      "bad-values": (index, written) => `put a value that is not a string or a number in finding ${index}'s values (${written})`,
+    },
+  },
+};
+
+/** The reason a rule whose detector failed is listed as not run. */
+export const failureReason = (origin: string, failure: RuleFailure, ui: UiLanguage): string => {
+  const text = TEXT[ui];
+  if (failure.kind === "threw") return text.reason(origin, text.threw(failure.message));
+  const { kind, index, written } = failure.problem;
+  return text.reason(origin, text.shape[kind](String(index), written));
+};

package/src/extension/import-default.ts

@@ -0,0 +1,13 @@
+import { pathToFileURL } from "node:url";
+
+const firstLine = (error: unknown): string => (error instanceof Error ? error.message : String(error)).split("\n")[0] ?? "";
+
+/** A module's default export, or the first line of why it could not be imported (a syntax error, a missing import). Running it runs its code. */
+export const importDefault = async (file: string): Promise<{ readonly exported: unknown } | { readonly message: string }> => {
+  try {
+    const namespace: unknown = await import(pathToFileURL(file).href);
+    return { exported: typeof namespace === "object" && namespace !== null && "default" in namespace ? namespace.default : undefined };
+  } catch (error) {
+    return { message: firstLine(error) };
+  }
+};

package/src/extension/load.ts

@@ -0,0 +1,97 @@
+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 { customRulesOf } from "../custom/load.ts";
+import { withStyle } from "../config/style.ts";
+import { moduleDetector } from "./module-detector.ts";
+import { detectorExport, type ExportProblem } from "./rule-export.ts";
+import { importDefault } from "./import-default.ts";
+import { loadPlugins } from "./plugin-load.ts";
+import type { ParsedPlugin, PluginProblem } from "./plugin-parse.ts";
+import { staysInside } from "./real-path.ts";
+
+// The code chaff.yaml names, loaded once before anything runs: each type: module rule's file, and each plugin under
+// plugins:. Loading runs that code, which is why only chaff.yaml can name it. What cannot be loaded stops the run
+// (settingProblems), like a rule in custom_rules that cannot be read: a rule that silently does not run looks like a clean document.
+
+/** A rule whose file could not be loaded. file is the path as chaff.yaml writes it; detail: why, or what ExportProblem says. */
+export type LoadProblem = {
+  readonly kind: "missing-file" | "outside" | "import-failed" | ExportProblem["kind"];
+  readonly rule: string;
+  readonly file: string;
+  readonly detail: string;
+};
+
+/** What was loaded, and what could not be. */
+export type Extensions = {
+  /** The detector of each type: module rule and each plugin rule written in code, by the rule's id. */
+  readonly detectors: Readonly<Record<string, Detector>>;
+  /** The plugins' rules, with their ids under each plugin's name. */
+  readonly rules: readonly RuleDefinition[];
+  /** The plugins' word lists by language, then by name. */
+  readonly lexicons: Readonly<Record<string, Readonly<Record<string, Lexicon>>>>;
+  /** The plugins' house styles. */
+  readonly styles: readonly StyleDefinition[];
+  readonly problems: readonly LoadProblem[];
+  readonly pluginProblems: readonly PluginProblem[];
+};
+
+type Loaded = { readonly detector: Detector } | { readonly problem: LoadProblem };
+
+/** A type: module rule: its id, its file, and the path as chaff.yaml writes it, which every message names. */
+type ModuleRule = { readonly id: string; readonly file: string; readonly written: string };
+
+const loadRule = async ({ id, file, written }: ModuleRule, baseDir: string): Promise<Loaded> => {
+  const at = { rule: id, file: written };
+  if (!existsSync(file)) return { problem: { ...at, kind: "missing-file", detail: "" } };
+  if (!staysInside(written, file, baseDir)) return { problem: { ...at, kind: "outside", detail: "" } };
+  const imported = await importDefault(file);
+  if ("message" in imported) return { problem: { ...at, kind: "import-failed", detail: imported.message } };
+  const read = detectorExport(imported.exported);
+  return "problem" in read ? { problem: { ...at, ...read.problem } } : { detector: moduleDetector(read.detect, written) };
+};
+
+const moduleRulesOf = (rules: readonly RuleDefinition[]): ModuleRule[] =>
+  rules.flatMap((rule) => (rule.custom?.type === "module" ? [{ id: rule.id, file: rule.custom.file, written: rule.custom.module }] : []));
+
+/** Every type: module rule in chaff.yaml, loaded one by one in the order written, so the same chaff.yaml loads the same way. */
+const loadModuleRules = async (config: Config): Promise<readonly { readonly id: string; readonly loaded: Loaded }[]> =>
+  moduleRulesOf(customRulesOf(config).rules).reduce<Promise<{ id: string; loaded: Loaded }[]>>(
+    async (done, rule) => [...(await done), { id: rule.id, loaded: await loadRule(rule, config.baseDir) }],
+    Promise.resolve([]),
+  );
+
+/** A plugin's code rules, each run as one of chaff's; a failure names the plugin as chaff.yaml writes it. */
+const pluginDetectors = (plugin: ParsedPlugin): [string, Detector][] =>
+  Object.entries(plugin.detectors).map(([id, detect]) => [id, moduleDetector(detect, plugin.written)]);
+
+const lexiconsByLanguage = (plugins: readonly ParsedPlugin[]): Record<string, Record<string, Lexicon>> => {
+  const languages = [...new Set(plugins.flatMap((plugin) => Object.keys(plugin.lexicons)))];
+  return Object.fromEntries(
+    languages.map((language) => [language, plugins.reduce<Record<string, Lexicon>>((merged, plugin) => ({ ...merged, ...plugin.lexicons[language] }), {})]),
+  );
+};
+
+/** Everything chaff.yaml names in code, loaded. */
+const loadExtensions = async (config: Config): Promise<Extensions> => {
+  const modules = await loadModuleRules(config);
+  const { plugins, problems: pluginProblems } = await loadPlugins(config);
+  return {
+    detectors: Object.fromEntries([
+      ...modules.flatMap((entry): [string, Detector][] => ("detector" in entry.loaded ? [[entry.id, entry.loaded.detector]] : [])),
+      ...plugins.flatMap(pluginDetectors),
+    ]),
+    rules: plugins.flatMap((plugin) => plugin.rules),
+    lexicons: lexiconsByLanguage(plugins),
+    styles: plugins.flatMap((plugin) => plugin.styles),
+    problems: modules.flatMap((entry) => ("problem" in entry.loaded ? [entry.loaded.problem] : [])),
+    pluginProblems,
+  };
+};
+
+/** chaff.yaml with the code it names loaded, and the style it names applied when a plugin ships it. */
+export const withExtensions = async (config: Config): Promise<Config> => {
+  const extensions = await loadExtensions(config);
+  return withStyle({ ...config, extensions }, extensions.styles);
+};

package/src/extension/module-detector.ts

@@ -0,0 +1,61 @@
+import type * as Api from "../api.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { frozenLexiconOf, ruleDocumentOf } from "./document-view.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
+// returns is checked before chaff uses it. A throw or a wrong return is that rule's failure only: run.ts lists the rule
+// as not run with the reason, and every other rule still runs.
+
+/** A detector from a plugin. It is JavaScript nobody has type-checked against this chaff, so what it returns is unknown. */
+export type UntrustedDetector = (doc: Api.RuleDocument, options: Api.DetectorOptions) => unknown;
+
+export type RuleFailure = { readonly kind: "threw"; readonly message: string } | { readonly kind: "returned"; readonly problem: ShapeProblem };
+
+/** A plugin's rule that failed on a document. origin is where the detector came from: its file, or its package. */
+export class PluginRuleFailure extends Error {
+  readonly failure: RuleFailure;
+  readonly origin: string;
+  constructor(failure: RuleFailure, origin: string) {
+    super(`${origin}: ${failure.kind === "threw" ? failure.message : failure.problem.kind}`);
+    this.name = "PluginRuleFailure";
+    this.failure = failure;
+    this.origin = origin;
+  }
+}
+
+/** The first line of what was thrown. What a plugin throws is its own object, so printing it may throw too. */
+const messageOf = (error: unknown): string => {
+  try {
+    const text = error instanceof Error ? error.message : String(error);
+    return text.split("\n")[0] ?? text;
+  } catch {
+    return "an error that cannot be printed";
+  }
+};
+
+/**
+ * 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);
+  try {
+    const returned: unknown = detect(view, options);
+    if (returned instanceof Promise) returned.catch(() => undefined);
+    const result = returnedFindings(returned, doc.source, doc.sentences);
+    return "problem" in result ? { failure: { kind: "returned", problem: result.problem } } : { findings: [...result.findings] };
+  } catch (error) {
+    return { failure: { kind: "threw", message: messageOf(error) } };
+  }
+};
+
+/** detect as one of chaff's detectors. Throws PluginRuleFailure when it throws or returns anything but findings. */
+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 }));
+    if ("failure" in outcome) throw new PluginRuleFailure(outcome.failure, origin);
+    return outcome.findings;
+  };