@jpeakai/prose-gates 0.1.2 → 0.3.0

package/src/rules/list-comma-labelled-run.ts

@@ -0,0 +1,117 @@
+// list-comma-labelled-run: one sentence stringing 3+ comma-separated segments each led by a
+// label (an inline-code span, or an identifier like sentence-one-per-line / MD025 / S4)
+// WITH content after it is a hidden list of labelled items. Bare labels
+// ("A, B, and C are interchangeable") are a subject enumeration, not a
+// list. An optional "Rules: " style intro on the first segment, and a
+// joining "and"/"or", are tolerated.
+//
+// The check counts labelled segments; the fix is stricter and needs every
+// segment of the sentence to be one, so no stray clause becomes a bullet.
+
+import { cleanLeadIn, itemsOf, promote } from "../fix/promote.ts";
+import type { ParagraphView } from "../model.ts";
+import { colonsIn, matchesInAll, proseSentences, sentenceSpans } from "../query.ts";
+import { collapse, first, type Range, spansBetween, within } from "../text.ts";
+import { type Edit, RULE, type Rule } from "./types.ts";
+
+// A labelled segment, built from its parts so each one can be read on its
+// own: the conjunction that joins the final segment, an optional "Rules: "
+// intro on the first, the label itself, and the content that makes it an
+// item rather than a bare mention.
+const JOINER = "(?:and\\s+|or\\s+)?";
+const INTRO = "(?:[A-Za-z][\\w\\s-]{0,24}:\\s*)?";
+const LABEL = "(?:CODE|[A-Z][A-Za-z]*\\d[\\w/-]*)";
+const CONTENT = "\\s+\\S";
+const LABELLED_SEGMENT = new RegExp(`^${JOINER}${INTRO}${LABEL}${CONTENT}`);
+
+// The intro that may precede the first label, as the lead-in test reads it.
+const INTRO_ONLY = /^[A-Za-z][\w\s-]{0,24}$/;
+
+// A source slice as the check sees it: code spans become one CODE token.
+const asProse = (src: string, view: ParagraphView, range: Range): string => {
+  let out = "";
+  let at = range[0];
+  for (const [start, end] of view.codeRanges) {
+    if (end <= range[0] || start >= range[1]) continue;
+    out += `${src.slice(at, start)}CODE`;
+    at = end;
+  }
+  return collapse(out + src.slice(at, range[1])).trim();
+};
+
+const labelledSegments = (sentence: string): number =>
+  sentence.split(/,\s+/).filter((segment) => LABELLED_SEGMENT.test(segment)).length;
+
+const check: Rule["check"] = ({ doc, file }) =>
+  proseSentences(doc)
+    .map(({ view, sentence }) => ({ view, labelled: labelledSegments(sentence) }))
+    .filter(({ labelled }) => labelled >= 3)
+    .map(({ view, labelled }) => ({
+      file,
+      line: view.line,
+      rule: RULE.LABELLED_RUN,
+      message: `comma-joined run of ${labelled} labelled items; promote to a bullet list`,
+    }));
+
+// The comma-separated segments of a sentence when every one is labelled, or
+// null when the sentence has too few commas or carries a stray clause.
+const labelledRun = (src: string, view: ParagraphView, commas: Range[], span: Range): Range[] | null => {
+  const inside = commas.filter((comma) => within(comma, span));
+  if (inside.length < 2) return null;
+  // The sentence start is the cut before the first segment, so the spans
+  // between the cuts are exactly the comma-separated segments.
+  const segments = spansBetween([[span[0], span[0]], ...inside], span[1]);
+  return segments.every((segment) => LABELLED_SEGMENT.test(asProse(src, view, segment))) ? segments : null;
+};
+
+interface LabelledSentence {
+  src: string;
+  view: ParagraphView;
+  span: Range;
+  segments: Range[];
+  colons: Range[];
+}
+
+// An intro colon in the first segment, before its label, is the lead-in.
+// The first item then starts after it, so the intro is not repeated as
+// both the lead-in and the head of the first bullet.
+const promoteRun = ({ src, view, span, segments, colons }: LabelledSentence): Edit | null => {
+  const opening = first(segments);
+  const colon = colons.find((c) => within(c, opening));
+  const intro = colon !== undefined && INTRO_ONLY.test(collapse(src.slice(span[0], colon[0])).trim());
+  const items: Range[] = intro && colon ? [[colon[1], opening[1]], ...segments.slice(1)] : segments;
+
+  return promote({
+    rule: RULE.LABELLED_RUN,
+    src,
+    view,
+    span,
+    leadIn: intro && colon ? cleanLeadIn(src.slice(span[0], colon[0])) : null,
+    items: itemsOf(src, items).map((text) => ({ text })),
+    ordered: false,
+  });
+};
+
+// One promotion per paragraph: the first fully labelled sentence is the only
+// one tried, and the engine re-parses and comes back for the rest.
+const fixParagraph = (src: string, view: ParagraphView): Edit | null => {
+  const commas = matchesInAll(src, view.directTexts, /,(?=\s)/);
+  const colons = colonsIn(src, view);
+  if (commas === null || colons === null) return null;
+  for (const span of sentenceSpans(src, view)) {
+    const segments = labelledRun(src, view, commas, span);
+    if (segments !== null) return promoteRun({ src, view, span, segments, colons });
+  }
+  return null;
+};
+
+const fix: Rule["fix"] = ({ doc }) =>
+  doc.paragraphs.map((view) => fixParagraph(doc.src, view)).filter((edit): edit is Edit => edit !== null);
+
+export const listCommaLabelledRun: Rule = {
+  id: RULE.LABELLED_RUN,
+  category: "list",
+  summary: "comma-joined labelled run (3+ labelled segments)",
+  check,
+  fix,
+};

package/src/rules/{pg007-inline-enum.ts → list-inline-enumeration-markers.ts}

@@ -1,10 +1,10 @@
-// PG007: parenthesised enumerators inlined in one paragraph are a hidden
+// 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 type { DirectText, ParagraphView } 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";
@@ -72,53 +72,64 @@ const check: Rule["check"] = ({ doc, file }) =>
     ];
   });
 
-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;
-    }
+// The paragraph's markers when they form a clean sequence: at least two, every
+// one in order from the family the first opens, none skipped. Otherwise null.
+const cleanSequence = (src: string, view: ParagraphView): Marker[] | null => {
+  const markers = markersIn(src, view.directTexts);
+  if (markers === null || markers.length < 2) return null;
+  const sequence = sequenceFor(first(markers).label);
+  if (sequence === null || markers.some((marker, i) => marker.label !== sequence[i])) return null;
+  return markers;
+};
+
+// Markers split across sentences are two references, not one list.
+const splitAcrossSentences = (src: string, view: ParagraphView, opener: Marker, closer: Marker): boolean =>
+  view.directTexts
+    .map((text) => src.slice(Math.max(text.start, opener.range[1]), Math.min(text.end, closer.range[0])))
+    .some((slice) => /[.!?]\s/.test(slice));
+
+// 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.
+const crossReference = (src: string, span: Range, markers: Marker[]): boolean => {
+  if (markers.length !== 2) return false;
+  const opener = first(markers);
+  const closer = last(markers);
+  const announced = /:\s*$/.test(src.slice(span[0], opener.range[0]));
+  const separated = /[,;]\s*$/.test(src.slice(opener.range[1], closer.range[0]));
+  return !announced && !separated;
+};
 
-    const edit = promote({
-      rule: RULE.INLINE_ENUM,
+const fixParagraph = (src: string, view: ParagraphView): Edit | null => {
+  const markers = cleanSequence(src, view);
+  if (markers === null) return null;
+  const opener = first(markers);
+  const closer = last(markers);
+  if (splitAcrossSentences(src, view, opener, closer)) return null;
+
+  const span = sentenceSpan(src, view, opener.range[0], closer.range[1]);
+  if (crossReference(src, span, markers)) return null;
+
+  return promote({
+    rule: RULE.INLINE_ENUM,
+    src,
+    view,
+    span,
+    leadIn: cleanLeadIn(src.slice(span[0], opener.range[0])),
+    items: itemsBetween(
       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;
+      markers.map((marker) => marker.range),
+      span[1],
+    ).map((text) => ({ text })),
+    ordered: true,
+  });
 };
 
-export const pg007: Rule = {
+const fix: Rule["fix"] = ({ doc }) =>
+  doc.paragraphs.map((view) => fixParagraph(doc.src, view)).filter((edit): edit is Edit => edit !== null);
+
+export const listInlineEnumerationMarkers: Rule = {
   id: RULE.INLINE_ENUM,
   category: "list",
   summary: "enumeration markers (a)/(b) or (1)/(2) inlined in prose",

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

@@ -0,0 +1,71 @@
+// 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 type { ParagraphView } from "../model.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`,
+  }));
+
+// With no colon to announce it, the run has to be the whole paragraph.
+const coversParagraph = (view: ParagraphView, span: Range): boolean =>
+  span[0] === view.startOffset && span[1] === view.endOffset;
+
+const fixParagraph = (src: string, view: ParagraphView): Edit | null => {
+  const separators = splittableSeparators(src, view, RUN_SEPARATOR, GLYPH);
+  const colons = colonsIn(src, view);
+  if (separators === null || colons === null) return null;
+
+  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();
+  if (!colon && !coversParagraph(view, span)) return null;
+
+  const cuts: Range[] = [colon ?? [span[0], span[0]], ...separators];
+  const items = itemsBetween(src, cuts, span[1]);
+  if (tailIsProse(items) || (!colon && headIsProse(items))) return null;
+
+  return 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,
+  });
+};
+
+const fix: Rule["fix"] = ({ doc, runs }) =>
+  paragraphsOf(doc, runs.filter(isFlat))
+    .map((view) => fixParagraph(doc.src, view))
+    .filter((edit): edit is Edit => edit !== null);
+
+export const listInterpunctJoinedRun: Rule = {
+  id: RULE.INTERPUNCT_RUN,
+  category: "list",
+  summary: "interpunct-joined inline list (2+ separators)",
+  check,
+  fix,
+};

package/src/rules/{pg003-semicolon-list.ts → list-semicolon-delimited-run.ts}

@@ -1,4 +1,4 @@
-// PG003: a run of items joined by semicolons is a wall of text hiding a
+// 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.
 
@@ -51,7 +51,7 @@ const fix: Rule["fix"] = ({ doc }) => {
   return edits;
 };
 
-export const pg003: Rule = {
+export const listSemicolonDelimitedRun: Rule = {
   id: RULE.SEMICOLON_LIST,
   category: "list",
   summary: "semicolon-delimited list (2+ ';' in one sentence)",

package/src/rules/{pg009-stacked-runs.ts → list-stacked-interpunct-runs.ts}

@@ -1,5 +1,5 @@
-// PG009: interpunct runs stacked on 2+ source lines of one paragraph are a
-// two-level structure, so PG009 replaces PG006 for that paragraph. The fix
+// 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.
 
@@ -71,7 +71,7 @@ const fix: Rule["fix"] = ({ doc, runs }) => {
   return edits;
 };
 
-export const pg009: Rule = {
+export const listStackedInterpunctRuns: Rule = {
   id: RULE.STACKED_RUNS,
   category: "list",
   summary: "interpunct runs stacked on several lines (nested list)",

package/src/rules/paragraph-sentence-budget-exceeded.ts

@@ -0,0 +1,64 @@
+// paragraph-sentence-budget-exceeded: a paragraph of more sentences than the
+// budget renders as a wall of text, even when every sentence is short. Never
+// autofixed: where a paragraph breaks is a judgement about its topics. The
+// message counts the topics and names the sentences to break after.
+//
+// It runs after the list rules. A list hidden in a paragraph is theirs to
+// report, and promoting it often brings the paragraph within budget on its
+// own, so a paragraph a list rule reports is counted only once the list is out.
+
+import { gapCohesion, planBreaks } from "../cohesion.ts";
+import type { LanguageSentence } from "../language.ts";
+import type { ParagraphView } from "../model.ts";
+import { proseParagraphs } from "../query.ts";
+import { type Finding, RULE, type Rule } from "./types.ts";
+
+export const DEFAULT_MAX_SENTENCES = 5;
+
+// A list of sentence numbers as prose: "3", "3 and 6", "2, 3 and 6".
+const series = (ns: number[]): string =>
+  ns.length === 1 ? `${ns[0]}` : `${ns.slice(0, -1).join(", ")} and ${ns.at(-1)}`;
+
+const plural = (n: number, word: string): string => `${word}${n === 1 ? "" : "s"}`;
+
+export const paragraphMessage = (sentences: readonly LanguageSentence[], maxSentences: number): string => {
+  const { topics, breaks } = planBreaks(gapCohesion(sentences), maxSentences);
+  const where = `break it after ${plural(breaks.length, "sentence")} ${series(breaks)}`;
+  const counted = `paragraph has ${sentences.length} sentences (budget ${maxSentences})`;
+  return topics === 1
+    ? `${counted} and one topic throughout; ${where}, where neighbouring sentences share the fewest words`
+    : `${counted} and about ${topics} topics; ${where}, one topic per paragraph`;
+};
+
+const budgetOf = (option: unknown): number => (typeof option === "number" ? option : DEFAULT_MAX_SENTENCES);
+
+// Whether a list rule reported a line of this paragraph. A list rule may
+// report the paragraph's first line or the line its run starts on.
+const holdsListFinding = (view: ParagraphView, earlier: readonly Finding[]): boolean => {
+  const last = view.line + view.raw.split("\n").length - 1;
+  return earlier.some((f) => f.line >= view.line && f.line <= last);
+};
+
+const check: Rule["check"] = ({ doc, file, options, earlier }) => {
+  const maxSentences = budgetOf(options.maxSentences);
+  return proseParagraphs(doc)
+    .filter((view) => !holdsListFinding(view, earlier))
+    .map((view) => ({ view, sentences: view.language.sentences }))
+    .filter(({ sentences }) => sentences.length > maxSentences)
+    .map(({ view, sentences }) => ({
+      file,
+      line: view.line,
+      rule: RULE.PARAGRAPH_LENGTH,
+      message: paragraphMessage(sentences, maxSentences),
+    }));
+};
+
+// No fixer: breaking a paragraph is a judgement about its topics, per PRS-0030.
+export const paragraphSentenceBudgetExceeded: Rule = {
+  id: RULE.PARAGRAPH_LENGTH,
+  category: "paragraph",
+  summary: `paragraph with more sentences than the budget (default ${DEFAULT_MAX_SENTENCES})`,
+  options: { maxSentences: "number" },
+  after: ["list"],
+  check,
+};

package/src/rules/{pg004-em-dash.ts → punctuation-em-dash-in-prose.ts}

@@ -1,4 +1,4 @@
-// PG004: an em-dash in prose. Code is exempt by construction, since only
+// 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.
@@ -99,7 +99,7 @@ const replacementFor = (src: string, { dashes, hasColon }: Aside): string | null
   const closing = last(dashes);
 
   // A pair wraps an aside, so it becomes parentheses. An aside that reads as
-  // "(b)" would plant a PG007 marker and hide the word from the fingerprint.
+  // "(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}) `;
@@ -146,7 +146,7 @@ const fix: Rule["fix"] = ({ doc }) =>
     .map((aside) => rewrite(doc.src, aside))
     .filter((edit): edit is Edit => edit !== null);
 
-export const pg004: Rule = {
+export const punctuationEmDashInProse: Rule = {
   id: RULE.EM_DASH,
   category: "punctuation",
   summary: "em-dash U+2014 in prose",

package/src/rules/{pg005-interpunct.ts → punctuation-interpunct-in-prose.ts}

@@ -1,5 +1,5 @@
-// PG005: a stray interpunct in prose. One inside a reported run is left to
-// PG006 or PG009. The fix swaps a spaced interpunct for a comma; a glyph
+// 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";
@@ -8,11 +8,11 @@ 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. PG006 and PG009 split on a
+// 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, runs }) => {
+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))
@@ -24,7 +24,7 @@ const check: Rule["check"] = ({ doc, file, runs }) => {
     }));
 };
 
-const fix: Rule["fix"] = ({ doc, runs }) => {
+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)) {
@@ -43,7 +43,7 @@ const fix: Rule["fix"] = ({ doc, runs }) => {
   return edits;
 };
 
-export const pg005: Rule = {
+export const punctuationInterpunctInProse: Rule = {
   id: RULE.INTERPUNCT,
   category: "punctuation",
   summary: "interpunct U+00B7 in prose",

package/src/rules/registry.ts

@@ -0,0 +1,143 @@
+// 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 ConceptModel, NO_CONCEPTS } from "../concepts.ts";
+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"],
+  ["paragraph", "How many sentences a paragraph holds before a break"],
+  ["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[];
+  // The project's concept file, read once per run, which every document model carries.
+  concepts: ConceptModel;
+}
+
+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;
+  concepts?: ConceptModel;
+}
+
+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}`);
+    }
+  }
+  // A budget below one would fail every sentence or every paragraph.
+  for (const budget of ["maxWords", "maxSentences"]) {
+    if (budget in options && !((options[budget] as number) >= 1)) {
+      throw new RuleOptionError(where, rule.id, budget, `option "${budget}" of "${rule.id}" must be at least 1`);
+    }
+  }
+};
+
+export const buildRegistry = (input: RegistryInput): Registry => {
+  const { rules, fixOrder, categories, sources = [], config, ignoreUnknownPluginIds = false } = input;
+  const concepts = input.concepts ?? NO_CONCEPTS;
+  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,
+    concepts,
+  };
+};
+
+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 };
+};