@jpeakai/prose-gates 0.1.1 → 0.2.0

package/src/rules/sentence-one-per-line.ts

@@ -0,0 +1,99 @@
+// sentence-one-per-line: 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.
+
+import { isStacked, paragraphsOf } from "../interpunct.ts";
+import type { ParagraphView } from "../model.ts";
+import { proseParagraphs } from "../query.ts";
+import { collapse, inRanges } from "../text.ts";
+import { type Edit, RULE, type Rule } from "./types.ts";
+
+// A line break after one of these ends a sentence, so it is authored layout.
+const TERMINALS = new Set([".", "!", "?", ":", ";"]);
+
+// What may sit between the terminal and the break: trailing space, a carriage
+// return, or the backslash form of a hard break.
+const TRAILING = new Set([" ", "\t", "\r", "\\"]);
+
+// A sentence ends at a terminal followed by space, and the next one opens with
+// a capital or an opening delimiter. Anything else is an abbreviation.
+const SENTENCE_BREAK = /[.!?]\s+(?=[A-Z`"'([])/g;
+
+// Offsets within the paragraph where a line break interrupts a sentence.
+const wrapsIn = (view: ParagraphView): number[] => {
+  const wraps: number[] = [];
+  for (let i = 0; i < view.raw.length; i++) {
+    if (view.raw[i] !== "\n") continue;
+    if (inRanges(view.startOffset + i, view.codeRanges)) continue;
+    let j = i - 1;
+    while (j >= 0 && TRAILING.has(view.raw.charAt(j))) j--;
+    if (j >= 0 && !TERMINALS.has(view.raw.charAt(j))) wraps.push(i);
+  }
+  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.
+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 lines: string[] = [];
+  let from = 0;
+  for (const match of joinedMask.matchAll(SENTENCE_BREAK)) {
+    const at = match.index ?? 0;
+    lines.push(joined.slice(from, at + 1));
+    from = at + match[0].length;
+  }
+  lines.push(joined.slice(from));
+  return lines.map((line, i) => (i === 0 ? line.trim() : indent + line.trim())).join(eol);
+};
+
+const check: Rule["check"] = ({ doc, file }) =>
+  proseParagraphs(doc).flatMap((view) =>
+    wrapsIn(view).map((at) => ({
+      file,
+      line: view.line + view.raw.slice(0, at).split("\n").length - 1,
+      rule: RULE.WRAP,
+      message: "mid-sentence line wrap; write one sentence per line",
+    })),
+  );
+
+const fix: Rule["fix"] = ({ doc, runs }) => {
+  const edits: Edit[] = [];
+  // 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 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
+    // exactly as written.
+    if (view.inBlockquote || view.hasBreak) continue;
+    if (stacked.has(view)) continue;
+
+    const text = reflow(view);
+    if (text === view.raw) continue;
+    edits.push({
+      rule: RULE.WRAP,
+      start: view.startOffset,
+      end: view.endOffset,
+      text,
+      expect: { kind: "same-tree" },
+    });
+  }
+  return edits;
+};
+
+export const sentenceOnePerLine: Rule = {
+  id: RULE.WRAP,
+  category: "sentence",
+  summary: "mid-sentence line wrap (one sentence per line)",
+  check,
+  fix,
+};

package/src/rules/{pg002-length.ts → sentence-word-budget-exceeded.ts}

@@ -1,10 +1,11 @@
-// PG002: sentences over the word budget are hard to unpack, especially for
+// 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 { sentences } from "../model.ts";
-import { type Finding, RULE, type Rule } from "./types.ts";
+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.
@@ -15,30 +16,31 @@ const CLAUSE_BOUNDARY =
 
 export const countClauses = (sentence: string): number => 1 + [...sentence.matchAll(CLAUSE_BOUNDARY)].length;
 
-const excerpt = (s: string): string => (s.length > 60 ? `${s.slice(0, 60)}...` : s);
+const excerpt = (sentence: string): string => (sentence.length > 60 ? `${sentence.slice(0, 60)}...` : sentence);
 
 export const lengthMessage = (sentence: string, maxWords: number): string => {
-  const words = sentence.split(/\s+/).length;
+  const count = words(sentence);
   const clauses = countClauses(sentence);
-  const target = Math.max(2, clauses, Math.ceil(words / maxWords));
+  const target = Math.max(2, clauses, Math.ceil(count / maxWords));
   const clauseNote = `${clauses} potential clause${clauses === 1 ? "" : "s"}`;
-  return `sentence has ${words} words (budget ${maxWords}) and ${clauseNote}; split it into about ${target} shorter sentences, one idea each, rather than compressing the wording: "${excerpt(sentence)}"`;
+  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)}"`;
 };
 
-export const pg002: Rule = {
+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 sentenceWordBudgetExceeded: Rule = {
   id: RULE.LENGTH,
   category: "sentence",
   summary: "sentence longer than the word budget (default 25)",
-  check: ({ doc, file, maxWords }) => {
-    const findings: Finding[] = [];
-    for (const p of doc.paragraphs) {
-      if (p.inTable) continue;
-      for (const s of sentences(p.prose)) {
-        if (s.split(/\s+/).length > maxWords) {
-          findings.push({ file, line: p.line, rule: RULE.LENGTH, message: lengthMessage(s, maxWords) });
-        }
-      }
-    }
-    return findings;
-  },
+  options: { maxWords: "number" },
+  check,
 };

package/src/rules/types.ts

@@ -2,21 +2,34 @@
 // optional fixer that proposes edits. The fix engine, not the fixer, decides
 // whether an edit is safe to keep.
 
-import type { DocModel, ParagraphView, Range } from "../model.ts";
+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",
 } 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;
@@ -25,20 +38,46 @@ export interface Finding {
   message: string;
 }
 
-// Paragraphs whose prose joins a run of items with 2+ interpunct separators.
-// Shared by PG005, PG006 and PG009 as an explicit data dependency.
-export interface InterpunctRun {
-  range: Range;
-  line: number;
-  separators: number;
-  lines: number; // source lines of the paragraph that carry a separator
+// 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[];
 }
 
-export interface CheckContext {
-  doc: DocModel;
+// 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.
+export interface CheckContext extends RuleContext {
   file: string;
   maxWords: number;
-  runs: InterpunctRun[];
+  options: RuleOptions;
+  helpers: TextHelpers;
+}
+
+// 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.
@@ -47,6 +86,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 };
@@ -63,15 +105,18 @@ 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.
+// A plugin may add a category of its own by declaring it.
 export const CATEGORIES = ["sentence", "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?: (doc: DocModel) => Edit[];
+  // The options the rule accepts. Absent when it takes none.
+  options?: OptionSpec;
+  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/text.ts

@@ -0,0 +1,50 @@
+// Text and range arithmetic that knows nothing about markdown. Everything
+// here is a pure function of its arguments, so it is the one layer that can
+// be read without the document model in mind.
+
+// A half-open span of absolute offsets into a source string. Every range in
+// this package is [start, end), and is only valid for the source it was
+// computed from.
+export type Range = [number, number];
+
+// The ends of a list the caller has already proved non-empty. Written once
+// here so `noUncheckedIndexedAccess` costs the package two casts rather than
+// one per rule.
+export const first = <T>(xs: readonly T[]): T => xs[0] as T;
+
+export const last = <T>(xs: readonly T[]): T => xs[xs.length - 1] as T;
+
+export const within = (r: Range, span: Range): boolean => r[0] >= span[0] && r[1] <= span[1];
+
+// Soft line breaks collapse to single spaces; nothing else in the slice moves.
+export const collapse = (s: string): string => s.replace(/[ \t]*\r?\n[ \t]*/g, " ");
+
+// How many times a pattern matches. The pattern must be global: matchAll
+// throws otherwise, which is the loud failure we want over a silent count
+// of one.
+export const countOf = (text: string, pattern: RegExp): number => [...text.matchAll(pattern)].length;
+
+// The spans a run of cut points carves out of a sentence. Each span runs from
+// the end of its own cut to the start of the next one, and the last runs to
+// `end`. Every hidden-list fixer needs exactly this, so the fencepost is
+// written once here rather than once per rule.
+export const spansBetween = (cuts: Range[], end: number): Range[] =>
+  cuts.map((cut, i) => {
+    const next = cuts[i + 1];
+    return [cut[1], next ? next[0] : end];
+  });
+
+// Words of a sentence or an item, counted the one way for every rule.
+export const words = (text: string): number => text.split(/\s+/).filter(Boolean).length;
+
+// Whether an offset falls inside any of the ranges.
+export const inRanges = (offset: number, ranges: Range[]): boolean =>
+  ranges.some(([a, b]) => offset >= a && offset < b);
+
+// Prose split on terminals. A check reads sentences this way; a fixer needs
+// the source offsets instead and asks `sentenceSpans` for them.
+export const sentences = (text: string): string[] =>
+  text
+    .split(/(?<=[.!?])\s+/)
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);

package/src/fix/spans.ts

@@ -1,75 +0,0 @@
-// Source-offset helpers shared by fixers. Everything here works on absolute
-// offsets into the document source, and only ever looks inside text the
-// parser proved is prose.
-
-import type { DirectText, ParagraphView, Range } from "../model.ts";
-
-// Absolute offsets of every match of `pattern` inside a text node, or null
-// when the source slice and the parsed value disagree (an entity like
-// `·` or an escape). A fixer that cannot map a glyph back to the
-// source refuses rather than guesses.
-export const matchesIn = (src: string, text: DirectText, pattern: RegExp): Range[] | null => {
-  const slice = src.slice(text.start, text.end);
-  const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
-  const inSlice = [...slice.matchAll(new RegExp(pattern.source, flags))];
-  const inValue = [...text.value.matchAll(new RegExp(pattern.source, flags))];
-  if (inSlice.length !== inValue.length) return null;
-  return inSlice.map((m) => [text.start + (m.index ?? 0), text.start + (m.index ?? 0) + m[0].length]);
-};
-
-export const matchesInAll = (src: string, texts: DirectText[], pattern: RegExp): Range[] | null => {
-  const out: Range[] = [];
-  for (const t of texts) {
-    const found = matchesIn(src, t, pattern);
-    if (found === null) return null;
-    out.push(...found);
-  }
-  return out;
-};
-
-// Sentence boundaries a fixer trusts: a terminal followed by whitespace,
-// inside a direct text node. Terminals inside links, emphasis or code never
-// split a sentence. Each boundary is [end of terminal, start of next sentence].
-const boundaries = (src: string, view: ParagraphView): Range[] => {
-  const out: Range[] = [];
-  for (const t of view.directTexts) {
-    const slice = src.slice(t.start, t.end);
-    for (const m of slice.matchAll(/[.!?]+(\s+)/g)) {
-      const at = t.start + (m.index ?? 0);
-      out.push([at + m[0].length - (m[1]?.length ?? 0), at + m[0].length]);
-    }
-  }
-  return out.sort((a, b) => a[0] - b[0]);
-};
-
-// The sentence span that covers [from, to): from the start of the sentence
-// holding `from` to the end of the sentence holding `to`.
-export const sentenceSpan = (src: string, view: ParagraphView, from: number, to: number): Range => {
-  let start = view.startOffset;
-  let end = view.endOffset;
-  for (const [terminalEnd, nextStart] of boundaries(src, view)) {
-    if (nextStart <= from) start = nextStart;
-    if (terminalEnd >= to && end === view.endOffset) end = terminalEnd;
-  }
-  return [start, end];
-};
-
-// Every sentence span of a paragraph, in order.
-export const sentenceSpans = (src: string, view: ParagraphView): Range[] => {
-  const spans: Range[] = [];
-  let start = view.startOffset;
-  for (const [terminalEnd, nextStart] of boundaries(src, view)) {
-    spans.push([start, terminalEnd]);
-    start = nextStart;
-  }
-  spans.push([start, view.endOffset]);
-  return spans;
-};
-
-export const within = (r: Range, span: Range): boolean => r[0] >= span[0] && r[1] <= span[1];
-
-// Soft line breaks collapse to single spaces; nothing else in the slice moves.
-export const collapse = (s: string): string => s.replace(/[ \t]*\r?\n[ \t]*/g, " ");
-
-// A glyph the author escaped is literal text, never a separator to rewrite.
-export const escaped = (src: string, offset: number): boolean => src[offset - 1] === "\\";

package/src/rules/interpunct.ts

@@ -1,19 +0,0 @@
-// Paragraphs whose prose joins a run of items with 2+ interpunct separators.
-// PG006 and PG009 report the run, and PG005 stays quiet inside one, so the
-// runs are computed once and passed to every check as data.
-
-import type { DocModel } from "../model.ts";
-import type { InterpunctRun } from "./types.ts";
-
-export const interpunctRuns = (doc: DocModel): InterpunctRun[] => {
-  const runs: InterpunctRun[] = [];
-  for (const p of doc.paragraphs) {
-    if (p.inTable) continue;
-    const separators = (p.prose.match(/·/g) ?? []).length;
-    if (separators >= 2) {
-      const lines = p.raw.split("\n").filter((l) => l.includes("·")).length;
-      runs.push({ range: [p.startOffset, p.endOffset], line: p.line, separators, lines });
-    }
-  }
-  return runs;
-};

package/src/rules/pg001-wrap.ts

@@ -1,79 +0,0 @@
-// 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.
-
-import { type DocModel, inRanges } from "../model.ts";
-import { interpunctRuns } from "./interpunct.ts";
-import { type Edit, type Finding, RULE, type Rule } from "./types.ts";
-
-const TERMINALS = new Set([".", "!", "?", ":", ";"]);
-
-const check: Rule["check"] = ({ doc, file }) => {
-  const findings: Finding[] = [];
-  for (const p of doc.paragraphs) {
-    if (p.inTable) continue;
-    for (let i = 0; i < p.raw.length; i++) {
-      if (p.raw[i] !== "\n") continue;
-      if (inRanges(p.startOffset + i, p.codeRanges)) continue;
-      let j = i - 1;
-      while (j >= 0 && (p.raw[j] === " " || p.raw[j] === "\t" || p.raw[j] === "\r" || p.raw[j] === "\\")) j--;
-      if (j >= 0 && !TERMINALS.has(p.raw[j] as string)) {
-        const line = p.line + p.raw.slice(0, i).split("\n").length - 1;
-        findings.push({ file, line, rule: RULE.WRAP, message: "mid-sentence line wrap; write one sentence per line" });
-      }
-    }
-  }
-  return findings;
-};
-
-const fix = (doc: DocModel): Edit[] => {
-  const edits: Edit[] = [];
-  // Interpunct runs stacked on several lines are a nested list PG009 either
-  // promotes or leaves for a human. Joining the lines would destroy the
-  // structure and hand PG006 a flat run it would merge wrongly.
-  const stacked = interpunctRuns(doc)
-    .filter((r) => r.lines >= 2)
-    .map((r) => r.range[0]);
-  for (const p of doc.paragraphs) {
-    // A hard break is structure the author chose, so the paragraph is left
-    // exactly as written.
-    if (p.inTable || p.inBlockquote || p.hasBreak || stacked.includes(p.startOffset)) continue;
-
-    // Continuation lines keep the paragraph's own indent column, and the
-    // paragraph's own line ending.
-    const indent = " ".repeat(p.startColumn - 1);
-    const eol = p.raw.includes("\r\n") ? "\r\n" : "\n";
-
-    // Mask code spans character for character, keeping whitespace, so the
-    // same join applies to both strings and offsets stay aligned. A terminal
-    // inside a code span then never splits a sentence.
-    const masked = [...p.raw]
-      .map((ch, i) => (inRanges(p.startOffset + i, p.codeRanges) && !/\s/.test(ch) ? "x" : ch))
-      .join("");
-    const join = (s: string): string => s.replace(/[ \t]*\r?\n[ \t]*/g, " ");
-    const joined = join(p.raw);
-    const joinedMask = join(masked);
-
-    const out: string[] = [];
-    let last = 0;
-    for (const m of joinedMask.matchAll(/[.!?]\s+(?=[A-Z`"'([])/g)) {
-      const at = m.index ?? 0;
-      out.push(joined.slice(last, at + 1));
-      last = at + m[0].length;
-    }
-    out.push(joined.slice(last));
-    const text = out.map((s, i) => (i === 0 ? s.trim() : indent + s.trim())).join(eol);
-    if (text !== p.raw) {
-      edits.push({ rule: RULE.WRAP, start: p.startOffset, end: p.endOffset, text, expect: { kind: "same-tree" } });
-    }
-  }
-  return edits;
-};
-
-export const pg001: Rule = {
-  id: RULE.WRAP,
-  category: "sentence",
-  summary: "mid-sentence line wrap (one sentence per line)",
-  check,
-  fix,
-};

package/src/rules/pg003-semicolon-list.ts

@@ -1,68 +0,0 @@
-// PG003: 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 { cleanItem, cleanLeadIn, promote } from "../fix/promote.ts";
-import { matchesInAll, sentenceSpans, within } from "../fix/spans.ts";
-import { type DocModel, sentences } from "../model.ts";
-import { type Edit, type Finding, RULE, type Rule } from "./types.ts";
-
-const check: Rule["check"] = ({ doc, file }) => {
-  const findings: Finding[] = [];
-  for (const p of doc.paragraphs) {
-    if (p.inTable) continue;
-    for (const s of sentences(p.prose)) {
-      const semis = (s.match(/;/g) ?? []).length;
-      if (semis >= 2) {
-        findings.push({
-          file,
-          line: p.line,
-          rule: RULE.SEMICOLON_LIST,
-          message: `semicolon-delimited list (${semis} ';'); promote to a bullet list`,
-        });
-      }
-    }
-  }
-  return findings;
-};
-
-const fix = (doc: DocModel): Edit[] => {
-  const edits: Edit[] = [];
-  const { src } = doc;
-  for (const view of doc.paragraphs) {
-    const semis = matchesInAll(src, view.directTexts, /;/);
-    const colons = matchesInAll(src, view.directTexts, /:/);
-    if (semis === null || colons === null) continue;
-    for (const span of sentenceSpans(src, view)) {
-      const inside = semis.filter((r) => within(r, span));
-      if (inside.length < 2) continue;
-      const colon = colons.find((r) => within(r, span) && r[1] <= (inside[0] as [number, number])[0]);
-      if (!colon) continue;
-      const cuts = [colon, ...inside];
-      const items = cuts.map((cut, i) => {
-        const end = i + 1 < cuts.length ? (cuts[i + 1] as [number, number])[0] : span[1];
-        return { text: cleanItem(src.slice(cut[1], end), { last: i + 1 === cuts.length }) };
-      });
-      const edit = promote({
-        rule: RULE.SEMICOLON_LIST,
-        src,
-        view,
-        span,
-        leadIn: cleanLeadIn(src.slice(span[0], colon[0])),
-        items,
-        ordered: false,
-      });
-      if (edit) edits.push(edit);
-      break; // one promotion per paragraph; the engine re-parses and comes back
-    }
-  }
-  return edits;
-};
-
-export const pg003: Rule = {
-  id: RULE.SEMICOLON_LIST,
-  category: "list",
-  summary: "semicolon-delimited list (2+ ';' in one sentence)",
-  check,
-  fix,
-};