@jpeakai/prose-gates 0.1.2 → 0.2.0

package/src/plugins/load.ts

@@ -0,0 +1,234 @@
+// Loading: import a plugin module, check it has the shape the contract
+// promises, and turn its rules into ordinary Rules. Every failure is a named
+// PluginLoadError that says which source and why. These functions never skip
+// anything themselves: they return or throw, and the caller decides whether a
+// failed source stops the run (strict) or is reported and left out (lenient).
+
+import { basename, extname } from "node:path";
+import { pathToFileURL } from "node:url";
+import {
+  PluginConflictError,
+  PluginContractError,
+  PluginFixerError,
+  PluginImportError,
+  PluginLoadError,
+  PluginSourceError,
+} from "../errors.ts";
+import { BUILTIN_CATEGORIES } from "../rules/registry.ts";
+import type { Edit, Finding, OptionType, Rule, RuleId } from "../rules/types.ts";
+import { API_VERSION, CATEGORY_WORD, NAMESPACE, type Plugin, type PluginRule, RULE_KEY } from "./contract.ts";
+import type { PluginSource } from "./discover.ts";
+import { canImportTypeScript, type RuntimeInfo, TYPESCRIPT_HELP } from "./runtime.ts";
+
+export { PluginLoadError };
+
+const isRecord = (v: unknown): v is Record<string, unknown> => typeof v === "object" && v !== null && !Array.isArray(v);
+
+const message = (err: unknown): string => (err instanceof Error ? err.message : String(err));
+
+// TypeScript is imported as is, so it needs a runtime that can. CommonJS
+// TypeScript is never supported, because the loader imports modules.
+const checkRuntime = (source: PluginSource, runtime?: RuntimeInfo): void => {
+  const ext = extname(source.path);
+  if (ext === ".cts") {
+    throw new PluginSourceError(source.spec, "a local rule is an ES module, so use .ts or .mts, not .cts");
+  }
+  if ((ext === ".ts" || ext === ".mts") && !canImportTypeScript(runtime)) {
+    throw new PluginSourceError(source.spec, TYPESCRIPT_HELP);
+  }
+};
+
+const importModule = async (source: PluginSource, runtime?: RuntimeInfo): Promise<Record<string, unknown>> => {
+  checkRuntime(source, runtime);
+  try {
+    return (await import(pathToFileURL(source.path).href)) as Record<string, unknown>;
+  } catch (err) {
+    throw new PluginImportError(source.spec, message(err));
+  }
+};
+
+const OPTION_TYPES = new Set<OptionType>(["number", "string", "boolean", "string[]"]);
+
+// Checks one rule's declaration and returns it, so a bad rule fails at load
+// rather than the first time it runs.
+const checkRule = (spec: string, key: string, raw: unknown, own: ReadonlySet<string>): PluginRule => {
+  const where = `rule "${key}"`;
+  if (!isRecord(raw)) throw new PluginContractError(spec, `${where} must be an object`);
+  if (!RULE_KEY.test(key)) {
+    throw new PluginContractError(spec, `${where} is not a valid key; use lower-case words joined by hyphens`);
+  }
+  const { category, summary, options, check, fix } = raw;
+  if (typeof category !== "string" || !CATEGORY_WORD.test(category)) {
+    throw new PluginContractError(spec, `${where} needs a category of one lower-case word`);
+  }
+  if (!BUILTIN_CATEGORIES.has(category) && !own.has(category)) {
+    throw new PluginContractError(
+      spec,
+      `${where} uses the category "${category}", which this plugin does not declare in meta.categories`,
+    );
+  }
+  if (!key.startsWith(`${category}-`)) {
+    throw new PluginContractError(spec, `${where} must start with its category, as "${category}-short-name"`);
+  }
+  if (typeof summary !== "string" || summary === "") throw new PluginContractError(spec, `${where} needs a summary`);
+  if (typeof check !== "function") throw new PluginContractError(spec, `${where} needs a check function`);
+  if (fix !== undefined && typeof fix !== "function") {
+    throw new PluginContractError(spec, `${where} fix must be a function`);
+  }
+  if (options !== undefined) {
+    const valid = isRecord(options) && Object.values(options).every((t) => OPTION_TYPES.has(t as OptionType));
+    if (!valid) {
+      throw new PluginContractError(spec, `${where} options must map names to number, string, boolean or string[]`);
+    }
+  }
+  return raw as unknown as PluginRule;
+};
+
+const checkCategories = (spec: string, raw: unknown): Record<string, string> => {
+  if (raw === undefined) return {};
+  if (!isRecord(raw)) throw new PluginContractError(spec, "categories must map a word to a description");
+  for (const [word, description] of Object.entries(raw)) {
+    if (!CATEGORY_WORD.test(word)) throw new PluginContractError(spec, `category "${word}" is not one lower-case word`);
+    if (BUILTIN_CATEGORIES.has(word)) {
+      throw new PluginContractError(spec, `category "${word}" is built in and cannot be declared`);
+    }
+    if (typeof description !== "string" || description === "") {
+      throw new PluginContractError(spec, `category "${word}" needs a one-line description`);
+    }
+  }
+  return raw as Record<string, string>;
+};
+
+// A plugin object is checked here, apart from how it was imported, so a test
+// can hold the same plugin to the same contract the loader does.
+export const parsePlugin = (spec: string, raw: unknown, reserved: ReadonlySet<string>): Plugin => {
+  if (!isRecord(raw) || !isRecord(raw.meta) || !isRecord(raw.rules)) {
+    throw new PluginContractError(spec, "the default export must be { meta, rules }");
+  }
+  const { name, namespace, apiVersion } = raw.meta;
+  if (apiVersion !== API_VERSION) {
+    throw new PluginContractError(
+      spec,
+      `targets plugin apiVersion ${JSON.stringify(apiVersion)}, but this prose-gates supports ${API_VERSION}`,
+    );
+  }
+  if (typeof name !== "string" || name === "") throw new PluginContractError(spec, "meta.name is required");
+  if (typeof namespace !== "string" || !NAMESPACE.test(namespace)) {
+    throw new PluginContractError(spec, "meta.namespace must be lower-case words joined by hyphens");
+  }
+  if (reserved.has(namespace)) throw new PluginContractError(spec, `meta.namespace "${namespace}" is reserved`);
+  const categories = checkCategories(spec, raw.meta.categories);
+  const own = new Set(Object.keys(categories));
+  const rules = Object.fromEntries(
+    Object.entries(raw.rules).map(([key, rule]) => [key, checkRule(spec, key, rule, own)]),
+  );
+  return { meta: { name, namespace, apiVersion, categories }, rules };
+};
+
+// A package: the default export is a Plugin.
+export const loadPackage = async (source: PluginSource, reserved: ReadonlySet<string>): Promise<Plugin> =>
+  parsePlugin(source.spec, (await importModule(source)).default, reserved);
+
+export interface LocalLoad {
+  // The local files that loaded, as one plugin. Null when none did.
+  plugin: Plugin | null;
+  failures: PluginLoadError[];
+}
+
+// Local files: each default-exports one rule, keyed by its file name. They load
+// as one plugin under the fixed namespace `local`, and a file may export
+// `categories` to declare the word its rule uses. Each file fails on its own,
+// so one bad file does not hide the others, and the caller gets every failure.
+export const loadLocal = async (sources: PluginSource[], runtime?: RuntimeInfo): Promise<LocalLoad> => {
+  const failures: PluginLoadError[] = [];
+  const fail = (err: unknown): void => {
+    if (!(err instanceof PluginLoadError)) throw err;
+    failures.push(err);
+  };
+  const categories: Record<string, string> = {};
+  const owner: Record<string, string> = {};
+  const loaded: { key: string; source: PluginSource; raw: unknown }[] = [];
+  for (const source of sources) {
+    try {
+      const mod = await importModule(source, runtime);
+      if (mod.default === undefined) {
+        throw new PluginContractError(source.spec, "has no default export; export one rule");
+      }
+      const declared = checkCategories(source.spec, mod.categories);
+      for (const [word, description] of Object.entries(declared)) {
+        if (categories[word] !== undefined && categories[word] !== description) {
+          throw new PluginConflictError(
+            source.spec,
+            owner[word] as string,
+            `declares category "${word}" with a different description than another local file`,
+          );
+        }
+        categories[word] = description;
+        owner[word] = source.spec;
+      }
+      loaded.push({ key: basename(source.path, extname(source.path)), source, raw: mod.default });
+    } catch (err) {
+      fail(err);
+    }
+  }
+  const own = new Set(Object.keys(categories));
+  const rules: Record<string, PluginRule> = {};
+  for (const { key, source, raw } of loaded) {
+    try {
+      rules[key] = checkRule(source.spec, key, raw, own);
+    } catch (err) {
+      fail(err);
+    }
+  }
+  const plugin: Plugin | null =
+    Object.keys(rules).length === 0 && failures.length > 0
+      ? null
+      : { meta: { name: "local", namespace: "local", apiVersion: API_VERSION, categories }, rules };
+  return { plugin, failures };
+};
+
+const validFinding = (f: unknown): f is { line: number; message: string } =>
+  isRecord(f) && Number.isInteger(f.line) && (f.line as number) >= 1 && typeof f.message === "string";
+
+const EXPECTATIONS = new Set(["same-tree", "same-shape", "same-frontmatter-data", "replace-paragraph"]);
+
+// A plugin rule becomes a Rule whose id is namespace/key. The plugin function may
+// be synchronous or return a promise, and the wrapper awaits it. Its check cannot
+// take the run down: a throw, a rejection or a malformed finding becomes a finding for that
+// rule, and the other rules carry on. Its fixer is held to the same proof as a
+// built-in, so a fixer that throws or returns nonsense stops the run loudly.
+export const toRule = (namespace: string, key: string, rule: PluginRule): Rule => {
+  const id = `${namespace}/${key}` as RuleId;
+  const check: Rule["check"] = async (ctx) => {
+    const report = (why: string): Finding[] => [{ file: ctx.file, line: 1, rule: id, message: `plugin rule ${why}` }];
+    let found: unknown;
+    try {
+      found = await rule.check(ctx);
+    } catch (err) {
+      return report(`threw: ${message(err)}`);
+    }
+    if (!Array.isArray(found) || !found.every(validFinding)) {
+      return report("returned something other than a list of { line, message } findings");
+    }
+    return found.map((f) => ({ file: ctx.file, line: f.line, rule: id, message: f.message }));
+  };
+  const fix: Rule["fix"] = rule.fix
+    ? async (ctx) => {
+        let edits: unknown;
+        try {
+          edits = await rule.fix?.(ctx);
+        } catch (err) {
+          throw new PluginFixerError(id, `fixer threw: ${message(err)}`);
+        }
+        if (!Array.isArray(edits))
+          throw new PluginFixerError(id, "fixer returned something other than a list of edits");
+        return edits.map((e: Edit) => {
+          if (!isRecord(e) || !isRecord(e.expect) || !EXPECTATIONS.has(e.expect.kind as string)) {
+            throw new PluginFixerError(id, "fixer returned an edit with no valid expectation");
+          }
+          return { ...e, rule: id };
+        });
+      }
+    : undefined;
+  return { id, category: rule.category, summary: rule.summary, options: rule.options, check, ...(fix ? { fix } : {}) };
+};

package/src/plugins/runtime.ts

@@ -0,0 +1,15 @@
+// What the running JavaScript can import. Bun runs TypeScript directly, and Node
+// strips types from 22.18 (earlier with a flag, and not at all before 22.6). A
+// local rule written in TypeScript therefore works under `bunx --bun` or a recent
+// Node, and anywhere else it fails with a message that says how to fix it.
+
+export interface RuntimeInfo {
+  versions: Record<string, string | undefined>;
+  features: Record<string, unknown>;
+}
+
+export const canImportTypeScript = (runtime: RuntimeInfo = process as unknown as RuntimeInfo): boolean =>
+  typeof runtime.versions.bun === "string" || Boolean(runtime.features.typescript);
+
+export const TYPESCRIPT_HELP =
+  "TypeScript cannot be imported by this runtime. Run with Bun (bunx --bun @jpeakai/prose-gates), use Node 22.18 or newer, or write a .js or .mjs file";

package/src/project.ts

@@ -0,0 +1,81 @@
+// 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
+// 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 { CONFIG_FILES, findConfig, loadConfig, NO_CONFIG } from "./config.ts";
+import { ConfigNotFoundError } from "./errors.ts";
+import { loadPlugins, type PluginFailure, type PluginMode } from "./plugins/index.ts";
+import { FIX_ORDER, RULES } from "./rules/index.ts";
+import { buildRegistry, type Registry } from "./rules/registry.ts";
+
+export const LOCAL_DIR = ".prose-gates";
+
+const exists = (path: string): Promise<boolean> =>
+  access(path).then(
+    () => true,
+    () => false,
+  );
+
+// The nearest ancestor of the working directory that marks a project: a
+// package.json, a config file or a .prose-gates directory. With none, the
+// working directory itself, so a loose folder of notes still works.
+export const findProjectRoot = async (cwd: string): Promise<string> => {
+  const markers = ["package.json", LOCAL_DIR, ...CONFIG_FILES];
+  for (let dir = resolve(cwd); ; dir = dirname(dir)) {
+    for (const marker of markers) if (await exists(join(dir, marker))) return dir;
+    if (dirname(dir) === dir) return resolve(cwd);
+  }
+};
+
+export interface SetupOptions {
+  cwd: string;
+  configPath?: string;
+  // Built-ins only. Anything discovered is reported as skipped.
+  noPlugins?: boolean;
+  // Skip a plugin that fails to load and say so, instead of stopping the run.
+  lenient?: boolean;
+  // Load every plugin and report every failure, without stopping at the first.
+  collect?: boolean;
+}
+
+export interface Setup {
+  registry: Registry;
+  skipped: string[];
+  // Plugins left out because they failed. Empty unless the run was lenient or collecting.
+  failures: PluginFailure[];
+}
+
+export const setUp = async ({
+  cwd,
+  configPath,
+  noPlugins = false,
+  lenient = false,
+  collect = false,
+}: SetupOptions): Promise<Setup> => {
+  const root = await findProjectRoot(cwd);
+  let file: string | null;
+  if (configPath !== undefined) {
+    file = resolve(cwd, configPath);
+    if (!(await exists(file))) throw new ConfigNotFoundError(configPath);
+  } else {
+    file = await findConfig(root);
+  }
+  const config = file ? await loadConfig(file) : NO_CONFIG;
+  let mode: PluginMode = "strict";
+  if (noPlugins || config.plugins === false) mode = "off";
+  else if (collect) mode = "collect";
+  else if (lenient || config.pluginLoading === "lenient") mode = "lenient";
+  const plugins = await loadPlugins(root, config, mode);
+  const registry = buildRegistry({
+    rules: [...RULES, ...plugins.rules],
+    fixOrder: [...FIX_ORDER, ...plugins.rules.filter((r) => r.fix)],
+    categories: plugins.categories,
+    sources: plugins.sources,
+    config,
+    ignoreUnknownPluginIds: mode === "lenient" || mode === "collect",
+  });
+  return { registry, skipped: plugins.skipped, failures: plugins.failures };
+};

package/src/rules/index.ts

@@ -2,27 +2,39 @@
 // 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 { interpunctRuns } from "../interpunct.ts";
-import type { DocModel } from "../model.ts";
-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, RuleContext } from "./types.ts";
+import { listCommaLabelledRun } from "./list-comma-labelled-run.ts";
+import { listInlineEnumerationMarkers } from "./list-inline-enumeration-markers.ts";
+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 { punctuationEmDashInProse } from "./punctuation-em-dash-in-prose.ts";
+import { punctuationInterpunctInProse } from "./punctuation-interpunct-in-prose.ts";
+import { sentenceOnePerLine } from "./sentence-one-per-line.ts";
+import { sentenceWordBudgetExceeded } from "./sentence-word-budget-exceeded.ts";
+import type { Rule } from "./types.ts";
 
-export const RULES: Rule[] = [pg001, pg002, pg003, pg004, pg005, pg006, pg007, pg008, pg009];
-
-// The data every rule shares, derived once per document. Interpunct runs are
-// read by four rules, so computing them here keeps the fix engine from
-// rebuilding them once per rule on every pass of the fixpoint loop.
-export const ruleContext = (doc: DocModel): RuleContext => ({ doc, runs: interpunctRuns(doc) });
+export const RULES: Rule[] = [
+  sentenceOnePerLine,
+  sentenceWordBudgetExceeded,
+  listSemicolonDelimitedRun,
+  punctuationEmDashInProse,
+  punctuationInterpunctInProse,
+  listInterpunctJoinedRun,
+  listInlineEnumerationMarkers,
+  listCommaLabelledRun,
+  listStackedInterpunctRuns,
+];
 
 // 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
+// a glyph swap would erase, so list-stacked-interpunct-runs and the list rules run before punctuation-interpunct-in-prose
 // turns interpuncts into commas. Reflow runs last, over the settled blocks.
-export const FIX_ORDER: Rule[] = [pg009, pg007, pg008, pg006, pg003, pg005, pg004, pg001];
+export const FIX_ORDER: Rule[] = [
+  listStackedInterpunctRuns,
+  listInlineEnumerationMarkers,
+  listCommaLabelledRun,
+  listInterpunctJoinedRun,
+  listSemicolonDelimitedRun,
+  punctuationInterpunctInProse,
+  punctuationEmDashInProse,
+  sentenceOnePerLine,
+];

package/src/rules/{pg008-labelled-run.ts → list-comma-labelled-run.ts}

@@ -1,5 +1,5 @@
-// PG008: one sentence stringing 3+ comma-separated segments each led by a
-// label (an inline-code span, or an identifier like PG001 / MD025 / S4)
+// list-comma-labelled-run: one sentence stringing 3+ comma-separated segments each led by a
+// label (an inline-code span, or an identifier like sentence-one-per-line / MD025 / S4)
 // WITH content after it is a hidden list of labelled items. Bare labels
 // ("A, B, and C are interchangeable") are a subject enumeration, not a
 // list. An optional "Rules: " style intro on the first segment, and a
@@ -92,7 +92,7 @@ const fix: Rule["fix"] = ({ doc }) => {
   return edits;
 };
 
-export const pg008: Rule = {
+export const listCommaLabelledRun: Rule = {
   id: RULE.LABELLED_RUN,
   category: "list",
   summary: "comma-joined labelled run (3+ labelled segments)",

package/src/rules/{pg007-inline-enum.ts → list-inline-enumeration-markers.ts}

@@ -1,4 +1,4 @@
-// PG007: parenthesised enumerators inlined in one paragraph are a hidden
+// list-inline-enumeration-markers: parenthesised enumerators inlined in one paragraph are a hidden
 // list. Requiring the first two members of a family keeps citations and a
 // lone "(a)" reference from firing. The fix only trusts a clean sequence:
 // every marker in order, none skipped, none from another family.
@@ -118,7 +118,7 @@ const fix: Rule["fix"] = ({ doc }) => {
   return edits;
 };
 
-export const pg007: Rule = {
+export const listInlineEnumerationMarkers: Rule = {
   id: RULE.INLINE_ENUM,
   category: "list",
   summary: "enumeration markers (a)/(b) or (1)/(2) inlined in prose",

package/src/rules/{pg006-interpunct-run.ts → list-interpunct-joined-run.ts}

@@ -1,4 +1,4 @@
-// PG006: a single-line interpunct-joined run is a disguised flat list. The
+// list-interpunct-joined-run: 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.
@@ -59,7 +59,7 @@ const fix: Rule["fix"] = ({ doc, runs }) => {
   return edits;
 };
 
-export const pg006: Rule = {
+export const listInterpunctJoinedRun: Rule = {
   id: RULE.INTERPUNCT_RUN,
   category: "list",
   summary: "interpunct-joined inline list (2+ separators)",

package/src/rules/{pg003-semicolon-list.ts → list-semicolon-delimited-run.ts}

@@ -1,4 +1,4 @@
-// PG003: a run of items joined by semicolons is a wall of text hiding a
+// list-semicolon-delimited-run: 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.
 
@@ -51,7 +51,7 @@ const fix: Rule["fix"] = ({ doc }) => {
   return edits;
 };
 
-export const pg003: Rule = {
+export const listSemicolonDelimitedRun: Rule = {
   id: RULE.SEMICOLON_LIST,
   category: "list",
   summary: "semicolon-delimited list (2+ ';' in one sentence)",

package/src/rules/{pg009-stacked-runs.ts → list-stacked-interpunct-runs.ts}

@@ -1,5 +1,5 @@
-// PG009: interpunct runs stacked on 2+ source lines of one paragraph are a
-// two-level structure, so PG009 replaces PG006 for that paragraph. The fix
+// list-stacked-interpunct-runs: interpunct runs stacked on 2+ source lines of one paragraph are a
+// two-level structure, so list-stacked-interpunct-runs replaces list-interpunct-joined-run for that paragraph. The fix
 // needs every line to read `Label: a · b · c`, and builds one parent bullet
 // per label with the items nested beneath it.
 
@@ -71,7 +71,7 @@ const fix: Rule["fix"] = ({ doc, runs }) => {
   return edits;
 };
 
-export const pg009: Rule = {
+export const listStackedInterpunctRuns: Rule = {
   id: RULE.STACKED_RUNS,
   category: "list",
   summary: "interpunct runs stacked on several lines (nested list)",

package/src/rules/{pg004-em-dash.ts → punctuation-em-dash-in-prose.ts}

@@ -1,4 +1,4 @@
-// PG004: an em-dash in prose. Code is exempt by construction, since only
+// punctuation-em-dash-in-prose: 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.
@@ -99,7 +99,7 @@ const replacementFor = (src: string, { dashes, hasColon }: Aside): string | null
   const closing = last(dashes);
 
   // A pair wraps an aside, so it becomes parentheses. An aside that reads as
-  // "(b)" would plant a PG007 marker and hide the word from the fingerprint.
+  // "(b)" would plant a list-inline-enumeration-markers marker and hide the word from the fingerprint.
   if (dashes.length === 2) {
     const inner = src.slice(opening.range[1], closing.range[0]);
     return MARKER_LIKE.test(inner.trim()) ? null : ` (${inner}) `;
@@ -146,7 +146,7 @@ const fix: Rule["fix"] = ({ doc }) =>
     .map((aside) => rewrite(doc.src, aside))
     .filter((edit): edit is Edit => edit !== null);
 
-export const pg004: Rule = {
+export const punctuationEmDashInProse: Rule = {
   id: RULE.EM_DASH,
   category: "punctuation",
   summary: "em-dash U+2014 in prose",

package/src/rules/{pg005-interpunct.ts → punctuation-interpunct-in-prose.ts}

@@ -1,5 +1,5 @@
-// 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
+// punctuation-interpunct-in-prose: a stray interpunct in prose. One inside a reported run is left to
+// list-interpunct-joined-run or list-stacked-interpunct-runs. 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 { GLYPH, INTERPUNCT } from "../interpunct.ts";
@@ -8,11 +8,11 @@ import { inRanges } from "../text.ts";
 import { type Edit, RULE, type Rule } from "./types.ts";
 
 // Only a separator reads as a comma: the spaces on both sides are what make
-// the glyph a joiner rather than part of a name. PG006 and PG009 split on a
+// the glyph a joiner rather than part of a name. list-interpunct-joined-run and list-stacked-interpunct-runs split on a
 // looser one, because a run has already proved itself a list.
 const SEPARATOR = /[ \t]+·[ \t]+/;
 
-const check: Rule["check"] = ({ doc, file, runs }) => {
+const check: Rule["check"] = ({ doc, file, reported: runs }) => {
   const reported = runs.map((run) => run.range);
   return textsContaining(doc, INTERPUNCT)
     .filter((text) => text.start === undefined || !inRanges(text.start, reported))
@@ -24,7 +24,7 @@ const check: Rule["check"] = ({ doc, file, runs }) => {
     }));
 };
 
-const fix: Rule["fix"] = ({ doc, runs }) => {
+const fix: Rule["fix"] = ({ doc, reported: runs }) => {
   const reported = runs.map((run) => run.range);
   const edits: Edit[] = [];
   for (const { start, end, value } of textsContaining(doc, INTERPUNCT)) {
@@ -43,7 +43,7 @@ const fix: Rule["fix"] = ({ doc, runs }) => {
   return edits;
 };
 
-export const pg005: Rule = {
+export const punctuationInterpunctInProse: Rule = {
   id: RULE.INTERPUNCT,
   category: "punctuation",
   summary: "interpunct U+00B7 in prose",