@jpeakai/prose-gates 0.1.2 → 0.3.0

package/src/rules/{pg001-wrap.ts → sentence-one-per-line.ts}

@@ -1,6 +1,7 @@
-// PG001: a newline inside a paragraph whose preceding non-space character
-// does not end a sentence is a mid-sentence wrap. The fix reflows the
-// paragraph to one sentence per line.
+// sentence-one-per-line: a newline inside a paragraph whose preceding non-space character
+// does not end a sentence is a mid-sentence wrap, and a sentence break with no
+// newline puts several sentences on one line. The fix reflows the paragraph to
+// one sentence per line, so the check reports every paragraph the fix changes.
 
 import { isStacked, paragraphsOf } from "../interpunct.ts";
 import type { ParagraphView } from "../model.ts";
@@ -32,17 +33,35 @@ const wrapsIn = (view: ParagraphView): number[] => {
   return wraps;
 };
 
-// The paragraph rewritten with one sentence per line. Code spans are masked
-// character for character before the split, keeping whitespace, so offsets
-// stay aligned and a terminal inside a code span never starts a new line.
+// The paragraph with each code span masked character for character, keeping
+// whitespace, so offsets stay aligned and a terminal inside a code span never
+// reads as the end of a sentence.
+const masked = (view: ParagraphView): string =>
+  [...view.raw].map((ch, i) => (inRanges(view.startOffset + i, view.codeRanges) && !/\s/.test(ch) ? "x" : ch)).join("");
+
+// Offsets within the paragraph of a sentence break that has no newline in it,
+// one per line, since one finding per line is enough to name it.
+const packedIn = (view: ParagraphView): number[] => {
+  const lines = new Set<number>();
+  const at: number[] = [];
+  const text = masked(view);
+  for (const match of text.matchAll(SENTENCE_BREAK)) {
+    if (match[0].includes("\n")) continue;
+    const offset = match.index ?? 0;
+    const line = text.slice(0, offset).split("\n").length;
+    if (lines.has(line)) continue;
+    lines.add(line);
+    at.push(offset);
+  }
+  return at;
+};
+
+// The paragraph rewritten with one sentence per line.
 const reflow = (view: ParagraphView): string => {
   const indent = " ".repeat(view.startColumn - 1);
   const eol = view.raw.includes("\r\n") ? "\r\n" : "\n";
-  const masked = [...view.raw]
-    .map((ch, i) => (inRanges(view.startOffset + i, view.codeRanges) && !/\s/.test(ch) ? "x" : ch))
-    .join("");
   const joined = collapse(view.raw);
-  const joinedMask = collapse(masked);
+  const joinedMask = collapse(masked(view));
 
   const lines: string[] = [];
   let from = 0;
@@ -55,21 +74,29 @@ const reflow = (view: ParagraphView): string => {
   return lines.map((line, i) => (i === 0 ? line.trim() : indent + line.trim())).join(eol);
 };
 
+const lineOf = (view: ParagraphView, at: number): number => view.line + view.raw.slice(0, at).split("\n").length - 1;
+
 const check: Rule["check"] = ({ doc, file }) =>
-  proseParagraphs(doc).flatMap((view) =>
-    wrapsIn(view).map((at) => ({
+  proseParagraphs(doc).flatMap((view) => [
+    ...wrapsIn(view).map((at) => ({
       file,
-      line: view.line + view.raw.slice(0, at).split("\n").length - 1,
+      line: lineOf(view, at),
       rule: RULE.WRAP,
       message: "mid-sentence line wrap; write one sentence per line",
     })),
-  );
+    ...packedIn(view).map((at) => ({
+      file,
+      line: lineOf(view, at),
+      rule: RULE.WRAP,
+      message: "several sentences on one line; write one sentence per line",
+    })),
+  ]);
 
 const fix: Rule["fix"] = ({ doc, runs }) => {
   const edits: Edit[] = [];
-  // Interpunct runs stacked on several lines are a nested list PG009 either
+  // Interpunct runs stacked on several lines are a nested list list-stacked-interpunct-runs either
   // promotes or leaves for a human. Joining the lines would destroy the
-  // structure and hand PG006 a flat run it would merge wrongly.
+  // structure and hand list-interpunct-joined-run a flat run it would merge wrongly.
   const stacked = new Set(paragraphsOf(doc, runs.filter(isStacked)));
   for (const view of proseParagraphs(doc)) {
     // A hard break is structure the author chose, so the paragraph is left
@@ -90,10 +117,10 @@ const fix: Rule["fix"] = ({ doc, runs }) => {
   return edits;
 };
 
-export const pg001: Rule = {
+export const sentenceOnePerLine: Rule = {
   id: RULE.WRAP,
   category: "sentence",
-  summary: "mid-sentence line wrap (one sentence per line)",
+  summary: "mid-sentence line wrap or several sentences on one line (one sentence per line)",
   check,
   fix,
 };

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

@@ -0,0 +1,57 @@
+// sentence-word-budget-exceeded: sentences over the word budget are hard to unpack, especially for
+// ESL readers and translators. Never autofixed: shortening a sentence is a
+// rewrite, and a rewrite needs discretion. The message estimates the clauses
+// in the sentence so the rewrite splits it rather than compressing it.
+
+import { type LanguageSentence, sentenceOf } from "../language.ts";
+import { proseParagraphs } from "../query.ts";
+import { words } from "../text.ts";
+import { RULE, type Rule } from "./types.ts";
+
+// A clause boundary is a semicolon or colon with text after it, a comma
+// before a coordinating conjunction, or a subordinating or relative word.
+// ", which" matches once, through the subordinator alone. An Oxford comma in
+// a list reads as a boundary too.
+const CLAUSE_BOUNDARY =
+  /[;:](?=\s+\S)|,\s+(?:and|but|or|so|yet|nor)\b|\b(?:because|although|though|whereas|unless|whenever|wherever|while|when|if|which|who|whom|whose)\b/gi;
+
+// Two signals, and the count is the larger. Every clause has a verb, so the
+// verb phrases compromise finds catch a series of verbs and a clause joined
+// with no marker word. Its tagger misses some verbs, such as "reparses", so
+// the punctuation and marker words stay as a floor. The count is a guide,
+// not a parse.
+export const clausesOf = (sentence: LanguageSentence): number =>
+  Math.max(1 + [...sentence.text.matchAll(CLAUSE_BOUNDARY)].length, sentence.verbPhrases);
+
+export const countClauses = (sentence: string): number => clausesOf(sentenceOf(sentence));
+
+const excerpt = (sentence: string): string => (sentence.length > 60 ? `${sentence.slice(0, 60)}...` : sentence);
+
+const messageOf = (sentence: LanguageSentence, maxWords: number): string => {
+  const count = words(sentence.text);
+  const clauses = clausesOf(sentence);
+  const target = Math.max(2, clauses, Math.ceil(count / maxWords));
+  const clauseNote = `${clauses} potential clause${clauses === 1 ? "" : "s"}`;
+  return `sentence has ${count} words (budget ${maxWords}) and ${clauseNote}; split it into about ${target} shorter sentences, one idea each, rather than compressing the wording: "${excerpt(sentence.text)}"`;
+};
+
+// The message for one sentence, as a plugin's helpers give it.
+export const lengthMessage = (sentence: string, maxWords: number): string => messageOf(sentenceOf(sentence), maxWords);
+
+// Sentences come from each paragraph's language view, so an abbreviation or
+// a decimal never ends one early.
+const check: Rule["check"] = ({ doc, file, maxWords }) =>
+  proseParagraphs(doc).flatMap((view) =>
+    view.language.sentences
+      .filter((sentence) => words(sentence.text) > maxWords)
+      .map((sentence) => ({ file, line: view.line, rule: RULE.LENGTH, message: messageOf(sentence, maxWords) })),
+  );
+
+// No fixer: shortening a sentence changes its words, per PRS-0006.
+export const sentenceWordBudgetExceeded: Rule = {
+  id: RULE.LENGTH,
+  category: "sentence",
+  summary: "sentence longer than the word budget (default 25)",
+  options: { maxWords: "number" },
+  check,
+};

package/src/rules/types.ts

@@ -6,18 +6,31 @@ import type { InterpunctRun } from "../interpunct.ts";
 import type { DocModel, ParagraphView } from "../model.ts";
 
 export const RULE = {
-  WRAP: "PG001",
-  LENGTH: "PG002",
-  SEMICOLON_LIST: "PG003",
-  EM_DASH: "PG004",
-  INTERPUNCT: "PG005",
-  INTERPUNCT_RUN: "PG006",
-  INLINE_ENUM: "PG007",
-  LABELLED_RUN: "PG008",
-  STACKED_RUNS: "PG009",
+  WRAP: "sentence-one-per-line",
+  LENGTH: "sentence-word-budget-exceeded",
+  SEMICOLON_LIST: "list-semicolon-delimited-run",
+  EM_DASH: "punctuation-em-dash-in-prose",
+  INTERPUNCT: "punctuation-interpunct-in-prose",
+  INTERPUNCT_RUN: "list-interpunct-joined-run",
+  INLINE_ENUM: "list-inline-enumeration-markers",
+  LABELLED_RUN: "list-comma-labelled-run",
+  STACKED_RUNS: "list-stacked-interpunct-runs",
+  PARAGRAPH_LENGTH: "paragraph-sentence-budget-exceeded",
 } as const;
 
-export type RuleId = (typeof RULE)[keyof typeof RULE];
+// A core id has no slash. A plugin id is always namespace/name, so the slash
+// is what tells the two apart.
+export type CoreRuleId = (typeof RULE)[keyof typeof RULE];
+
+// A rule function may be synchronous or return a promise, so a rule can call a tool
+// or a service. The engine awaits every call.
+export type Awaitable<T> = T | Promise<T>;
+
+export type PluginRuleId = `${string}/${string}`;
+
+export const isPluginRuleId = (id: string): id is PluginRuleId => id.includes("/");
+
+export type RuleId = CoreRuleId | PluginRuleId;
 
 export interface Finding {
   file: string;
@@ -26,23 +39,50 @@ export interface Finding {
   message: string;
 }
 
-// What every rule reads, computed once per document and handed to it. Shared
-// data is passed in rather than recomputed, so a check and a fix can never
-// disagree about what the document holds.
+// The data every rule shares, computed once per document and handed to it.
+// Shared data is passed in rather than recomputed, so a check and a fix can
+// never disagree about what the document holds. `runs` is every interpunct
+// run. `reported` is the runs some enabled rule owns, so a rule that defers
+// to another stops deferring when that rule is switched off.
 export interface RuleContext {
   doc: DocModel;
   runs: InterpunctRun[];
+  reported: InterpunctRun[];
+}
+
+// What a rule may be configured with. A rule names each option it accepts
+// and the type of its value, and the config is checked against that.
+export type OptionType = "number" | "string" | "boolean" | "string[]";
+
+export type OptionSpec = Readonly<Record<string, OptionType>>;
+
+export type RuleOptions = Readonly<Record<string, unknown>>;
+
+// Plain functions a plugin can use without importing this package, so a plugin
+// never depends on resolving the host from its own location.
+export interface TextHelpers {
+  words: (text: string) => number;
+  sentences: (text: string) => string[];
+  lengthMessage: (sentence: string, maxWords: number) => string;
 }
 
 // A check also names the file it reports against, and the sentence budget.
+// `earlier` is what the rules of the categories in its `after` reported, and
+// is empty for a rule that runs after none.
 export interface CheckContext extends RuleContext {
   file: string;
   maxWords: number;
+  earlier: readonly Finding[];
+  options: RuleOptions;
+  helpers: TextHelpers;
 }
 
-// A fix needs nothing beyond the shared context. It proposes edits, and the
-// engine alone decides which of them survive verification.
-export type FixContext = RuleContext;
+// A fix needs nothing beyond the shared context and its own options. It
+// proposes edits, and the engine alone decides which of them survive.
+export interface FixContext extends RuleContext {
+  options: RuleOptions;
+  helpers: TextHelpers;
+}
 
 // What the engine must be able to prove about the document after an edit.
 export type Expectation =
@@ -50,6 +90,9 @@ export type Expectation =
   | { kind: "same-tree" }
   // Glyphs swapped inside text: the tree keeps its shape and every word.
   | { kind: "same-shape" }
+  // The frontmatter is written differently and means the same: the YAML parses to
+  // identical data before and after, and nothing outside it moves.
+  | { kind: "same-frontmatter-data" }
   // One paragraph becomes the blocks parsed from `fragment`, and nothing else
   // in the document moves.
   | { kind: "replace-paragraph"; view: ParagraphView; fragment: string; listItems: number };
@@ -66,15 +109,22 @@ export interface Edit {
 // 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 CATEGORIES = ["sentence", "list", "punctuation"] as const;
+// paragraph: how many sentences a paragraph holds before a break.
+// A plugin may add a category of its own by declaring it.
+export const CATEGORIES = ["sentence", "paragraph", "list", "punctuation"] as const;
 
 export type Category = (typeof CATEGORIES)[number];
 
 export interface Rule {
   id: RuleId;
-  category: Category;
+  category: string;
   summary: string;
-  check: (ctx: CheckContext) => Finding[];
-  // Absent for rules whose fix needs discretion (PG002).
-  fix?: (ctx: FixContext) => Edit[];
+  // The options the rule accepts. Absent when it takes none.
+  options?: OptionSpec;
+  // Categories whose findings this rule reads, so its check runs after theirs.
+  // Absent for a rule that reads no other rule's findings.
+  after?: readonly string[];
+  check: (ctx: CheckContext) => Awaitable<Finding[]>;
+  // Absent for rules whose fix needs discretion (sentence-word-budget-exceeded).
+  fix?: (ctx: FixContext) => Awaitable<Edit[]>;
 }

package/src/testing.ts

@@ -0,0 +1,60 @@
+// A test helper for plugin authors: run one plugin rule over real strings, with
+// the same loader checks, the same context and the same verified fix engine as
+// a real run. It is a separate entry point so a plugin's tests import it and
+// production code never does.
+
+import { checkMarkdown } from "./check.ts";
+import { type FixReport, fixMarkdownReport } from "./fix/engine.ts";
+import type { Plugin, PluginRule } from "./plugins/contract.ts";
+import { parsePlugin, toRule } from "./plugins/load.ts";
+import { BUILTIN_CATEGORIES, buildRegistry, type Registry } from "./rules/registry.ts";
+import type { Finding, RuleOptions } from "./rules/types.ts";
+
+export interface RunOptions {
+  // The rule's own options, as a config would give them.
+  options?: RuleOptions;
+  // The sentence budget, as --max-words would give it.
+  maxWords?: number;
+}
+
+// Wraps a local rule module, with its optional `categories` export, as the
+// plugin the loader would build from the file under the `local` namespace.
+export const localPlugin = (key: string, mod: { default: PluginRule; categories?: Record<string, string> }): Plugin =>
+  parsePlugin(
+    "local",
+    {
+      meta: { name: "local", namespace: "local", apiVersion: 1, categories: mod.categories },
+      rules: { [key]: mod.default },
+    },
+    new Set(),
+  );
+
+const registryFor = (plugin: Plugin, key: string, options: RuleOptions): Registry => {
+  const checked = parsePlugin(plugin.meta.name, plugin, new Set());
+  const rule = checked.rules[key];
+  if (!rule)
+    throw new Error(
+      `plugin "${plugin.meta.name}" has no rule "${key}"; it has ${Object.keys(checked.rules).join(", ")}`,
+    );
+  const built = toRule(checked.meta.namespace, key, rule);
+  return buildRegistry({
+    rules: [built],
+    fixOrder: built.fix ? [built] : [],
+    categories: new Map([...BUILTIN_CATEGORIES, ...Object.entries(checked.meta.categories ?? {})]),
+    config: {
+      plugins: [],
+      pluginLoading: "strict",
+      file: null,
+      rules: new Map([[built.id, { severity: "error", options }]]),
+    },
+  });
+};
+
+// The findings one rule of the plugin reports for a document.
+export const checkRule = async (plugin: Plugin, key: string, src: string, run: RunOptions = {}): Promise<Finding[]> =>
+  checkMarkdown(src, "test.md", run.maxWords, registryFor(plugin, key, run.options ?? {}));
+
+// The document after the rule's fixer has run to a fixpoint, and what was
+// applied or refused. A fixer that loses a word throws, exactly as in a real run.
+export const fixRule = async (plugin: Plugin, key: string, src: string, run: RunOptions = {}): Promise<FixReport> =>
+  fixMarkdownReport(src, registryFor(plugin, key, run.options ?? {}));

package/src/rules/pg002-length.ts

@@ -1,45 +0,0 @@
-// PG002: sentences over the word budget are hard to unpack, especially for
-// ESL readers and translators. Never autofixed: shortening a sentence is a
-// rewrite, and a rewrite needs discretion. The message estimates the clauses
-// in the sentence so the rewrite splits it rather than compressing it.
-
-import { proseSentences } from "../query.ts";
-import { words } from "../text.ts";
-import { RULE, type Rule } from "./types.ts";
-
-// A clause boundary is a semicolon or colon with text after it, a comma
-// before a coordinating conjunction, or a subordinating or relative word.
-// ", which" matches once, through the subordinator alone. The count is a
-// guide, not a parse: an Oxford comma in a list reads as a boundary too.
-const CLAUSE_BOUNDARY =
-  /[;:](?=\s+\S)|,\s+(?:and|but|or|so|yet|nor)\b|\b(?:because|although|though|whereas|unless|whenever|wherever|while|when|if|which|who|whom|whose)\b/gi;
-
-export const countClauses = (sentence: string): number => 1 + [...sentence.matchAll(CLAUSE_BOUNDARY)].length;
-
-const excerpt = (sentence: string): string => (sentence.length > 60 ? `${sentence.slice(0, 60)}...` : sentence);
-
-export const lengthMessage = (sentence: string, maxWords: number): string => {
-  const count = words(sentence);
-  const clauses = countClauses(sentence);
-  const target = Math.max(2, clauses, Math.ceil(count / maxWords));
-  const clauseNote = `${clauses} potential clause${clauses === 1 ? "" : "s"}`;
-  return `sentence has ${count} words (budget ${maxWords}) and ${clauseNote}; split it into about ${target} shorter sentences, one idea each, rather than compressing the wording: "${excerpt(sentence)}"`;
-};
-
-const check: Rule["check"] = ({ doc, file, maxWords }) =>
-  proseSentences(doc)
-    .filter(({ sentence }) => words(sentence) > maxWords)
-    .map(({ view, sentence }) => ({
-      file,
-      line: view.line,
-      rule: RULE.LENGTH,
-      message: lengthMessage(sentence, maxWords),
-    }));
-
-// No fixer: shortening a sentence changes its words, per PRS-0006.
-export const pg002: Rule = {
-  id: RULE.LENGTH,
-  category: "sentence",
-  summary: "sentence longer than the word budget (default 25)",
-  check,
-};

package/src/rules/pg006-interpunct-run.ts

@@ -1,68 +0,0 @@
-// PG006: 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 pg006: Rule = {
-  id: RULE.INTERPUNCT_RUN,
-  category: "list",
-  summary: "interpunct-joined inline list (2+ separators)",
-  check,
-  fix,
-};

package/src/rules/pg008-labelled-run.ts

@@ -1,101 +0,0 @@
-// PG008: one sentence stringing 3+ comma-separated segments each led by a
-// label (an inline-code span, or an identifier like PG001 / 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`,
-    }));
-
-const fix: Rule["fix"] = ({ doc }) => {
-  const { src } = doc;
-  const edits: Edit[] = [];
-  for (const view of doc.paragraphs) {
-    const commas = matchesInAll(src, view.directTexts, /,(?=\s)/);
-    const colons = colonsIn(src, view);
-    if (commas === null || colons === null) continue;
-    for (const span of sentenceSpans(src, view)) {
-      const inside = commas.filter((comma) => within(comma, span));
-      if (inside.length < 2) continue;
-      // 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]);
-      if (!segments.every((segment) => LABELLED_SEGMENT.test(asProse(src, view, segment)))) continue;
-
-      // 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 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;
-
-      const edit = 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,
-      });
-      if (edit) edits.push(edit);
-      break; // one promotion per paragraph; the engine re-parses and comes back
-    }
-  }
-  return edits;
-};
-
-export const pg008: Rule = {
-  id: RULE.LABELLED_RUN,
-  category: "list",
-  summary: "comma-joined labelled run (3+ labelled segments)",
-  check,
-  fix,
-};