@jpeakai/prose-gates 0.1.1 → 0.2.0

package/src/rules/list-inline-enumeration-markers.ts

@@ -0,0 +1,127 @@
+// list-inline-enumeration-markers: parenthesised enumerators inlined in one paragraph are a hidden
+// list. Requiring the first two members of a family keeps citations and a
+// lone "(a)" reference from firing. The fix only trusts a clean sequence:
+// every marker in order, none skipped, none from another family.
+
+import { cleanLeadIn, itemsBetween, promote } from "../fix/promote.ts";
+import type { DirectText } from "../model.ts";
+import { proseParagraphs, sentenceSpan } from "../query.ts";
+import { first, last, type Range } from "../text.ts";
+import { type Edit, RULE, type Rule } from "./types.ts";
+
+const ENUM_FAMILIES: Array<[string, string]> = [
+  ["(a)", "(b)"],
+  ["(1)", "(2)"],
+  ["(i)", "(ii)"],
+];
+
+const ROMAN = ["i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix", "x", "xi", "xii"];
+const LETTERS = [..."abcdefghijklmnopqrstuvwxyz"];
+
+// The expected nth marker for the family the first marker opens.
+const sequenceFor = (label: string): string[] | null => {
+  if (label === "a") return LETTERS;
+  if (label === "1") return Array.from({ length: 99 }, (_, i) => String(i + 1));
+  if (label === "i") return ROMAN;
+  return null;
+};
+
+const MARKER = /\(([a-z]|[ivx]+|\d{1,2})\)(?=\s)/g;
+
+interface Marker {
+  range: Range;
+  label: string;
+}
+
+// Markers that open an item: preceded by whitespace or the start of a direct
+// text node, and followed by whitespace. The parsed value must agree with the
+// source, or an escape is hiding somewhere and the fixer refuses.
+const markersIn = (src: string, texts: DirectText[]): Marker[] | null => {
+  const opening = (s: string): RegExpMatchArray[] =>
+    [...s.matchAll(MARKER)].filter((m) => (m.index ?? 0) === 0 || /\s/.test(s.charAt((m.index ?? 0) - 1)));
+
+  const markers: Marker[] = [];
+  for (const text of texts) {
+    const inSlice = opening(src.slice(text.start, text.end));
+    if (inSlice.length !== opening(text.value).length) return null;
+    for (const match of inSlice) {
+      const start = text.start + (match.index ?? 0);
+      markers.push({ range: [start, start + match[0].length], label: match[1] ?? "" });
+    }
+  }
+  return markers;
+};
+
+// The first family whose opening two markers both appear, or undefined. One
+// family per paragraph is enough to report it.
+const familyIn = (prose: string): [string, string] | undefined =>
+  ENUM_FAMILIES.find(([opener, second]) => prose.includes(opener) && prose.includes(second));
+
+const check: Rule["check"] = ({ doc, file }) =>
+  proseParagraphs(doc).flatMap((view) => {
+    const family = familyIn(view.prose);
+    if (!family) return [];
+    const [opener, second] = family;
+    return [
+      {
+        file,
+        line: view.line,
+        rule: RULE.INLINE_ENUM,
+        message: `enumeration ${opener} ${second} ... inlined in prose; promote to a bullet list`,
+      },
+    ];
+  });
+
+const fix: Rule["fix"] = ({ doc }) => {
+  const { src } = doc;
+  const edits: Edit[] = [];
+  for (const view of doc.paragraphs) {
+    const markers = markersIn(src, view.directTexts);
+    if (markers === null || markers.length < 2) continue;
+    const sequence = sequenceFor(first(markers).label);
+    if (sequence === null || markers.some((marker, i) => marker.label !== sequence[i])) continue;
+
+    const opener = first(markers);
+    const closer = last(markers);
+    // Markers split across sentences are two references, not one list.
+    const between = view.directTexts.map((text) =>
+      src.slice(Math.max(text.start, opener.range[1]), Math.min(text.end, closer.range[0])),
+    );
+    if (between.some((slice) => /[.!?]\s/.test(slice))) continue;
+
+    const span = sentenceSpan(src, view, opener.range[0], closer.range[1]);
+    // Two markers joined only by a conjunction, with no colon to announce
+    // them, read as cross-references ("see (a) above and (b) below"). With
+    // exactly two markers the closer is also the second, so the text between
+    // them is the whole of the first item.
+    if (markers.length === 2) {
+      const announced = /:\s*$/.test(src.slice(span[0], opener.range[0]));
+      const separated = /[,;]\s*$/.test(src.slice(opener.range[1], closer.range[0]));
+      if (!announced && !separated) continue;
+    }
+
+    const edit = promote({
+      rule: RULE.INLINE_ENUM,
+      src,
+      view,
+      span,
+      leadIn: cleanLeadIn(src.slice(span[0], opener.range[0])),
+      items: itemsBetween(
+        src,
+        markers.map((marker) => marker.range),
+        span[1],
+      ).map((text) => ({ text })),
+      ordered: true,
+    });
+    if (edit) edits.push(edit);
+  }
+  return edits;
+};
+
+export const listInlineEnumerationMarkers: Rule = {
+  id: RULE.INLINE_ENUM,
+  category: "list",
+  summary: "enumeration markers (a)/(b) or (1)/(2) inlined in prose",
+  check,
+  fix,
+};

package/src/rules/list-interpunct-joined-run.ts

@@ -0,0 +1,68 @@
+// list-interpunct-joined-run: a single-line interpunct-joined run is a disguised flat list. The
+// fix promotes it to bullets, taking a colon before the run as the lead-in.
+// Without a colon the run must be the whole paragraph, or there is no way to
+// tell where the first item starts.
+
+import { cleanLeadIn, itemsBetween, promote } from "../fix/promote.ts";
+import { GLYPH, isFlat, paragraphsOf, RUN_SEPARATOR } from "../interpunct.ts";
+import { colonsBefore, colonsIn, sentenceSpan, splittableSeparators } from "../query.ts";
+import { first, last, type Range, words } from "../text.ts";
+import { type Edit, RULE, type Rule } from "./types.ts";
+
+// A last item this much longer than every other is a sentence that happens
+// to follow the list, not a member of it.
+const tailIsProse = (items: string[]): boolean =>
+  words(last(items)) > Math.max(8, 3 * Math.max(...items.slice(0, -1).map(words)));
+
+// Without a colon, a first item longer than the rest ("Built with Bun")
+// carries a clause the list would strip of its meaning.
+const headIsProse = (items: string[]): boolean => words(first(items)) > Math.max(...items.slice(1).map(words));
+
+const check: Rule["check"] = ({ file, runs }) =>
+  runs.filter(isFlat).map((run) => ({
+    file,
+    line: run.line,
+    rule: RULE.INTERPUNCT_RUN,
+    message: `interpunct-joined inline list (${run.separators + 1} items); promote to a bullet list`,
+  }));
+
+const fix: Rule["fix"] = ({ doc, runs }) => {
+  const { src } = doc;
+  const edits: Edit[] = [];
+  for (const view of paragraphsOf(doc, runs.filter(isFlat))) {
+    const separators = splittableSeparators(src, view, RUN_SEPARATOR, GLYPH);
+    const colons = colonsIn(src, view);
+    if (separators === null || colons === null) continue;
+
+    const span = sentenceSpan(src, view, first(separators)[0], last(separators)[1]);
+    // The innermost colon before the first item, so a lead-in that itself
+    // contains a colon keeps only its final clause.
+    const colon = colonsBefore(colons, span, first(separators)[0]).pop();
+    // With no colon to announce it, the run has to be the whole paragraph.
+    if (!colon && (span[0] !== view.startOffset || span[1] !== view.endOffset)) continue;
+
+    const cuts: Range[] = [colon ?? [span[0], span[0]], ...separators];
+    const items = itemsBetween(src, cuts, span[1]);
+    if (tailIsProse(items) || (!colon && headIsProse(items))) continue;
+
+    const edit = promote({
+      rule: RULE.INTERPUNCT_RUN,
+      src,
+      view,
+      span,
+      leadIn: colon ? cleanLeadIn(src.slice(span[0], colon[0])) : null,
+      items: items.map((text) => ({ text })),
+      ordered: false,
+    });
+    if (edit) edits.push(edit);
+  }
+  return edits;
+};
+
+export const listInterpunctJoinedRun: Rule = {
+  id: RULE.INTERPUNCT_RUN,
+  category: "list",
+  summary: "interpunct-joined inline list (2+ separators)",
+  check,
+  fix,
+};

package/src/rules/list-semicolon-delimited-run.ts

@@ -0,0 +1,60 @@
+// list-semicolon-delimited-run: a run of items joined by semicolons is a wall of text hiding a
+// list. The fix needs a colon lead-in to know where the list starts, and
+// refuses without one.
+
+import { cleanLeadIn, itemsBetween, promote } from "../fix/promote.ts";
+import { colonsBefore, colonsIn, matchesInAll, proseSentences, sentenceSpans } from "../query.ts";
+import { countOf, first, within } from "../text.ts";
+import { type Edit, RULE, type Rule } from "./types.ts";
+
+const SEMICOLON = /;/g;
+
+const check: Rule["check"] = ({ doc, file }) =>
+  proseSentences(doc)
+    .map(({ view, sentence }) => ({ view, semicolons: countOf(sentence, SEMICOLON) }))
+    .filter(({ semicolons }) => semicolons >= 2)
+    .map(({ view, semicolons }) => ({
+      file,
+      line: view.line,
+      rule: RULE.SEMICOLON_LIST,
+      message: `semicolon-delimited list (${semicolons} ';'); promote to a bullet list`,
+    }));
+
+const fix: Rule["fix"] = ({ doc }) => {
+  const { src } = doc;
+  const edits: Edit[] = [];
+  for (const view of doc.paragraphs) {
+    const semicolons = matchesInAll(src, view.directTexts, SEMICOLON);
+    const colons = colonsIn(src, view);
+    if (semicolons === null || colons === null) continue;
+    for (const span of sentenceSpans(src, view)) {
+      const inside = semicolons.filter((semicolon) => within(semicolon, span));
+      if (inside.length < 2) continue;
+      // The outermost colon before the first item opens the lead-in, so a
+      // "Note: the rules: a; b; c" keeps the whole of "Note: the rules".
+      const colon = colonsBefore(colons, span, first(inside)[0])[0];
+      if (!colon) continue;
+
+      const edit = promote({
+        rule: RULE.SEMICOLON_LIST,
+        src,
+        view,
+        span,
+        leadIn: cleanLeadIn(src.slice(span[0], colon[0])),
+        items: itemsBetween(src, [colon, ...inside], span[1]).map((text) => ({ text })),
+        ordered: false,
+      });
+      if (edit) edits.push(edit);
+      break; // one promotion per paragraph; the engine re-parses and comes back
+    }
+  }
+  return edits;
+};
+
+export const listSemicolonDelimitedRun: Rule = {
+  id: RULE.SEMICOLON_LIST,
+  category: "list",
+  summary: "semicolon-delimited list (2+ ';' in one sentence)",
+  check,
+  fix,
+};

package/src/rules/list-stacked-interpunct-runs.ts

@@ -0,0 +1,80 @@
+// list-stacked-interpunct-runs: interpunct runs stacked on 2+ source lines of one paragraph are a
+// two-level structure, so list-stacked-interpunct-runs replaces list-interpunct-joined-run for that paragraph. The fix
+// needs every line to read `Label: a · b · c`, and builds one parent bullet
+// per label with the items nested beneath it.
+
+import { itemsBetween, type PromotedItem, promote } from "../fix/promote.ts";
+import { GLYPH, isStacked, paragraphsOf, RUN_SEPARATOR } from "../interpunct.ts";
+import type { ParagraphView } from "../model.ts";
+import { colonsBefore, colonsIn, splittableSeparators } from "../query.ts";
+import { collapse, first, type Range, within } from "../text.ts";
+import { type Edit, RULE, type Rule } from "./types.ts";
+
+// The source lines of a paragraph, as absolute ranges.
+const linesOf = (view: ParagraphView): Range[] => {
+  const lines: Range[] = [];
+  let at = view.startOffset;
+  for (const line of view.raw.split("\n")) {
+    lines.push([at, at + line.length]);
+    at += line.length + 1;
+  }
+  return lines;
+};
+
+// One line read as `Label: a · b · c`, or null when it is not that shape.
+// Every line of the paragraph has to parse, or the fix has no nested list to
+// build and leaves the whole paragraph reported.
+const parentOf = (src: string, line: Range, separators: Range[], colons: Range[]): PromotedItem | null => {
+  const inside = separators.filter((separator) => within(separator, line));
+  if (inside.length === 0) return null;
+  const colon = colonsBefore(colons, line, first(inside)[0])[0];
+  if (!colon) return null;
+  return {
+    text: collapse(src.slice(line[0], colon[0])).trim(),
+    children: itemsBetween(src, [colon, ...inside], line[1]),
+  };
+};
+
+const check: Rule["check"] = ({ file, runs }) =>
+  runs.filter(isStacked).map((run) => ({
+    file,
+    line: run.line,
+    rule: RULE.STACKED_RUNS,
+    message: `interpunct runs stacked on ${run.lines} lines; promote to a nested list`,
+  }));
+
+const fix: Rule["fix"] = ({ doc, runs }) => {
+  const { src } = doc;
+  const edits: Edit[] = [];
+  for (const view of paragraphsOf(doc, runs.filter(isStacked))) {
+    const separators = splittableSeparators(src, view, RUN_SEPARATOR, GLYPH);
+    const colons = colonsIn(src, view);
+    if (separators === null || colons === null) continue;
+
+    const lines = linesOf(view);
+    const parents = lines
+      .map((line) => parentOf(src, line, separators, colons))
+      .filter((parent): parent is PromotedItem => parent !== null);
+    if (parents.length !== lines.length) continue;
+
+    const edit = promote({
+      rule: RULE.STACKED_RUNS,
+      src,
+      view,
+      span: [view.startOffset, view.endOffset],
+      leadIn: null,
+      items: parents,
+      ordered: false,
+    });
+    if (edit) edits.push(edit);
+  }
+  return edits;
+};
+
+export const listStackedInterpunctRuns: Rule = {
+  id: RULE.STACKED_RUNS,
+  category: "list",
+  summary: "interpunct runs stacked on several lines (nested list)",
+  check,
+  fix,
+};

package/src/rules/punctuation-em-dash-in-prose.ts

@@ -0,0 +1,155 @@
+// punctuation-em-dash-in-prose: an em-dash in prose. Code is exempt by construction, since only
+// text nodes are read. The fix is deliberately narrow: a pair of dashes
+// around an aside becomes parentheses, a lone dash becomes a colon, and
+// anything else stays reported for a human.
+
+import type { Node } from "mdast";
+import type { DirectText, DocModel } from "../model.ts";
+import { matchesIn, textsContaining } from "../query.ts";
+import { first, last, type Range } from "../text.ts";
+import { type Edit, RULE, type Rule } from "./types.ts";
+
+const EM_DASH = "—";
+
+// Any horizontal space around the dash belongs to it, including no-break and
+// zero-width spaces, or the swap strands one in front of the colon.
+const DASH = /[\p{Zs}\t​]*—[\p{Zs}\t​]*/u;
+
+// What an aside must not be: an enumeration marker in disguise.
+const MARKER_LIKE = /^(?:[a-z]|[ivx]+|\d+)$/i;
+
+interface Dash {
+  range: Range; // the dash with its surrounding spaces
+  text: DirectText; // the text node it sits in
+}
+
+// One paragraph, heading or table cell: the dashes it holds and the text
+// nodes they came from. A block whose source and parsed value disagree is
+// refused whole, so a swap never lands next to a glyph the fixer cannot see.
+interface Block {
+  texts: DirectText[];
+  dashes: Dash[];
+  refused: boolean;
+}
+
+const blocksOf = (doc: DocModel): Block[] => {
+  const byBlock = new Map<Node, Block>();
+  for (const { block, start, end, value } of doc.texts) {
+    if (block === undefined || start === undefined || end === undefined) continue;
+    let entry = byBlock.get(block);
+    if (!entry) {
+      entry = { texts: [], dashes: [], refused: false };
+      byBlock.set(block, entry);
+    }
+    const text: DirectText = { value, start, end };
+    entry.texts.push(text);
+    const found = matchesIn(doc.src, text, DASH);
+    if (found === null) entry.refused = true;
+    else entry.dashes.push(...found.map((range) => ({ range, text })));
+  }
+  return [...byBlock.values()];
+};
+
+// Absolute offsets of every match of `pattern` across a block's prose text.
+const offsetsIn = (src: string, texts: DirectText[], pattern: RegExp): number[] =>
+  texts.flatMap((text) =>
+    [...src.slice(text.start, text.end).matchAll(pattern)].map((m) => text.start + (m.index ?? 0)),
+  );
+
+// The dashes of one sentence, with the one fact about that sentence the
+// rewrite needs. A pair only reads as an aside when both halves sit in the
+// same sentence, which is why dashes are judged a sentence at a time.
+interface Aside {
+  dashes: Dash[];
+  hasColon: boolean;
+}
+
+const asidesIn = (src: string, { texts, dashes }: Block): Aside[] => {
+  // Terminals and colons are read only from this block's prose text, so one
+  // inside a link, emphasis or code span never splits a sentence.
+  const terminals = offsetsIn(src, texts, /[.!?](?=\s)/g);
+  const colons = offsetsIn(src, texts, /:/g);
+  const sentenceOf = (offset: number): number => terminals.filter((terminal) => terminal < offset).length;
+
+  const bySentence = new Map<number, Dash[]>();
+  for (const dash of dashes) {
+    const sentence = sentenceOf(dash.range[0]);
+    const group = bySentence.get(sentence);
+    if (group) group.push(dash);
+    else bySentence.set(sentence, [dash]);
+  }
+  return [...bySentence].map(([sentence, group]) => ({
+    dashes: group,
+    hasColon: colons.some((colon) => sentenceOf(colon) === sentence),
+  }));
+};
+
+// A dash touching a line break, the edge of its text node, or punctuation
+// that already ends or opens a clause has no clear neighbours to join.
+const touchesEdge = (src: string, dash: Dash): boolean =>
+  dash.range[0] === dash.text.start ||
+  dash.range[1] === dash.text.end ||
+  /[\r\n.!?:;,(\\]/.test(src[dash.range[0] - 1] ?? "\n") ||
+  /[\r\n.!?:;,)]/.test(src[dash.range[1]] ?? "\n");
+
+// What the dashes of one sentence become, or null when the shape is not one
+// of the two the fix trusts.
+const replacementFor = (src: string, { dashes, hasColon }: Aside): string | null => {
+  const opening = first(dashes);
+  const closing = last(dashes);
+
+  // A pair wraps an aside, so it becomes parentheses. An aside that reads as
+  // "(b)" would plant a list-inline-enumeration-markers marker and hide the word from the fingerprint.
+  if (dashes.length === 2) {
+    const inner = src.slice(opening.range[1], closing.range[0]);
+    return MARKER_LIKE.test(inner.trim()) ? null : ` (${inner}) `;
+  }
+
+  // A lone dash joins two clauses, so it becomes a colon. A numeric range
+  // like 1—2 or 2020 — 2021 wants an en-dash instead, and a sentence that
+  // already has a colon would read as two labels.
+  if (dashes.length === 1) {
+    const numericRange = /\d/.test(src[opening.range[0] - 1] ?? "") && /\d/.test(src[opening.range[1]] ?? "");
+    return numericRange || hasColon ? null : ": ";
+  }
+
+  // Three or more dashes in one sentence is a shape the fix does not claim
+  // to understand, so the finding stays for a human.
+  return null;
+};
+
+const rewrite = (src: string, aside: Aside): Edit | null => {
+  if (aside.dashes.some((dash) => touchesEdge(src, dash))) return null;
+  const text = replacementFor(src, aside);
+  if (text === null) return null;
+  return {
+    rule: RULE.EM_DASH,
+    start: first(aside.dashes).range[0],
+    end: last(aside.dashes).range[1],
+    text,
+    expect: { kind: "same-shape" },
+  };
+};
+
+const check: Rule["check"] = ({ doc, file }) =>
+  textsContaining(doc, EM_DASH).map((text) => ({
+    file,
+    line: text.line,
+    rule: RULE.EM_DASH,
+    message: "em-dash in prose; use comma, colon, parentheses, or two sentences",
+  }));
+
+const fix: Rule["fix"] = ({ doc }) =>
+  blocksOf(doc)
+    .filter((block) => !block.refused && block.dashes.length > 0)
+    .flatMap((block) => asidesIn(doc.src, block))
+    .map((aside) => rewrite(doc.src, aside))
+    .filter((edit): edit is Edit => edit !== null);
+
+export const punctuationEmDashInProse: Rule = {
+  id: RULE.EM_DASH,
+  category: "punctuation",
+  summary: "em-dash U+2014 in prose",
+  check,
+  fix,
+};

package/src/rules/punctuation-interpunct-in-prose.ts

@@ -0,0 +1,52 @@
+// punctuation-interpunct-in-prose: a stray interpunct in prose. One inside a reported run is left to
+// list-interpunct-joined-run or list-stacked-interpunct-runs. The fix swaps a spaced interpunct for a comma; a glyph
+// with no space on either side (a product name, a unit) is left alone.
+
+import { GLYPH, INTERPUNCT } from "../interpunct.ts";
+import { matchesIn, textsContaining } from "../query.ts";
+import { inRanges } from "../text.ts";
+import { type Edit, RULE, type Rule } from "./types.ts";
+
+// Only a separator reads as a comma: the spaces on both sides are what make
+// the glyph a joiner rather than part of a name. list-interpunct-joined-run and list-stacked-interpunct-runs split on a
+// looser one, because a run has already proved itself a list.
+const SEPARATOR = /[ \t]+·[ \t]+/;
+
+const check: Rule["check"] = ({ doc, file, reported: runs }) => {
+  const reported = runs.map((run) => run.range);
+  return textsContaining(doc, INTERPUNCT)
+    .filter((text) => text.start === undefined || !inRanges(text.start, reported))
+    .map((text) => ({
+      file,
+      line: text.line,
+      rule: RULE.INTERPUNCT,
+      message: "interpunct in prose; use a comma, slash, or a list",
+    }));
+};
+
+const fix: Rule["fix"] = ({ doc, reported: runs }) => {
+  const reported = runs.map((run) => run.range);
+  const edits: Edit[] = [];
+  for (const { start, end, value } of textsContaining(doc, INTERPUNCT)) {
+    if (start === undefined || end === undefined) continue;
+    if (inRanges(start, reported)) continue;
+    const text = { value, start, end };
+    // Every glyph in the node must be a spaced separator. A mixed node holds
+    // at least one the fix would leave behind, so it refuses whole.
+    const glyphs = matchesIn(doc.src, text, GLYPH);
+    const separators = matchesIn(doc.src, text, SEPARATOR);
+    if (glyphs === null || separators === null || glyphs.length !== separators.length) continue;
+    for (const [from, to] of separators) {
+      edits.push({ rule: RULE.INTERPUNCT, start: from, end: to, text: ", ", expect: { kind: "same-shape" } });
+    }
+  }
+  return edits;
+};
+
+export const punctuationInterpunctInProse: Rule = {
+  id: RULE.INTERPUNCT,
+  category: "punctuation",
+  summary: "interpunct U+00B7 in prose",
+  check,
+  fix,
+};

package/src/rules/registry.ts

@@ -0,0 +1,133 @@
+// The registry: the rules a run actually uses. It starts from the built-in
+// catalogue, adds whatever plugins loaded, then applies the config, so a rule
+// that is off loses its check and its fixer together. Nothing else reads the
+// catalogue directly, which is what lets a plugin rule behave as a built-in.
+
+import type { Config } from "../config.ts";
+import { RuleOptionError, UnknownRuleError } from "../errors.ts";
+import { interpunctRuns, isFlat } from "../interpunct.ts";
+import type { DocModel } from "../model.ts";
+import { sentences, words } from "../text.ts";
+import { FIX_ORDER, RULES } from "./index.ts";
+import { lengthMessage } from "./sentence-word-budget-exceeded.ts";
+import {
+  isPluginRuleId,
+  type OptionType,
+  RULE,
+  type Rule,
+  type RuleContext,
+  type RuleId,
+  type RuleOptions,
+} from "./types.ts";
+
+export const BUILTIN_CATEGORIES: ReadonlyMap<string, string> = new Map([
+  ["sentence", "How a sentence is laid out and how long it runs"],
+  ["list", "A list hidden in running prose, promoted to a real markdown list"],
+  ["punctuation", "A glyph that reads as generated text"],
+]);
+
+export const TEXT_HELPERS = { words, sentences, lengthMessage } as const;
+
+// Where a group of rules came from, for the line each run prints.
+export interface LoadedSource {
+  kind: "local" | "package" | "config";
+  spec: string;
+  namespace: string;
+  rules: RuleId[];
+}
+
+export interface Registry {
+  rules: Rule[];
+  fixOrder: Rule[];
+  enabled: ReadonlySet<RuleId>;
+  options: ReadonlyMap<RuleId, RuleOptions>;
+  categories: ReadonlyMap<string, string>;
+  sources: LoadedSource[];
+  // Config settings dropped because they name a plugin rule that did not load.
+  ignoredSettings: string[];
+}
+
+export interface RegistryInput {
+  rules: Rule[];
+  fixOrder: Rule[];
+  categories: ReadonlyMap<string, string>;
+  sources?: LoadedSource[];
+  config?: Config;
+  // A lenient run drops a setting for an unknown plugin rule instead of failing.
+  ignoreUnknownPluginIds?: boolean;
+}
+
+const typeOf = (value: unknown): OptionType | null => {
+  if (typeof value === "number" && Number.isFinite(value)) return "number";
+  if (typeof value === "string") return "string";
+  if (typeof value === "boolean") return "boolean";
+  if (Array.isArray(value) && value.every((v) => typeof v === "string")) return "string[]";
+  return null;
+};
+
+const checkOptions = (where: string, rule: Rule, options: RuleOptions): void => {
+  const accepted = Object.keys(rule.options ?? {});
+  for (const [name, value] of Object.entries(options)) {
+    const want = rule.options?.[name];
+    if (!want) {
+      const list = accepted.length > 0 ? `it accepts ${accepted.join(", ")}` : "it takes no options";
+      throw new RuleOptionError(where, rule.id, name, `rule "${rule.id}" has no option "${name}"; ${list}`);
+    }
+    if (typeOf(value) !== want) {
+      throw new RuleOptionError(where, rule.id, name, `option "${name}" of "${rule.id}" must be a ${want}`);
+    }
+  }
+  if ("maxWords" in options && !((options.maxWords as number) >= 1)) {
+    throw new RuleOptionError(where, rule.id, "maxWords", `option "maxWords" of "${rule.id}" must be at least 1`);
+  }
+};
+
+export const buildRegistry = (input: RegistryInput): Registry => {
+  const { rules, fixOrder, categories, sources = [], config, ignoreUnknownPluginIds = false } = input;
+  const off = new Set<string>();
+  const options = new Map<RuleId, RuleOptions>();
+  const ignored: string[] = [];
+  const where = config?.file ?? "config";
+  for (const [id, setting] of config?.rules ?? []) {
+    const rule = rules.find((r) => r.id === id);
+    if (!rule) {
+      // A plugin that was skipped cannot have its rules configured, so a lenient
+      // run drops the setting and says so. A built-in id is never forgiven.
+      if (ignoreUnknownPluginIds && isPluginRuleId(id)) {
+        ignored.push(id);
+        continue;
+      }
+      throw new UnknownRuleError(
+        where,
+        id,
+        rules.map((r) => r.id),
+      );
+    }
+    checkOptions(where, rule, setting.options);
+    if (setting.severity === "off") off.add(id);
+    else options.set(rule.id, setting.options);
+  }
+  const active = rules.filter((r) => !off.has(r.id));
+  return {
+    rules: active,
+    fixOrder: fixOrder.filter((r) => !off.has(r.id)),
+    enabled: new Set(active.map((r) => r.id)),
+    options,
+    categories,
+    sources,
+    ignoredSettings: ignored,
+  };
+};
+
+export const BUILTIN: Registry = buildRegistry({ rules: RULES, fixOrder: FIX_ORDER, categories: BUILTIN_CATEGORIES });
+
+// The data every rule shares, derived once per document. Interpunct runs are
+// read by several rules, so computing them here keeps the fix engine from
+// rebuilding them once per rule on every pass of the fixpoint loop. A run is
+// owned by the flat or the stacked list rule, and it counts as reported only
+// while its owner is on.
+export const ruleContext = (doc: DocModel, registry: Registry = BUILTIN): RuleContext => {
+  const runs = interpunctRuns(doc);
+  const reported = runs.filter((run) => registry.enabled.has(isFlat(run) ? RULE.INTERPUNCT_RUN : RULE.STACKED_RUNS));
+  return { doc, runs, reported };
+};