@jpeakai/prose-gates 0.2.0 → 0.3.0

package/src/project.ts

@@ -1,10 +1,11 @@
-// Setting up a run: find the project root, read its config, load the plugins,
-// and build the registry every check and fix in the run uses. This happens
+// Setting up a run: find the project root, read its config and its concept
+// file, load the plugins, and build the registry every check and fix in the run uses. This happens
 // once, before any file is read, so a bad config or plugin stops the run
 // before it touches a document.
 
 import { access } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
+import { loadConcepts } from "./concepts.ts";
 import { CONFIG_FILES, findConfig, loadConfig, NO_CONFIG } from "./config.ts";
 import { ConfigNotFoundError } from "./errors.ts";
 import { loadPlugins, type PluginFailure, type PluginMode } from "./plugins/index.ts";
@@ -69,6 +70,7 @@ export const setUp = async ({
   else if (collect) mode = "collect";
   else if (lenient || config.pluginLoading === "lenient") mode = "lenient";
   const plugins = await loadPlugins(root, config, mode);
+  const concepts = await loadConcepts(root);
   const registry = buildRegistry({
     rules: [...RULES, ...plugins.rules],
     fixOrder: [...FIX_ORDER, ...plugins.rules.filter((r) => r.fix)],
@@ -76,6 +78,7 @@ export const setUp = async ({
     sources: plugins.sources,
     config,
     ignoreUnknownPluginIds: mode === "lenient" || mode === "collect",
+    concepts,
   });
   return { registry, skipped: plugins.skipped, failures: plugins.failures };
 };

package/src/rules/index.ts

@@ -7,6 +7,7 @@ import { listInlineEnumerationMarkers } from "./list-inline-enumeration-markers.
 import { listInterpunctJoinedRun } from "./list-interpunct-joined-run.ts";
 import { listSemicolonDelimitedRun } from "./list-semicolon-delimited-run.ts";
 import { listStackedInterpunctRuns } from "./list-stacked-interpunct-runs.ts";
+import { paragraphSentenceBudgetExceeded } from "./paragraph-sentence-budget-exceeded.ts";
 import { punctuationEmDashInProse } from "./punctuation-em-dash-in-prose.ts";
 import { punctuationInterpunctInProse } from "./punctuation-interpunct-in-prose.ts";
 import { sentenceOnePerLine } from "./sentence-one-per-line.ts";
@@ -16,6 +17,7 @@ import type { Rule } from "./types.ts";
 export const RULES: Rule[] = [
   sentenceOnePerLine,
   sentenceWordBudgetExceeded,
+  paragraphSentenceBudgetExceeded,
   listSemicolonDelimitedRun,
   punctuationEmDashInProse,
   punctuationInterpunctInProse,

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

@@ -53,45 +53,61 @@ const check: Rule["check"] = ({ doc, file }) =>
       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;
+// 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 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;
+// 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;
 
-      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 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 edits;
+  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",

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

@@ -4,7 +4,7 @@
 // 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,52 +72,63 @@ 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,
+  });
 };
 
+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",

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

@@ -5,6 +5,7 @@
 
 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";
@@ -26,39 +27,41 @@ const check: Rule["check"] = ({ file, runs }) =>
     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;
+// 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 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 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 cuts: Range[] = [colon ?? [span[0], span[0]], ...separators];
-    const items = itemsBetween(src, cuts, span[1]);
-    if (tailIsProse(items) || (!colon && headIsProse(items))) 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();
+  if (!colon && !coversParagraph(view, span)) return null;
 
-    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;
+  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",

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/registry.ts

@@ -3,6 +3,7 @@
 // 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";
@@ -22,6 +23,7 @@ import {
 
 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"],
 ]);
@@ -45,6 +47,8 @@ export interface Registry {
   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 {
@@ -55,6 +59,7 @@ export interface RegistryInput {
   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 => {
@@ -77,13 +82,17 @@ const checkOptions = (where: string, rule: Rule, options: RuleOptions): void =>
       throw new RuleOptionError(where, rule.id, name, `option "${name}" of "${rule.id}" must be a ${want}`);
     }
   }
-  if ("maxWords" in options && !((options.maxWords as number) >= 1)) {
-    throw new RuleOptionError(where, rule.id, "maxWords", `option "maxWords" of "${rule.id}" must be at least 1`);
+  // 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[] = [];
@@ -116,6 +125,7 @@ export const buildRegistry = (input: RegistryInput): Registry => {
     categories,
     sources,
     ignoredSettings: ignored,
+    concepts,
   };
 };
 

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

@@ -1,6 +1,7 @@
 // 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.
+// 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,15 +74,23 @@ 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[] = [];
@@ -93,7 +120,7 @@ const fix: Rule["fix"] = ({ doc, runs }) => {
 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

@@ -3,38 +3,49 @@
 // 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 { 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. The count is a
-// guide, not a parse: an Oxford comma in a list reads as a boundary too.
+// ", 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;
 
-export const countClauses = (sentence: string): number => 1 + [...sentence.matchAll(CLAUSE_BOUNDARY)].length;
+// 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);
 
-export const lengthMessage = (sentence: string, maxWords: number): string => {
-  const count = words(sentence);
-  const clauses = countClauses(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)}"`;
+  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 }) =>
-  proseSentences(doc)
-    .filter(({ sentence }) => words(sentence) > maxWords)
-    .map(({ view, sentence }) => ({
-      file,
-      line: view.line,
-      rule: RULE.LENGTH,
-      message: lengthMessage(sentence, 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 = {