@jpeakai/prose-gates 0.1.2 → 0.3.0

package/src/config.ts

@@ -0,0 +1,119 @@
+// The config file: which rules are off, what options each takes, and how
+// strictly plugins load. It is optional, because everything auto-detected loads
+// without it. A mistake in it is a named usage error, so a stale or misspelt
+// rule id fails the run instead of silently doing nothing.
+
+import { access, readFile } from "node:fs/promises";
+import { extname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { AmbiguousConfigError, ConfigFileError, ConfigShapeError, RuleSettingError, UsageError } from "./errors.ts";
+import type { RuleOptions } from "./rules/types.ts";
+
+export { UsageError };
+
+export type Severity = "error" | "off";
+
+// How a plugin that fails to load is treated. Strict stops the run. Lenient
+// skips that plugin, says so, and carries on with the rest.
+export type PluginLoading = "strict" | "lenient";
+
+export interface RuleSetting {
+  severity: Severity;
+  options: RuleOptions;
+}
+
+export interface Config {
+  // Extra plugin paths or package names beyond what is auto-detected, or
+  // `false` for a built-ins-only run.
+  plugins: string[] | false;
+  pluginLoading: PluginLoading;
+  rules: Map<string, RuleSetting>;
+  // The file it came from, for messages. Null when there is no config.
+  file: string | null;
+}
+
+export const NO_CONFIG: Config = { plugins: [], pluginLoading: "strict", rules: new Map(), file: null };
+
+export const CONFIG_FILES = ["prose-gates.config.json", "prose-gates.config.mjs"] as const;
+
+const isRecord = (v: unknown): v is Record<string, unknown> => typeof v === "object" && v !== null && !Array.isArray(v);
+
+const parseSetting = (file: string, id: string, raw: unknown): RuleSetting => {
+  const [severity, options = {}] = Array.isArray(raw) ? raw : [raw];
+  if (Array.isArray(raw) && (raw.length < 1 || raw.length > 2)) {
+    throw new RuleSettingError(file, id, 'must be "error", "off" or [severity, options]');
+  }
+  if (severity !== "error" && severity !== "off") {
+    throw new RuleSettingError(file, id, `has severity ${JSON.stringify(severity)}; use "error" or "off"`);
+  }
+  if (!isRecord(options)) throw new RuleSettingError(file, id, "options must be an object");
+  return { severity, options };
+};
+
+export const parseConfig = (file: string, raw: unknown): Config => {
+  if (!isRecord(raw)) throw new ConfigShapeError(file, "the config must be an object");
+  for (const key of Object.keys(raw)) {
+    if (key !== "plugins" && key !== "pluginLoading" && key !== "rules") {
+      throw new ConfigShapeError(
+        file,
+        `unknown key "${key}"; a config has "plugins", "pluginLoading" and "rules"`,
+        key,
+      );
+    }
+  }
+  const { plugins = [], pluginLoading = "strict", rules = {} } = raw;
+  const validPlugins = plugins === false || (Array.isArray(plugins) && plugins.every((p) => typeof p === "string"));
+  if (!validPlugins) throw new ConfigShapeError(file, '"plugins" must be a list of strings, or false', "plugins");
+  if (pluginLoading !== "strict" && pluginLoading !== "lenient") {
+    throw new ConfigShapeError(file, '"pluginLoading" must be "strict" or "lenient"', "pluginLoading");
+  }
+  if (!isRecord(rules)) throw new ConfigShapeError(file, '"rules" must be an object', "rules");
+  return {
+    plugins: plugins as string[] | false,
+    pluginLoading,
+    rules: new Map(Object.entries(rules).map(([id, value]) => [id, parseSetting(file, id, value)])),
+    file,
+  };
+};
+
+// The first config file at the root, or null. Two at once is ambiguous, so it
+// is an error rather than a pick.
+export const findConfig = async (root: string): Promise<string | null> => {
+  const found: string[] = [];
+  for (const name of CONFIG_FILES) {
+    const path = join(root, name);
+    if (
+      await access(path).then(
+        () => true,
+        () => false,
+      )
+    )
+      found.push(path);
+  }
+  if (found.length > 1) throw new AmbiguousConfigError(root, found);
+  return found[0] ?? null;
+};
+
+const reason = (err: unknown): string => (err instanceof Error ? err.message : String(err));
+
+export const loadConfig = async (file: string): Promise<Config> => {
+  if (extname(file) === ".json") {
+    let raw: unknown;
+    try {
+      raw = JSON.parse(await readFile(file, "utf8"));
+    } catch (err) {
+      throw new ConfigFileError(file, reason(err));
+    }
+    return parseConfig(file, raw);
+  }
+  if (extname(file) === ".mjs") {
+    let mod: { default?: unknown };
+    try {
+      mod = (await import(pathToFileURL(file).href)) as { default?: unknown };
+    } catch (err) {
+      throw new ConfigFileError(file, `could not be imported: ${reason(err)}`);
+    }
+    return parseConfig(file, mod.default);
+  }
+  throw new ConfigFileError(file, "a config is a .json or .mjs file");
+};

package/src/errors.ts

@@ -0,0 +1,212 @@
+// Every way a run can fail on purpose, as a class that says what went wrong.
+// A usage error is the caller's to fix and exits 2. A plugin error exits 1.
+// Each class carries a stable `code` and the fields a tool needs to act on it,
+// so a wrapper can branch on the type instead of reading the message.
+
+export class ProseGatesError extends Error {
+  readonly code: string;
+
+  constructor(code: string, message: string) {
+    super(message);
+    this.code = code;
+    this.name = new.target.name;
+  }
+}
+
+// --- usage: the invocation or the config is wrong -------------------------
+
+export class UsageError extends ProseGatesError {
+  constructor(message: string, code = "usage") {
+    super(code, message);
+  }
+}
+
+// A flag that is missing or has a value it cannot take.
+export class FlagError extends UsageError {
+  readonly flag: string;
+
+  constructor(flag: string, message: string) {
+    super(message, "flag");
+    this.flag = flag;
+  }
+}
+
+// A config file that cannot be read or parsed, or is the wrong kind of file.
+export class ConfigFileError extends UsageError {
+  readonly file: string;
+
+  constructor(file: string, message: string) {
+    super(`${file}: ${message}`, "config-file");
+    this.file = file;
+  }
+}
+
+// --config named a file that is not there.
+export class ConfigNotFoundError extends UsageError {
+  readonly path: string;
+
+  constructor(path: string) {
+    super(`--config ${path}: no such file`, "config-not-found");
+    this.path = path;
+  }
+}
+
+// Two config files at one root, so neither can be picked.
+export class AmbiguousConfigError extends UsageError {
+  readonly files: string[];
+
+  constructor(root: string, files: string[]) {
+    super(`more than one config file at ${root}: ${files.join(", ")}`, "config-ambiguous");
+    this.files = files;
+  }
+}
+
+// A concept file at the project root that does not parse as one: no term
+// headings, a repeated term, or a diagram that names something undefined.
+export class ConceptsFileError extends UsageError {
+  readonly file: string;
+
+  constructor(file: string, message: string) {
+    super(`${file}: not a concept file, because ${message}`, "concepts-file");
+    this.file = file;
+  }
+}
+
+// Both GLOSSARY.md and CONCEPTS.md at one root, so neither can be picked.
+export class AmbiguousConceptsError extends UsageError {
+  readonly files: string[];
+
+  constructor(root: string, files: string[]) {
+    super(`more than one concept file at ${root}: ${files.join(", ")}`, "concepts-ambiguous");
+    this.files = files;
+  }
+}
+
+// The config parsed, but its top-level shape is wrong.
+export class ConfigShapeError extends UsageError {
+  readonly file: string;
+  readonly key: string | null;
+
+  constructor(file: string, message: string, key: string | null = null) {
+    super(`${file}: ${message}`, "config-shape");
+    this.file = file;
+    this.key = key;
+  }
+}
+
+// One rule's setting is not a severity, or a severity and options.
+export class RuleSettingError extends UsageError {
+  readonly file: string;
+  readonly rule: string;
+
+  constructor(file: string, rule: string, message: string) {
+    super(`${file}: rule "${rule}" ${message}`, "rule-setting");
+    this.file = file;
+    this.rule = rule;
+  }
+}
+
+// The config names a rule that is not loaded, which also catches a retired id.
+export class UnknownRuleError extends UsageError {
+  readonly file: string;
+  readonly rule: string;
+  readonly known: string[];
+
+  constructor(file: string, rule: string, known: string[]) {
+    super(
+      `${file}: unknown rule "${rule}"; a retired or misspelt id cannot be switched off. Known rules: ${known.join(", ")}`,
+      "unknown-rule",
+    );
+    this.file = file;
+    this.rule = rule;
+    this.known = known;
+  }
+}
+
+// A rule option the rule does not take, or a value of the wrong type or range.
+export class RuleOptionError extends UsageError {
+  readonly file: string;
+  readonly rule: string;
+  readonly option: string;
+
+  constructor(file: string, rule: string, option: string, message: string) {
+    super(`${file}: ${message}`, "rule-option");
+    this.file = file;
+    this.rule = rule;
+    this.option = option;
+  }
+}
+
+// --- plugins: a source could not be loaded --------------------------------
+
+// A source that failed to load. `source` is what the user would recognise, a
+// package name or a path under the project root.
+export class PluginLoadError extends ProseGatesError {
+  readonly source: string;
+
+  constructor(source: string, reason: string, code = "plugin") {
+    super(code, `plugin ${source}: ${reason}`);
+    this.source = source;
+  }
+}
+
+// The module threw, or could not be found, when it was imported.
+export class PluginImportError extends PluginLoadError {
+  constructor(source: string, reason: string) {
+    super(source, `could not be imported: ${reason}`, "plugin-import");
+  }
+}
+
+// The module loaded but does not meet the contract: shape, version, namespace,
+// category, or a rule's declaration.
+export class PluginContractError extends PluginLoadError {
+  constructor(source: string, reason: string) {
+    super(source, reason, "plugin-contract");
+  }
+}
+
+// Two plugins claim one namespace or one new category.
+export class PluginConflictError extends PluginLoadError {
+  readonly other: string;
+
+  constructor(source: string, other: string, reason: string) {
+    super(source, reason, "plugin-conflict");
+    this.other = other;
+  }
+}
+
+// A dependency the project declares, or a config lists, that is not installed.
+export class PluginNotInstalledError extends PluginLoadError {
+  readonly root: string;
+
+  constructor(source: string, root: string) {
+    super(
+      source,
+      `is declared or listed but not installed; looked from ${root} upward. Install it, or remove it`,
+      "plugin-not-installed",
+    );
+    this.root = root;
+  }
+}
+
+// A file the loader cannot read in this runtime, such as TypeScript on a
+// runtime that cannot strip types.
+export class PluginSourceError extends PluginLoadError {
+  constructor(source: string, reason: string) {
+    super(source, reason, "plugin-source");
+  }
+}
+
+// --- plugins: a loaded plugin misbehaved while running --------------------
+
+// A fixer threw or returned something that is not a list of valid edits.
+// Unlike a check, this stops the run, because carrying on after a corrupt edit
+// is worse than stopping.
+export class PluginFixerError extends ProseGatesError {
+  readonly rule: string;
+
+  constructor(rule: string, reason: string) {
+    super("plugin-fixer", `plugin rule ${rule} ${reason}`);
+    this.rule = rule;
+  }
+}

package/src/fix/engine.ts

@@ -3,9 +3,10 @@
 // edit that survives verification. Offsets are only ever valid for the
 // source they were computed from, so every accepted edit restarts the pass.
 
+import type { Root } from "mdast";
 import { buildDocModel, parse } from "../model.ts";
-import { FIX_ORDER, ruleContext } from "../rules/index.ts";
-import type { Edit } from "../rules/types.ts";
+import { BUILTIN, type Registry, ruleContext, TEXT_HELPERS } from "../rules/registry.ts";
+import type { Edit, Rule, RuleContext } from "../rules/types.ts";
 import { verify } from "./verify.ts";
 
 const MAX_PASSES = 10_000;
@@ -27,58 +28,97 @@ const overlaps = (edits: Edit[]): boolean => {
   return sorted.some((e, i) => i > 0 && e.start < (sorted[i - 1] as Edit).end);
 };
 
-export const fixMarkdownReport = (src: string): FixReport => {
-  const applied: Edit[] = [];
-  const refused: Edit[] = [];
-  // An edit refused once stays refused while its source slice is unchanged.
-  const refusedKeys = new Set<string>();
-  let current = src;
+// Offsets are whole numbers inside the source, in order, and the replacement
+// is text. Anything else is a malformed edit from a fixer that miscounted.
+const wellFormed = (e: Edit, length: number): boolean =>
+  Number.isInteger(e.start) &&
+  Number.isInteger(e.end) &&
+  e.start >= 0 &&
+  e.start <= e.end &&
+  e.end <= length &&
+  typeof e.text === "string";
 
+// What the loop carries between passes. An edit refused once stays refused
+// while its source slice is unchanged, which `refusedKeys` remembers.
+interface FixState {
+  current: string;
+  applied: Edit[];
+  refused: Edit[];
+  refusedKeys: Set<string>;
+}
+
+type Before = { src: string; tree: Root };
+
+const keyOf = (state: FixState, e: Edit): string =>
+  `${e.rule}\u0000${state.current.slice(e.start, e.end)}\u0000${e.text}`;
+
+// Splice the edits, re-parse, and keep the result only if every edit is
+// proven against the tree the pass started from.
+const attempt = (state: FixState, edits: Edit[], before: Before): boolean => {
+  const next = splice(state.current, edits);
+  const afterTree = parse(next);
+  if (!edits.every((e) => verify(e, before, afterTree) === "accept")) return false;
+  state.current = next;
+  state.applied.push(...edits);
+  return true;
+};
+
+// An edit that points outside the source cannot be proven, so it is
+// refused before it is ever spliced. A built-in never proposes one.
+const keepWellFormed = (state: FixState, proposed: Edit[]): Edit[] =>
+  proposed.filter((e) => {
+    if (wellFormed(e, state.current.length)) return true;
+    const key = `${e.rule}\u0000malformed\u0000${e.start}:${e.end}`;
+    if (!state.refusedKeys.has(key)) {
+      state.refusedKeys.add(key);
+      state.refused.push(e);
+    }
+    return false;
+  });
+
+// The rule's edits that would change something and have not been refused.
+const proposeEdits = async (state: FixState, rule: Rule, ctx: RuleContext, registry: Registry): Promise<Edit[]> => {
+  const proposed =
+    (await rule.fix?.({ ...ctx, options: registry.options.get(rule.id) ?? {}, helpers: TEXT_HELPERS })) ?? [];
+  const sound = keepWellFormed(state, proposed);
+  return sound.filter((e) => state.current.slice(e.start, e.end) !== e.text && !state.refusedKeys.has(keyOf(state, e)));
+};
+
+// Whitespace and glyph edits leave the tree's shape alone, so a rule's
+// whole batch can be proven in one re-parse. A batch that fails falls
+// back to one edit at a time, so one bad edit never blocks the rest.
+const applyRuleEdits = (state: FixState, edits: Edit[], before: Before): boolean => {
+  const batchable = edits.length > 1 && !overlaps(edits) && edits.every((e) => e.expect.kind !== "replace-paragraph");
+  if (batchable && attempt(state, edits, before)) return true;
+  for (const edit of edits) {
+    if (attempt(state, [edit], before)) return true;
+    state.refusedKeys.add(keyOf(state, edit));
+    state.refused.push(edit);
+  }
+  return false;
+};
+
+// One pass: rules in fix order until one edit lands. True when it did.
+const runPass = async (state: FixState, registry: Registry): Promise<boolean> => {
+  const ctx = ruleContext(buildDocModel(state.current, registry.concepts), registry);
+  const before = { src: state.current, tree: ctx.doc.tree };
+  for (const rule of registry.fixOrder) {
+    const edits = await proposeEdits(state, rule, ctx, registry);
+    if (edits.length === 0) continue;
+    if (applyRuleEdits(state, edits, before)) return true;
+  }
+  return false;
+};
+
+export const fixMarkdownReport = async (src: string, registry: Registry = BUILTIN): Promise<FixReport> => {
+  const state: FixState = { current: src, applied: [], refused: [], refusedKeys: new Set<string>() };
   for (let pass = 0; pass < MAX_PASSES; pass++) {
-    const ctx = ruleContext(buildDocModel(current));
-    const before = { src: current, tree: ctx.doc.tree };
-    const keyOf = (e: Edit): string => `${e.rule}\u0000${current.slice(e.start, e.end)}\u0000${e.text}`;
-
-    const attempt = (edits: Edit[]): boolean => {
-      const next = splice(current, edits);
-      const afterTree = parse(next);
-      if (edits.every((e) => verify(e, before, afterTree) === "accept")) {
-        current = next;
-        applied.push(...edits);
-        return true;
-      }
-      return false;
-    };
-
-    let progressed = false;
-    for (const rule of FIX_ORDER) {
-      const edits = (rule.fix?.(ctx) ?? []).filter(
-        (e) => current.slice(e.start, e.end) !== e.text && !refusedKeys.has(keyOf(e)),
-      );
-      if (edits.length === 0) continue;
-
-      // Whitespace and glyph edits leave the tree's shape alone, so a rule's
-      // whole batch can be proven in one re-parse. A batch that fails falls
-      // back to one edit at a time, so one bad edit never blocks the rest.
-      const batchable =
-        edits.length > 1 && !overlaps(edits) && edits.every((e) => e.expect.kind !== "replace-paragraph");
-      if (batchable && attempt(edits)) {
-        progressed = true;
-        break;
-      }
-      for (const edit of edits) {
-        if (attempt([edit])) {
-          progressed = true;
-          break;
-        }
-        refusedKeys.add(keyOf(edit));
-        refused.push(edit);
-      }
-      if (progressed) break;
+    if (!(await runPass(state, registry))) {
+      return { output: state.current, applied: state.applied, refused: state.refused };
     }
-    if (!progressed) return { output: current, applied, refused };
   }
   throw new Error(`fix did not converge after ${MAX_PASSES} passes; a fixer keeps proposing edits`);
 };
 
-export const fixMarkdown = (src: string): string => fixMarkdownReport(src).output;
+export const fixMarkdown = async (src: string, registry: Registry = BUILTIN): Promise<string> =>
+  (await fixMarkdownReport(src, registry)).output;

package/src/fix/verify.ts

@@ -5,6 +5,7 @@
 
 import type { Node, Parent, Root } from "mdast";
 import { visitParents as visit } from "unist-util-visit-parents";
+import { parse as parseYaml } from "yaml";
 import { parse } from "../model.ts";
 import type { Edit } from "../rules/types.ts";
 
@@ -105,30 +106,70 @@ const fragmentShapeOk = (nodes: Node[], listItems: number): boolean => {
   return items.length === listItems && items.every((i) => i.children[0]?.type === "paragraph");
 };
 
+const INVALID = Symbol("invalid frontmatter");
+
+// What the leading YAML block means: its data as the yaml package reads it, so a
+// rewrite that only changes how the data is written compares equal. Absent
+// frontmatter is `undefined`, and a block that does not parse is INVALID.
+const frontmatterData = (tree: Root): unknown => {
+  const first = tree.children[0];
+  if (first?.type !== "yaml") return undefined;
+  try {
+    return parseYaml(first.value);
+  } catch {
+    return INVALID;
+  }
+};
+
+// The tree with its leading frontmatter node taken off, so everything else can
+// be compared on its own.
+const withoutFrontmatter = (tree: Root): Root =>
+  tree.children[0]?.type === "yaml" ? { ...tree, children: tree.children.slice(1) } : tree;
+
 export type Verdict = "accept" | "refuse";
 
-export const verify = (edit: Edit, before: { src: string; tree: Root }, afterTree: Root): Verdict => {
-  const lost = fingerprint(before.tree).join(" ");
+// No word may be lost or moved. A mismatch is a fixer bug, so it throws and
+// names the first word where the two fingerprints part.
+const assertNoWordLost = (edit: Edit, beforeTree: Root, afterTree: Root): void => {
+  const lost = fingerprint(beforeTree).join(" ");
   const kept = fingerprint(afterTree).join(" ");
-  if (lost !== kept) {
-    const a = lost.split(" ");
-    const b = kept.split(" ");
-    const diverge = a.findIndex((w, i) => w !== b[i]);
-    const at = diverge === -1 ? a.length : diverge;
-    throw new FixInvariantError(edit, `word ${at} was "${a[at] ?? ""}", now "${b[at] ?? ""}"`);
-  }
+  if (lost === kept) return;
+  const a = lost.split(" ");
+  const b = kept.split(" ");
+  const diverge = a.findIndex((w, i) => w !== b[i]);
+  const at = diverge === -1 ? a.length : diverge;
+  throw new FixInvariantError(edit, `word ${at} was "${a[at] ?? ""}", now "${b[at] ?? ""}"`);
+};
 
-  const expect = edit.expect;
-  if (expect.kind === "same-tree") {
-    return sameJson(normalise(before.tree), normalise(afterTree)) ? "accept" : "refuse";
-  }
-  if (expect.kind === "same-shape") {
-    return sameJson(normalise(before.tree, { blankText: true }), normalise(afterTree, { blankText: true }))
-      ? "accept"
-      : "refuse";
-  }
+const verdictOf = (ok: boolean): Verdict => (ok ? "accept" : "refuse");
+
+// The frontmatter must mean the same data, and the rest of the tree must be
+// untouched.
+const sameFrontmatterData = (beforeTree: Root, afterTree: Root): Verdict => {
+  const was = frontmatterData(beforeTree);
+  const now = frontmatterData(afterTree);
+  if (was === INVALID || now === INVALID || !sameJson(was, now)) return "refuse";
+  return verdictOf(sameJson(normalise(withoutFrontmatter(beforeTree)), normalise(withoutFrontmatter(afterTree))));
+};
+
+type ReplaceParagraph = Extract<Edit["expect"], { kind: "replace-paragraph" }>;
+
+// The paragraph must become exactly the fragment the fixer declared, parsed
+// with the document's definitions, and nothing else may change.
+const replacedParagraph = (expect: ReplaceParagraph, before: { src: string; tree: Root }, afterTree: Root): Verdict => {
   const nodes = parseFragment(expect.fragment, definitionsOf(before.src, before.tree));
   if (!fragmentShapeOk(nodes, expect.listItems)) return "refuse";
   const expected = normalise(before.tree, { swap: [expect.view.node, nodes] });
-  return sameJson(expected, normalise(afterTree)) ? "accept" : "refuse";
+  return verdictOf(sameJson(expected, normalise(afterTree)));
+};
+
+export const verify = (edit: Edit, before: { src: string; tree: Root }, afterTree: Root): Verdict => {
+  assertNoWordLost(edit, before.tree, afterTree);
+  const expect = edit.expect;
+  if (expect.kind === "same-tree") return verdictOf(sameJson(normalise(before.tree), normalise(afterTree)));
+  if (expect.kind === "same-frontmatter-data") return sameFrontmatterData(before.tree, afterTree);
+  if (expect.kind === "same-shape") {
+    return verdictOf(sameJson(normalise(before.tree, { blankText: true }), normalise(afterTree, { blankText: true })));
+  }
+  return replacedParagraph(expect, before, afterTree);
 };

package/src/index.ts

@@ -2,9 +2,58 @@
 
 export { checkMarkdown, checkModel, DEFAULT_MAX_WORDS } from "./check.ts";
 export { main } from "./cli.ts";
+export {
+  CONCEPT_FILES,
+  type Concept,
+  type ConceptMention,
+  type ConceptModel,
+  type ConceptRelation,
+  KIND_OF,
+  loadConcepts,
+  NO_CONCEPTS,
+  parseConcepts,
+} from "./concepts.ts";
+export { type Config, loadConfig, type PluginLoading, parseConfig, type RuleSetting, type Severity } from "./config.ts";
+export * from "./errors.ts";
 export { type FixReport, fixMarkdown, fixMarkdownReport } from "./fix/engine.ts";
 export { FixInvariantError } from "./fix/verify.ts";
-export { buildDocModel, type DocModel } from "./model.ts";
+export type { LanguageSentence, LanguageView, LanguageWord } from "./language.ts";
+export {
+  buildDocModel,
+  type DocModel,
+  type FrontmatterEntry,
+  type FrontmatterScalar,
+  type FrontmatterView,
+  type ParagraphView,
+  type ScalarStyle,
+} from "./model.ts";
+export type { Plugin, PluginEdit, PluginFinding, PluginMeta, PluginRule } from "./plugins/contract.ts";
+export { findProjectRoot, setUp } from "./project.ts";
 export { FIX_ORDER, RULES } from "./rules/index.ts";
-export type { Category, Edit, Finding, Rule, RuleId } from "./rules/types.ts";
+export {
+  BUILTIN,
+  BUILTIN_CATEGORIES,
+  buildRegistry,
+  type LoadedSource,
+  type Registry,
+  type RegistryInput,
+} from "./rules/registry.ts";
+export type {
+  Category,
+  CheckContext,
+  CoreRuleId,
+  Edit,
+  Expectation,
+  Finding,
+  FixContext,
+  OptionSpec,
+  OptionType,
+  PluginRuleId,
+  Rule,
+  RuleContext,
+  RuleId,
+  RuleOptions,
+  TextHelpers,
+} from "./rules/types.ts";
 export { CATEGORIES, RULE } from "./rules/types.ts";
+export { sentences, words } from "./text.ts";

package/src/interpunct.ts

@@ -1,6 +1,6 @@
 // The interpunct run: the one piece of data derived from a whole document
-// that more than one rule reads. PG006 and PG009 report a run, PG005 stays
-// quiet inside one, and PG001 leaves a stacked one unreflowed, so it is
+// that more than one rule reads. list-interpunct-joined-run and list-stacked-interpunct-runs report a run, punctuation-interpunct-in-prose stays
+// quiet inside one, and sentence-one-per-line leaves a stacked one unreflowed, so it is
 // derived once per document and handed to every rule as data.
 
 import type { DocModel, ParagraphView } from "./model.ts";
@@ -10,8 +10,8 @@ import { countOf, type Range } from "./text.ts";
 export const INTERPUNCT = "·";
 
 // The glyph on its own, for counting, and the glyph with the space a run
-// puts around it, for splitting. PG006 and PG009 both cut on the separator;
-// PG005 is stricter and needs space on both sides, so it keeps its own.
+// puts around it, for splitting. list-interpunct-joined-run and list-stacked-interpunct-runs both cut on the separator;
+// punctuation-interpunct-in-prose is stricter and needs space on both sides, so it keeps its own.
 export const GLYPH = /·/g;
 export const RUN_SEPARATOR = /[ \t]*·[ \t]*/;
 
@@ -34,9 +34,9 @@ export const interpunctRuns = (doc: DocModel): InterpunctRun[] => {
   return runs;
 };
 
-// A run on one source line is a flat list, which PG006 owns. A run spread
-// over two or more lines is a two-level structure, which PG009 owns and
-// PG001 leaves unreflowed. The two predicates partition every run.
+// A run on one source line is a flat list, which list-interpunct-joined-run owns. A run spread
+// over two or more lines is a two-level structure, which list-stacked-interpunct-runs owns and
+// sentence-one-per-line leaves unreflowed. The two predicates partition every run.
 export const isFlat = (run: InterpunctRun): boolean => run.lines === 1;
 
 export const isStacked = (run: InterpunctRun): boolean => run.lines >= 2;