@jpeakai/prose-gates 0.1.0

package/src/model.ts

@@ -0,0 +1,165 @@
+// The document model: markdown parsed to mdast once, then flattened into the
+// views every rule and fixer reads. Code spans, code blocks, tables and
+// frontmatter are exempt by construction, never by pattern matching.
+
+import type { Code, InlineCode, Node, Paragraph, Parent, Root, Text } from "mdast";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { frontmatter } from "micromark-extension-frontmatter";
+import { gfm } from "micromark-extension-gfm";
+import { visitParents } from "unist-util-visit-parents";
+
+// Fenced blocks in these languages hold markdown templates (a conventions or
+// skeleton file shown verbatim): their prose is audited as embedded markdown
+// instead of being exempt as code. Check-only, so no fix rewrites through a
+// fence boundary.
+const MARKDOWN_FENCE_LANGS = new Set(["markdown", "md"]);
+
+export type Range = [number, number];
+
+// A text node that is a direct child of its paragraph. Only these carry
+// separators a fixer may split on: text inside a link, emphasis or code is
+// cargo and moves whole.
+export interface DirectText {
+  value: string;
+  start: number;
+  end: number;
+}
+
+// One paragraph with everything the rules need, derived in a single walk.
+export interface ParagraphView {
+  node: Paragraph;
+  raw: string; // exact source slice
+  line: number;
+  startOffset: number;
+  endOffset: number;
+  startColumn: number;
+  prose: string; // text values joined; inline code becomes one CODE token
+  codeRanges: Range[]; // inline-code offsets in src
+  directTexts: DirectText[];
+  hasBreak: boolean; // a hard line break is structure, so reflow leaves it
+  inTable: boolean; // check rules skip table cells
+  inBlockquote: boolean;
+  inListItem: boolean;
+  onlyChild: boolean; // the paragraph is its parent's only block
+}
+
+export interface TextView {
+  value: string;
+  line: number;
+  offset: number | undefined;
+  start: number | undefined;
+  end: number | undefined;
+  block: Node | undefined; // nearest paragraph, heading or table cell
+}
+
+// A fenced code block tagged markdown/md: a template whose body is itself
+// markdown prose, audited recursively.
+export interface FenceView {
+  value: string; // fence body (starts on the line after the opening fence)
+  line: number; // line of the opening fence
+}
+
+export interface DocModel {
+  src: string;
+  tree: Root;
+  paragraphs: ParagraphView[];
+  texts: TextView[]; // every prose text node, including headings and lists
+  fences: FenceView[]; // embedded-markdown fences, audited recursively
+}
+
+export const parse = (src: string): Root =>
+  // Frontmatter is metadata, not prose. Without this extension a leading
+  // `---` block parses as a thematicBreak followed by a setext heading whose
+  // text is the raw YAML, so every text rule fires on it.
+  fromMarkdown(src, {
+    extensions: [frontmatter(["yaml", "toml"]), gfm()],
+    mdastExtensions: [frontmatterFromMarkdown(["yaml", "toml"]), gfmFromMarkdown()],
+  });
+
+export const buildDocModel = (src: string): DocModel => {
+  const tree = parse(src);
+  const paragraphs: ParagraphView[] = [];
+  const texts: TextView[] = [];
+  const fences: FenceView[] = [];
+  const viewOf = new Map<Paragraph, ParagraphView>();
+  const proseParts = new Map<Paragraph, string[]>();
+
+  visitParents(tree, (node: Node, ancestors: Node[]) => {
+    if (node.type === "code") {
+      const c = node as Code;
+      if (c.lang != null && MARKDOWN_FENCE_LANGS.has(c.lang) && c.position) {
+        fences.push({ value: c.value, line: c.position.start.line });
+      }
+      return;
+    }
+    const parent = ancestors.at(-1) as Parent | undefined;
+    if (node.type === "paragraph") {
+      const p = node as Paragraph;
+      const pos = p.position;
+      if (!pos || pos.start.offset == null || pos.end.offset == null) return;
+      const view: ParagraphView = {
+        node: p,
+        raw: src.slice(pos.start.offset, pos.end.offset),
+        line: pos.start.line,
+        startOffset: pos.start.offset,
+        endOffset: pos.end.offset,
+        startColumn: pos.start.column,
+        prose: "",
+        codeRanges: [],
+        directTexts: [],
+        hasBreak: false,
+        inTable: ancestors.some((a) => a.type === "table" || a.type === "tableCell"),
+        inBlockquote: ancestors.some((a) => a.type === "blockquote"),
+        inListItem: ancestors.some((a) => a.type === "listItem"),
+        onlyChild: parent !== undefined && parent.children.length === 1,
+      };
+      paragraphs.push(view);
+      viewOf.set(p, view);
+      proseParts.set(p, []);
+    }
+    const paragraph = ancestors.findLast((a): a is Paragraph => a.type === "paragraph");
+    const view = paragraph ? viewOf.get(paragraph) : undefined;
+    if (node.type === "text") {
+      const t = node as Text;
+      const start = t.position?.start.offset;
+      const end = t.position?.end.offset;
+      texts.push({
+        value: t.value,
+        line: t.position?.start.line ?? 0,
+        offset: start,
+        start,
+        end,
+        block: ancestors.findLast((a) => a.type === "paragraph" || a.type === "heading" || a.type === "tableCell"),
+      });
+      if (paragraph) proseParts.get(paragraph)?.push(t.value);
+      if (view && parent === paragraph && start != null && end != null) {
+        view.directTexts.push({ value: t.value, start, end });
+      }
+    } else if (node.type === "inlineCode" && view) {
+      const c = node as InlineCode;
+      proseParts.get(paragraph as Paragraph)?.push("CODE");
+      if (c.position?.start.offset != null && c.position.end.offset != null) {
+        view.codeRanges.push([c.position.start.offset, c.position.end.offset]);
+      }
+    } else if (node.type === "break" && view) {
+      view.hasBreak = true;
+    }
+  });
+
+  for (const [p, parts] of proseParts) {
+    const view = viewOf.get(p);
+    if (view) view.prose = parts.join(" ").replace(/\s+/g, " ").trim();
+  }
+  return { src, tree, paragraphs, texts, fences };
+};
+
+export const inRanges = (offset: number, ranges: Range[]): boolean =>
+  ranges.some(([a, b]) => offset >= a && offset < b);
+
+export const sentences = (text: string): string[] =>
+  text
+    .split(/(?<=[.!?])\s+/)
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);

package/src/rules/index.ts

@@ -0,0 +1,21 @@
+// The rule catalogue, in id order. To add a rule: write one module exporting
+// a Rule with its category, register it here, and add its section and
+// examples to RULES.md, which tests/rules-doc.test.ts holds to the code.
+
+import { pg001 } from "./pg001-wrap.ts";
+import { pg002 } from "./pg002-length.ts";
+import { pg003 } from "./pg003-semicolon-list.ts";
+import { pg004 } from "./pg004-em-dash.ts";
+import { pg005 } from "./pg005-interpunct.ts";
+import { pg006 } from "./pg006-interpunct-run.ts";
+import { pg007 } from "./pg007-inline-enum.ts";
+import { pg008 } from "./pg008-labelled-run.ts";
+import { pg009 } from "./pg009-stacked-runs.ts";
+import type { Rule } from "./types.ts";
+
+export const RULES: Rule[] = [pg001, pg002, pg003, pg004, pg005, pg006, pg007, pg008, pg009];
+
+// The order fixers run in. Structure first: a promotion needs the separators
+// a glyph swap would erase, so PG009 and the list rules run before PG005
+// turns interpuncts into commas. Reflow runs last, over the settled blocks.
+export const FIX_ORDER: Rule[] = [pg009, pg007, pg008, pg006, pg003, pg005, pg004, pg001];

package/src/rules/interpunct.ts

@@ -0,0 +1,19 @@
+// 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

@@ -0,0 +1,79 @@
+// 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/pg002-length.ts

@@ -0,0 +1,44 @@
+// 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 { sentences } from "../model.ts";
+import { type Finding, 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 = (s: string): string => (s.length > 60 ? `${s.slice(0, 60)}...` : s);
+
+export const lengthMessage = (sentence: string, maxWords: number): string => {
+  const words = sentence.split(/\s+/).length;
+  const clauses = countClauses(sentence);
+  const target = Math.max(2, clauses, Math.ceil(words / 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)}"`;
+};
+
+export const pg002: 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;
+  },
+};

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

@@ -0,0 +1,68 @@
+// 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,
+};

package/src/rules/pg004-em-dash.ts

@@ -0,0 +1,117 @@
+// PG004: 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 { matchesIn } from "../fix/spans.ts";
+import type { DocModel, Range, TextView } from "../model.ts";
+import { type Edit, RULE, type Rule } from "./types.ts";
+
+// 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\u200b]*—[\p{Zs}\t\u200b]*/u;
+
+// An aside that reads as an enumeration marker, "(b)", would plant a PG007
+// marker and hide the word from the content fingerprint.
+const MARKER_LIKE = /^(?:[a-z]|[ivx]+|\d+)$/i;
+
+interface Dash {
+  range: Range; // the dash with its surrounding spaces
+  text: TextView;
+}
+
+const fix = (doc: DocModel): Edit[] => {
+  const { src } = doc;
+  const byBlock = new Map<unknown, { texts: TextView[]; dashes: Dash[]; refused: boolean }>();
+  for (const t of doc.texts) {
+    if (t.block === undefined || t.start === undefined || t.end === undefined) continue;
+    const entry = byBlock.get(t.block) ?? { texts: [], dashes: [], refused: false };
+    byBlock.set(t.block, entry);
+    entry.texts.push(t);
+    const found = matchesIn(src, { value: t.value, start: t.start, end: t.end }, DASH);
+    if (found === null) entry.refused = true;
+    else entry.dashes.push(...found.map((range) => ({ range, text: t })));
+  }
+
+  const edits: Edit[] = [];
+  for (const { texts, dashes, refused } of byBlock.values()) {
+    if (refused || dashes.length === 0) continue;
+    // Sentence terminals and colons, read only from prose text in this block.
+    const terminals: number[] = [];
+    const colons: number[] = [];
+    for (const t of texts) {
+      const slice = src.slice(t.start, t.end);
+      for (const m of slice.matchAll(/[.!?](?=\s)/g)) terminals.push((t.start as number) + (m.index ?? 0));
+      for (const m of slice.matchAll(/:/g)) colons.push((t.start as number) + (m.index ?? 0));
+    }
+    const sentenceOf = (offset: number): number => terminals.filter((x) => x < offset).length;
+    const groups = new Map<number, Dash[]>();
+    for (const d of dashes) {
+      const key = sentenceOf(d.range[0]);
+      groups.set(key, [...(groups.get(key) ?? []), d]);
+    }
+
+    for (const [sentence, group] of groups) {
+      const edit = rewrite(src, group, sentence, sentenceOf, colons);
+      if (edit) edits.push(edit);
+    }
+  }
+  return edits;
+};
+
+const rewrite = (
+  src: string,
+  group: Dash[],
+  sentence: number,
+  sentenceOf: (offset: number) => number,
+  colons: number[],
+): Edit | null => {
+  const first = group[0] as Dash;
+  const last = group[group.length - 1] as Dash;
+  // 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 = (d: Dash): boolean =>
+    d.range[0] === d.text.start ||
+    d.range[1] === d.text.end ||
+    /[\r\n.!?:;,(\\]/.test(src[d.range[0] - 1] ?? "\n") ||
+    /[\r\n.!?:;,)]/.test(src[d.range[1]] ?? "\n");
+  if (group.some(touchesEdge)) return null;
+
+  let text: string;
+  if (group.length === 2) {
+    const inner = src.slice(first.range[1], last.range[0]);
+    if (MARKER_LIKE.test(inner.trim())) return null;
+    text = ` (${inner}) `;
+  } else if (group.length === 1) {
+    // A numeric range like 1—2 or 2020 — 2021 wants an en-dash, not a colon,
+    // and a sentence that already has a colon would read as two labels.
+    if (/\d/.test(src[first.range[0] - 1] ?? "") && /\d/.test(src[first.range[1]] ?? "")) return null;
+    if (colons.some((c) => sentenceOf(c) === sentence)) return null;
+    text = ": ";
+  } else {
+    return null;
+  }
+  return {
+    rule: RULE.EM_DASH,
+    start: first.range[0],
+    end: last.range[1],
+    text,
+    expect: { kind: "same-shape" },
+  };
+};
+
+export const pg004: Rule = {
+  id: RULE.EM_DASH,
+  category: "punctuation",
+  summary: "em-dash U+2014 in prose",
+  check: ({ doc, file }) =>
+    doc.texts
+      .filter((t) => t.value.includes("—"))
+      .map((t) => ({
+        file,
+        line: t.line,
+        rule: RULE.EM_DASH,
+        message: "em-dash in prose; use comma, colon, parentheses, or two sentences",
+      })),
+  fix,
+};

package/src/rules/pg005-interpunct.ts

@@ -0,0 +1,43 @@
+// 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
+// with no space on either side (a product name, a unit) is left alone.
+
+import { matchesIn } from "../fix/spans.ts";
+import { type DocModel, inRanges } from "../model.ts";
+import { interpunctRuns } from "./interpunct.ts";
+import { type Edit, RULE, type Rule } from "./types.ts";
+
+const fix = (doc: DocModel): Edit[] => {
+  const runs = interpunctRuns(doc).map((r) => r.range);
+  const edits: Edit[] = [];
+  for (const t of doc.texts) {
+    if (t.start === undefined || t.end === undefined || !t.value.includes("·")) continue;
+    if (inRanges(t.start, runs)) continue;
+    const text = { value: t.value, start: t.start, end: t.end };
+    const glyphs = matchesIn(doc.src, text, /·/);
+    const spaced = matchesIn(doc.src, text, /[ \t]+·[ \t]+/);
+    if (glyphs === null || spaced === null || glyphs.length !== spaced.length) continue;
+    for (const [start, end] of spaced) {
+      edits.push({ rule: RULE.INTERPUNCT, start, end, text: ", ", expect: { kind: "same-shape" } });
+    }
+  }
+  return edits;
+};
+
+export const pg005: Rule = {
+  id: RULE.INTERPUNCT,
+  category: "punctuation",
+  summary: "interpunct U+00B7 in prose",
+  check: ({ doc, file, runs }) => {
+    const suppressed = runs.map((r) => r.range);
+    return doc.texts
+      .filter((t) => t.value.includes("·") && !(t.offset != null && inRanges(t.offset, suppressed)))
+      .map((t) => ({
+        file,
+        line: t.line,
+        rule: RULE.INTERPUNCT,
+        message: "interpunct in prose; use a comma, slash, or a list",
+      }));
+  },
+  fix,
+};

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

@@ -0,0 +1,84 @@
+// 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 { cleanItem, cleanLeadIn, promote } from "../fix/promote.ts";
+import { escaped, matchesInAll, sentenceSpan, within } from "../fix/spans.ts";
+import type { DocModel, Range } from "../model.ts";
+import { interpunctRuns } from "./interpunct.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. Without a colon, a first item
+// longer than the rest ("Built with Bun") carries a clause the list would
+// strip of its meaning.
+const words = (s: string): number => s.split(/\s+/).filter(Boolean).length;
+const tailIsProse = (items: string[]): boolean => {
+  const last = words(items[items.length - 1] ?? "");
+  const others = Math.max(...items.slice(0, -1).map(words));
+  return last > Math.max(8, 3 * others);
+};
+const headIsProse = (items: string[]): boolean => {
+  const first = words(items[0] ?? "");
+  return first > Math.max(...items.slice(1).map(words));
+};
+
+const fix = (doc: DocModel): Edit[] => {
+  const { src } = doc;
+  const edits: Edit[] = [];
+  const runs = interpunctRuns(doc).filter((r) => r.lines === 1);
+  for (const view of doc.paragraphs) {
+    if (!runs.some((r) => r.range[0] === view.startOffset)) continue;
+    const seps = matchesInAll(src, view.directTexts, /[ \t]*·[ \t]*/);
+    const colons = matchesInAll(src, view.directTexts, /:/);
+    // Every separator the check counted must be one a fixer can split on.
+    if (
+      seps === null ||
+      colons === null ||
+      seps.length !== (view.prose.match(/·/g) ?? []).length ||
+      seps.some(([s]) => escaped(src, s))
+    )
+      continue;
+    const first = seps[0] as Range;
+    const last = seps[seps.length - 1] as Range;
+    const span = sentenceSpan(src, view, first[0], last[1]);
+    const colon = colons.filter((c) => within(c, span) && c[1] <= first[0]).pop();
+    if (!colon && (span[0] !== view.startOffset || span[1] !== view.endOffset)) continue;
+
+    const cuts: Range[] = [colon ?? [span[0], span[0]], ...seps];
+    const items = cuts.map((cut, i) => {
+      const end = i + 1 < cuts.length ? (cuts[i + 1] as Range)[0] : span[1];
+      return cleanItem(src.slice(cut[1], end), { last: i + 1 === cuts.length });
+    });
+    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: ({ file, runs }) =>
+    runs
+      .filter((r) => r.lines < 2)
+      .map((r) => ({
+        file,
+        line: r.line,
+        rule: RULE.INTERPUNCT_RUN,
+        message: `interpunct-joined inline list (${r.separators + 1} items); promote to a bullet list`,
+      })),
+  fix,
+};