@jpeakai/prose-gates 0.1.2 → 0.3.0

package/src/plugins/index.ts

@@ -0,0 +1,136 @@
+// Assembling plugins: discover the sources, load each one, and merge their
+// rules and categories into the set the registry is built from. Namespaces and
+// new category words are global, so two plugins cannot share either.
+//
+// How a failed source is treated is the mode. Strict throws the first failure,
+// which is the default. Lenient leaves the failed source out and returns it, so
+// the caller can say so. Collect does the same and is what validation uses, so
+// one run reports every failure. Off loads nothing.
+
+import type { Config } from "../config.ts";
+import { PluginConflictError, PluginLoadError } from "../errors.ts";
+import { BUILTIN_CATEGORIES, type LoadedSource } from "../rules/registry.ts";
+import type { Rule } from "../rules/types.ts";
+import type { Plugin } from "./contract.ts";
+import { discoverSources, LOCAL_RULES, type PluginSource, type SourceKind } from "./discover.ts";
+import { loadLocal, loadPackage, toRule } from "./load.ts";
+
+export type PluginMode = "off" | "strict" | "lenient" | "collect";
+
+export interface PluginFailure {
+  source: string;
+  kind: SourceKind;
+  error: PluginLoadError;
+}
+
+export interface PluginSet {
+  rules: Rule[];
+  categories: Map<string, string>;
+  sources: LoadedSource[];
+  // Specs found but not loaded, because the run asked for built-ins only.
+  skipped: string[];
+  // Sources left out because they failed. Always empty in strict mode, which throws.
+  failures: PluginFailure[];
+}
+
+type Settle = (error: PluginLoadError, kind: SourceKind) => void;
+
+interface LoadedPlugin {
+  plugin: Plugin;
+  kind: SourceKind;
+  spec: string;
+}
+
+// Strict stops at the first failure. The others record it and carry on.
+const settler =
+  (mode: PluginMode, failures: PluginFailure[]): Settle =>
+  (error, kind) => {
+    if (mode === "strict") throw error;
+    if (!failures.some((f) => f.source === error.source)) failures.push({ source: error.source, kind, error });
+  };
+
+// Local files load together as one plugin, then each package loads on its own.
+const importSources = async (found: PluginSource[], settle: Settle): Promise<LoadedPlugin[]> => {
+  const loaded: LoadedPlugin[] = [];
+  const locals = found.filter((s) => s.kind === "local");
+  if (locals.length > 0) {
+    const local = await loadLocal(locals);
+    for (const error of local.failures) settle(error, "local");
+    if (local.plugin) loaded.push({ plugin: local.plugin, kind: "local", spec: LOCAL_RULES });
+  }
+  for (const source of found.filter((s) => s.kind !== "local")) {
+    try {
+      loaded.push({ plugin: await loadPackage(source, new Set(["local"])), kind: source.kind, spec: source.spec });
+    } catch (err) {
+      if (!(err instanceof PluginLoadError)) throw err;
+      settle(err, source.kind);
+    }
+  }
+  return loaded;
+};
+
+interface Claims {
+  namespaces: Map<string, string>;
+  declaredBy: Map<string, string>;
+}
+
+// The earlier claimant and the reason, when a plugin reuses a namespace or a
+// category word another plugin already holds. Null when it claims nothing taken.
+const findClash = (plugin: Plugin, claims: Claims): { other: string; reason: string } | null => {
+  const { namespace } = plugin.meta;
+  const taken = claims.namespaces.get(namespace);
+  if (taken) return { other: taken, reason: `namespace "${namespace}" is already used by ${taken}` };
+  const clash = Object.keys(plugin.meta.categories ?? {}).find((w) => claims.declaredBy.has(w));
+  if (!clash) return null;
+  const other = claims.declaredBy.get(clash) as string;
+  return { other, reason: `category "${clash}" is already declared by ${other}` };
+};
+
+// Namespaces and new categories are global. The first plugin to claim one
+// keeps it, and a later claimant fails, naming both.
+const acceptPlugins = (loaded: LoadedPlugin[], set: PluginSet, settle: Settle): LoadedPlugin[] => {
+  const claims: Claims = { namespaces: new Map(), declaredBy: new Map() };
+  const accepted: LoadedPlugin[] = [];
+  for (const entry of loaded) {
+    const { plugin, spec, kind } = entry;
+    const clash = findClash(plugin, claims);
+    if (clash) {
+      settle(new PluginConflictError(spec, clash.other, clash.reason), kind);
+      continue;
+    }
+    claims.namespaces.set(plugin.meta.namespace, spec);
+    for (const [word, description] of Object.entries(plugin.meta.categories ?? {})) {
+      claims.declaredBy.set(word, spec);
+      set.categories.set(word, description);
+    }
+    accepted.push(entry);
+  }
+  return accepted;
+};
+
+// Each accepted plugin's rules join the set, and the source records which ids it gave.
+const addRules = (set: PluginSet, accepted: LoadedPlugin[]): void => {
+  for (const { plugin, kind, spec } of accepted) {
+    const rules = Object.entries(plugin.rules).map(([key, rule]) => toRule(plugin.meta.namespace, key, rule));
+    set.rules.push(...rules);
+    set.sources.push({ kind, spec, namespace: plugin.meta.namespace, rules: rules.map((r) => r.id) });
+  }
+};
+
+export const loadPlugins = async (root: string, config: Config, mode: PluginMode): Promise<PluginSet> => {
+  const { sources: found, failures: unresolved } = await discoverSources(root, config);
+  const set: PluginSet = {
+    rules: [],
+    categories: new Map(BUILTIN_CATEGORIES),
+    sources: [],
+    skipped: [],
+    failures: [],
+  };
+  if (mode === "off") return { ...set, skipped: [...found.map((s) => s.spec), ...unresolved.map((e) => e.source)] };
+
+  const settle = settler(mode, set.failures);
+  for (const error of unresolved) settle(error, "package");
+  const loaded = await importSources(found, settle);
+  addRules(set, acceptPlugins(loaded, set, settle));
+  return set;
+};

package/src/plugins/load.ts

@@ -0,0 +1,274 @@
+// 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[]"]);
+
+// A rule's category is one word, built in or declared by this plugin, and its
+// key starts with it.
+const checkRuleCategory = (spec: string, key: string, category: unknown, own: ReadonlySet<string>): void => {
+  const where = `rule "${key}"`;
+  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"`);
+  }
+};
+
+// A rule's summary, functions and option types, checked after its category.
+const checkRuleBody = (spec: string, key: string, raw: Record<string, unknown>): void => {
+  const where = `rule "${key}"`;
+  const { summary, options, check, fix } = raw;
+  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) return;
+  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[]`);
+  }
+};
+
+// 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`);
+  }
+  checkRuleCategory(spec, key, raw.category, own);
+  checkRuleBody(spec, key, raw);
+  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[];
+}
+
+interface LocalCategories {
+  // Each word the local files declare, with its description.
+  categories: Record<string, string>;
+  // The file that first declared each word.
+  owner: Record<string, string>;
+}
+
+interface LocalFile {
+  key: string;
+  source: PluginSource;
+  raw: unknown;
+}
+
+// Local files may each declare the same word, but only with the same description.
+const mergeCategories = (source: PluginSource, declared: Record<string, string>, merged: LocalCategories): void => {
+  const { categories, owner } = merged;
+  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;
+  }
+};
+
+// Imports one local file and merges the categories it declares. Its rule is
+// checked later, once every file's categories are known.
+const importLocalFile = async (
+  source: PluginSource,
+  merged: LocalCategories,
+  runtime?: RuntimeInfo,
+): Promise<LocalFile> => {
+  const mod = await importModule(source, runtime);
+  if (mod.default === undefined) {
+    throw new PluginContractError(source.spec, "has no default export; export one rule");
+  }
+  mergeCategories(source, checkCategories(source.spec, mod.categories), merged);
+  return { key: basename(source.path, extname(source.path)), source, raw: mod.default };
+};
+
+// 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 merged: LocalCategories = { categories: {}, owner: {} };
+  const loaded: LocalFile[] = [];
+  for (const source of sources) {
+    try {
+      loaded.push(await importLocalFile(source, merged, runtime));
+    } catch (err) {
+      fail(err);
+    }
+  }
+  const { categories } = merged;
+  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,84 @@
+// 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";
+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 concepts = await loadConcepts(root);
+  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",
+    concepts,
+  });
+  return { registry, skipped: plugins.skipped, failures: plugins.failures };
+};

package/src/rules/index.ts

@@ -2,27 +2,41 @@
 // 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 { 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";
+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,
+  paragraphSentenceBudgetExceeded,
+  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,
+];