@jpeakai/mermaidjs-lint 0.7.0 → 0.7.2

package/dist/types/parse/contrast.d.ts

@@ -60,6 +60,11 @@ export interface SequenceFeatures {
 }
 export declare const sequenceFeatures: (db: SequenceDb) => SequenceFeatures;
 export declare const scoreSequence: (source: string, profile: Profile, canvas?: Canvas) => Promise<ContrastResult>;
-export declare const scoreDiagram: (source: string, directives: StyleDirective[], profile: Profile, keyword: string | null, canvas?: Canvas) => Promise<ContrastResult>;
+export interface ScoredDiagram {
+    source: string;
+    directives: StyleDirective[];
+    keyword: string | null;
+}
+export declare const scoreDiagram: ({ source, directives, keyword }: ScoredDiagram, profile: Profile, canvas?: Canvas) => Promise<ContrastResult>;
 export declare const detectProfile: (filePath: string) => Profile;
 export {};

package/dist/types/parse/graph.d.ts

@@ -0,0 +1,16 @@
+export interface GraphNode {
+    id: string;
+    label: string;
+    parent: string | null;
+}
+export interface GraphEdge {
+    source: string;
+    target: string;
+}
+export interface DiagramGraph {
+    diagram_type: string;
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    subgraphs: GraphNode[];
+}
+export declare const extractGraph: (content: string) => Promise<DiagramGraph>;

package/dist/types/rules/shared.d.ts

@@ -10,7 +10,11 @@ export interface Measured {
     metrics: ComplexityMetrics;
 }
 export declare const measure: (diagram: Diagram, config: ThresholdConfig) => Promise<Measured | null>;
-export declare const finding: (ctx: RuleContext, diagram: Diagram, rule: RuleId, message: string, remediation?: string) => Finding;
+export interface FindingText {
+    message: string;
+    remediation?: string | undefined;
+}
+export declare const finding: (ctx: RuleContext, diagram: Diagram, rule: RuleId, { message, remediation }: FindingText) => Finding;
 export declare const boundaryHint: (boundaries: string[]) => string;
 export declare const splitTarget: (c: ThresholdConfig) => string;
 export declare const profileOf: (ctx: RuleContext) => Profile;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jpeakai/mermaidjs-lint",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "type": "module",
   "description": "Deterministic lint gates and verified fixers for Mermaid diagrams in markdown",
   "license": "MIT",

package/src/check.ts

@@ -84,6 +84,18 @@ const setsAside = (rule: Rule, options: Record<string, unknown>, flags: RunFlags
   canvasOptions(rule).some((name) => options[name] !== undefined) &&
   detectProfile(file) === "mkdocs-material";
 
+// A canvas option with each side the flag gives laid over the configured one.
+const mergeCanvas = (current: unknown, canvas: CanvasSetting): Record<string, string> => {
+  const merged: Record<string, string> = {
+    ...(typeof current === "object" && current !== null ? (current as Record<string, string>) : {}),
+  };
+  for (const side of THEMES) {
+    const value = canvas[side];
+    if (value !== undefined) merged[side] = value;
+  }
+  return merged;
+};
+
 // The options a rule runs with: its configured options, then a flag for any
 // option the rule declares. A preset reaches the rule by its canonical name,
 // so a plugin rule never has to resolve an alias such as `high` or `H`. Given
@@ -105,17 +117,7 @@ export const optionsFor = (
   // canvas type, not only one named canvas.
   const canvas = flags.canvas;
   if (canvas && hasFlagCanvas(flags)) {
-    for (const name of canvasOptions(rule)) {
-      const current = options[name];
-      const merged: Record<string, string> = {
-        ...(typeof current === "object" && current !== null ? (current as Record<string, string>) : {}),
-      };
-      for (const side of THEMES) {
-        const value = canvas[side];
-        if (value !== undefined) merged[side] = value;
-      }
-      options[name] = merged;
-    }
+    for (const name of canvasOptions(rule)) options[name] = mergeCanvas(options[name], canvas);
   }
   if (file !== undefined && setsAside(rule, options, flags, file)) {
     for (const name of canvasOptions(rule)) delete options[name];

package/src/cli.ts

@@ -233,133 +233,154 @@ const refuseOutsideLinks = async (files: string[], root: string, cwd: string): P
   }
 };
 
-const run = async (argv: string[], cwd: string): Promise<number> => {
-  let parsed: Parsed;
+type Values = Parsed["values"];
+
+const parseArgv = (argv: string[]): Parsed => {
   try {
-    parsed = parse(argv);
+    return parse(argv);
   } catch (err) {
     throw new FlagError("argv", err instanceof Error ? err.message : String(err));
   }
-  const { values, positionals } = parsed;
-  if (values.help) {
-    console.log(USAGE);
-    return 0;
-  }
-  if (values.version) {
-    console.log(pkg.version);
-    return 0;
-  }
-  const listing = values["list-rules"];
-  const validating = values["validate-plugins"];
+};
+
+const runFlagsOf = (values: Values): RunFlags => {
   const canvas = {
     ...(values["canvas-light"] !== undefined && { light: values["canvas-light"] }),
     ...(values["canvas-dark"] !== undefined && { dark: values["canvas-dark"] }),
   };
-  const flags: RunFlags = {
+  return {
     preset: values.preset,
     profile: values.profile,
     ...(Object.keys(canvas).length > 0 && { canvas }),
   };
-  checkRunFlags(flags, "--");
+};
+
+const checkPluginFlags = (values: Values): void => {
   if (values["no-plugins"] && values["lenient-plugins"]) {
     throw new FlagError("--lenient-plugins", "--no-plugins and --lenient-plugins contradict each other");
   }
-  if (validating && (values["no-plugins"] || values.fix || listing)) {
+  if (values["validate-plugins"] && (values["no-plugins"] || values.fix || values["list-rules"])) {
     throw new FlagError("--validate-plugins", "--validate-plugins takes no --no-plugins, --fix or --list-rules");
   }
-  const enable = categoryWords("--category", values.category);
-  const disable = categoryWords("--disable-category", values["disable-category"]);
-  // Validation loads every plugin whatever the category flags say, so it
-  // refuses them rather than ignore them.
-  if (validating && enable.length + disable.length > 0) {
-    throw new FlagError("--validate-plugins", "--validate-plugins checks every plugin, so it takes no category flag");
-  }
-  // --list-rules prints the rules the config and the plugin flags leave
-  // active. Any other flag or a path would be silently ignored, so it is refused.
-  if (listing && !validating) {
-    const ignored = [
-      ...(["fix", "json", "preset", "profile", "canvas-light", "canvas-dark"] as const)
-        .filter((name) => values[name] !== undefined && values[name] !== false)
-        .map((name) => `--${name}`),
-      ...(positionals.length > 0 ? ["a path"] : []),
-    ];
-    if (ignored.length > 0) {
-      throw new FlagError(
-        "--list-rules",
-        `--list-rules takes only --config and --no-plugins or --lenient-plugins, not ${ignored.join(", ")}`,
-      );
-    }
+};
+
+// --list-rules prints the rules the config and the plugin flags leave
+// active. Any other flag or a path would be silently ignored, so it is refused.
+const checkListingFlags = (values: Values, positionals: string[]): void => {
+  const ignored = [
+    ...(["fix", "json", "preset", "profile", "canvas-light", "canvas-dark"] as const)
+      .filter((name) => values[name] !== undefined && values[name] !== false)
+      .map((name) => `--${name}`),
+    ...(positionals.length > 0 ? ["a path"] : []),
+  ];
+  if (ignored.length > 0) {
+    throw new FlagError(
+      "--list-rules",
+      `--list-rules takes only --config and --no-plugins or --lenient-plugins, not ${ignored.join(", ")}`,
+    );
   }
+};
+
+// The paths each mode takes: a check needs at least one, validation none.
+const checkPositionals = (values: Values, positionals: string[]): void => {
+  const validating = values["validate-plugins"];
   if (validating && positionals.length > 0) {
     throw new FlagError("files", "--validate-plugins runs no check, so it takes no files");
   }
-  if (positionals.length === 0 && !listing && !validating) throw new FlagError("files", "no files given");
+  if (positionals.length === 0 && !(values["list-rules"] || validating)) {
+    throw new FlagError("files", "no files given");
+  }
+};
 
-  const { root, registry, skipped, failures } = await setUp({
-    cwd,
-    configPath: values.config,
-    noPlugins: values["no-plugins"],
-    lenient: values["lenient-plugins"],
-    collect: validating,
-    selection: { enable, disable, prefix: "--" },
-  });
+interface CategoryWords {
+  enable: string[];
+  disable: string[];
+}
 
-  if (validating) {
-    const result = validate(registry, failures, Boolean(values.json));
-    for (const line of result.stderr) console.error(line);
-    if (result.stdout) console.log(result.stdout);
-    return result.code;
+// The category flags as word lists, after every flag they combine with is checked.
+const checkCombinations = (values: Values, positionals: string[]): CategoryWords => {
+  checkPluginFlags(values);
+  const enable = categoryWords("--category", values.category);
+  const disable = categoryWords("--disable-category", values["disable-category"]);
+  const validating = values["validate-plugins"];
+  // Validation loads every plugin whatever the category flags say, so it
+  // refuses them rather than ignore them.
+  if (validating && enable.length + disable.length > 0) {
+    throw new FlagError("--validate-plugins", "--validate-plugins checks every plugin, so it takes no category flag");
   }
+  if (values["list-rules"] && !validating) checkListingFlags(values, positionals);
+  checkPositionals(values, positionals);
+  return { enable, disable };
+};
 
-  const note = loadedLine(registry.sources, skipped);
-  if (note) console.error(note);
-  for (const line of skippedLines(failures, registry.ignoredSettings)) console.error(line);
-  if (listing) {
-    console.log(listRules(registry));
-    return 0;
-  }
+const printValidation = (registry: Registry, failures: PluginFailure[], json: boolean): number => {
+  const result = validate(registry, failures, json);
+  for (const line of result.stderr) console.error(line);
+  if (result.stdout) console.log(result.stdout);
+  return result.code;
+};
 
+// The files the paths name, refusing an unreadable path or an empty walk, and
+// naming each symbolic link the walk skipped.
+const filesToCheck = (positionals: string[], cwd: string): string[] => {
   const { files, unreadable, symlinks } = collectFiles(positionals.map((p) => resolve(cwd, p)));
   if (unreadable.length > 0) throw new FlagError("files", `cannot read ${unreadable.join(", ")}`);
   for (const link of symlinks) {
     console.error(`mermaidjs-lint: skipped symbolic link ${display(link, cwd)}; name it as a path to check it`);
   }
   if (files.length === 0) throw new FlagError("files", "no matching files");
-  if (values.fix) await refuseOutsideLinks(files, root, cwd);
+  return files;
+};
 
-  // A config canvas is set aside for a file the auto profile reads as
-  // mkdocs-material, and one line names every such file, so the run says what
-  // it scored without the canvas. The --json object carries the same paths, so
-  // a job that reads only stdout still learns the canvas was dropped.
+// A config canvas is set aside for a file the auto profile reads as
+// mkdocs-material, and one line names every such file, so the run says what
+// it scored without the canvas. The --json object carries the same paths, so
+// a job that reads only stdout still learns the canvas was dropped.
+const reportSetAside = (files: string[], flags: RunFlags, registry: Registry, cwd: string): string[] => {
   const setAside = files.filter((file) => canvasSetAside(file, flags, registry)).map((f) => display(f, cwd));
   if (setAside.length > 0) {
     console.error(
       `mermaidjs-lint: config canvas set aside for ${plural(setAside.length, "file")} scored under mkdocs-material: ${setAside.join(", ")}`,
     );
   }
+  return setAside;
+};
 
-  // Every rule, in check and in fix, sees the file as an absolute path, so a
-  // rule that reads the path sees one form, and the auto profile is found
-  // from the file's own folder whatever the process's working directory. The
-  // report shows the path relative to cwd.
-  const perFile = await Promise.all(
-    files.map(async (file) => {
-      let src = await readFile(file, "utf8");
-      if (values.fix) {
-        const fixed = (await fixSourceReport(src, file, flags, registry)).output;
-        if (fixed !== src) {
-          await writeFile(file, fixed);
-          src = fixed;
-        }
-      }
-      const shown = display(file, cwd);
-      const found = await checkModel(buildDocModel(src, documentKind(file)), file, flags, registry);
-      return found.map((f) => ({ ...f, file: shown }));
-    }),
-  );
-  const all = perFile.flat();
+interface FileRun {
+  flags: RunFlags;
+  registry: Registry;
+  fix: boolean;
+  cwd: string;
+}
 
-  if (values.json) {
+// Every rule, in check and in fix, sees the file as an absolute path, so a
+// rule that reads the path sees one form, and the auto profile is found
+// from the file's own folder whatever the process's working directory. The
+// report shows the path relative to cwd.
+const checkFile = async (file: string, { flags, registry, fix, cwd }: FileRun): Promise<Finding[]> => {
+  let src = await readFile(file, "utf8");
+  if (fix) {
+    const fixed = (await fixSourceReport(src, file, flags, registry)).output;
+    if (fixed !== src) {
+      await writeFile(file, fixed);
+      src = fixed;
+    }
+  }
+  const shown = display(file, cwd);
+  const found = await checkModel(buildDocModel(src, documentKind(file)), file, flags, registry);
+  return found.map((f) => ({ ...f, file: shown }));
+};
+
+interface Report {
+  all: Finding[];
+  files: number;
+  registry: Registry;
+  failures: PluginFailure[];
+  setAside: string[];
+}
+
+const printReport = (json: boolean, { all, files, registry, failures, setAside }: Report): void => {
+  if (json) {
     const skippedPlugins = failures.map((f) => ({
       source: f.source,
       kind: f.kind,
@@ -368,15 +389,57 @@ const run = async (argv: string[], cwd: string): Promise<number> => {
     }));
     console.log(
       JSON.stringify(
-        { findings: all, files: files.length, plugins: registry.sources, skippedPlugins, canvasSetAside: setAside },
+        { findings: all, files, plugins: registry.sources, skippedPlugins, canvasSetAside: setAside },
         null,
         2,
       ),
     );
-  } else {
-    for (const f of all) console.log(reportLine(f, f.file));
-    console.log(`${all.length} finding(s) in ${files.length} file(s)`);
+    return;
   }
+  for (const f of all) console.log(reportLine(f, f.file));
+  console.log(`${all.length} finding(s) in ${files} file(s)`);
+};
+
+const run = async (argv: string[], cwd: string): Promise<number> => {
+  const { values, positionals } = parseArgv(argv);
+  if (values.help) {
+    console.log(USAGE);
+    return 0;
+  }
+  if (values.version) {
+    console.log(pkg.version);
+    return 0;
+  }
+  const flags = runFlagsOf(values);
+  checkRunFlags(flags, "--");
+  const { enable, disable } = checkCombinations(values, positionals);
+
+  const { root, registry, skipped, failures } = await setUp({
+    cwd,
+    configPath: values.config,
+    noPlugins: values["no-plugins"],
+    lenient: values["lenient-plugins"],
+    collect: values["validate-plugins"],
+    selection: { enable, disable, prefix: "--" },
+  });
+
+  if (values["validate-plugins"]) return printValidation(registry, failures, Boolean(values.json));
+
+  const note = loadedLine(registry.sources, skipped);
+  if (note) console.error(note);
+  for (const line of skippedLines(failures, registry.ignoredSettings)) console.error(line);
+  if (values["list-rules"]) {
+    console.log(listRules(registry));
+    return 0;
+  }
+
+  const files = filesToCheck(positionals, cwd);
+  const fix = Boolean(values.fix);
+  if (fix) await refuseOutsideLinks(files, root, cwd);
+  const setAside = reportSetAside(files, flags, registry, cwd);
+  const perFile = await Promise.all(files.map((file) => checkFile(file, { flags, registry, fix, cwd })));
+  const all = perFile.flat();
+  printReport(Boolean(values.json), { all, files: files.length, registry, failures, setAside });
   return all.length > 0 ? 1 : 0;
 };
 

package/src/files.ts

@@ -17,6 +17,8 @@ export const SKIP_DIRS = new Set(["node_modules", "vendor", "dist", "build", "tm
 
 const skipDir = (name: string): boolean => name.startsWith(".") || SKIP_DIRS.has(name);
 
+const isDiagramFile = (name: string): boolean => DIAGRAM_FILE_EXTS.has(extname(name).toLowerCase());
+
 // Whether a link resolves to a directory. A dangling link resolves to nothing.
 const linksToDir = (path: string): boolean => {
   try {
@@ -43,6 +45,24 @@ export const collectFiles = (paths: string[]): Collected => {
   const symlinks: string[] = [];
   const seen = new Set<string>();
 
+  // A file reached by more than one path is listed once.
+  const add = (abs: string): void => {
+    if (seen.has(abs)) return;
+    seen.add(abs);
+    files.push(abs);
+  };
+
+  const visit = (dir: string, entry: Dirent): void => {
+    const abs = join(dir, entry.name);
+    if (entry.isSymbolicLink()) {
+      if (!skipDir(entry.name) && (isDiagramFile(entry.name) || linksToDir(abs))) symlinks.push(abs);
+    } else if (entry.isDirectory()) {
+      if (!skipDir(entry.name)) walk(abs);
+    } else if (entry.isFile() && isDiagramFile(entry.name)) {
+      add(abs);
+    }
+  };
+
   const walk = (dir: string): void => {
     let entries: Dirent[];
     try {
@@ -51,21 +71,7 @@ export const collectFiles = (paths: string[]): Collected => {
       unreadable.push(dir);
       return;
     }
-    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      const abs = join(dir, entry.name);
-      if (entry.isSymbolicLink()) {
-        if (!skipDir(entry.name) && (DIAGRAM_FILE_EXTS.has(extname(entry.name).toLowerCase()) || linksToDir(abs))) {
-          symlinks.push(abs);
-        }
-      } else if (entry.isDirectory()) {
-        if (!skipDir(entry.name)) walk(abs);
-      } else if (entry.isFile() && DIAGRAM_FILE_EXTS.has(extname(entry.name).toLowerCase())) {
-        if (!seen.has(abs)) {
-          seen.add(abs);
-          files.push(abs);
-        }
-      }
-    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) visit(dir, entry);
   };
 
   for (const p of paths) {
@@ -74,10 +80,9 @@ export const collectFiles = (paths: string[]): Collected => {
       const st = statSync(abs);
       if (st.isDirectory()) {
         walk(abs);
-      } else if (st.isFile() && !seen.has(abs)) {
+      } else if (st.isFile()) {
         // An explicitly named file is honoured whatever its extension.
-        seen.add(abs);
-        files.push(abs);
+        add(abs);
       }
     } catch {
       unreadable.push(p);

package/src/fix/engine.ts

@@ -5,9 +5,9 @@
 
 import { checkRunFlags, optionsFor, type RunFlags } from "../check.ts";
 import { FixNotConvergingError } from "../errors.ts";
-import { buildDocModel, documentKind } from "../model.ts";
+import { buildDocModel, type DocModel, documentKind } from "../model.ts";
 import { BUILTIN, HELPERS, type Registry } from "../rules/registry.ts";
-import type { Edit } from "../rules/types.ts";
+import type { Edit, Rule } from "../rules/types.ts";
 import { verify } from "./verify.ts";
 
 const MAX_PASSES = 1_000;
@@ -40,6 +40,73 @@ const wellFormed = (e: Edit, length: number): boolean =>
   e.end <= length &&
   typeof e.text === "string";
 
+// The state one fix run carries from pass to pass.
+interface FixRun {
+  file: string;
+  flags: RunFlags;
+  registry: Registry;
+  kind: "markdown" | "diagram";
+  current: string;
+  applied: Edit[];
+  refused: Edit[];
+  // An edit refused once stays refused while its source slice is unchanged.
+  refusedKeys: Set<string>;
+}
+
+const keyOf = (run: FixRun, e: Edit): string => `${e.rule}\u0000${run.current.slice(e.start, e.end)}\u0000${e.text}`;
+
+// Splice the edits, re-parse, and keep the result only when every edit
+// survives verification against the pass's model.
+const attempt = async (run: FixRun, doc: DocModel, edits: Edit[]): Promise<boolean> => {
+  const next = splice(run.current, edits);
+  const after = buildDocModel(next, run.kind);
+  for (const e of edits) if ((await verify(e, doc, after)) !== "accept") return false;
+  run.current = next;
+  run.applied.push(...edits);
+  return true;
+};
+
+// The well-formed edits. A malformed one is refused, once per rule and span.
+const soundEdits = (run: FixRun, proposed: Edit[]): Edit[] =>
+  proposed.filter((e) => {
+    if (wellFormed(e, run.current.length)) return true;
+    const key = `${e.rule}\u0000malformed\u0000${e.start}:${e.end}`;
+    if (!run.refusedKeys.has(key)) {
+      run.refusedKeys.add(key);
+      run.refused.push(e);
+    }
+    return false;
+  });
+
+// Whether one rule's edits change the source, trying its batch first.
+const applyRule = async (run: FixRun, doc: DocModel, rule: Rule): Promise<boolean> => {
+  const options = optionsFor(rule, run.registry.options.get(rule.id), run.flags, run.file);
+  const proposed = (await rule.fix?.({ doc, file: run.file, options, helpers: HELPERS })) ?? [];
+  const edits = soundEdits(run, proposed).filter(
+    (e) => run.current.slice(e.start, e.end) !== e.text && !run.refusedKeys.has(keyOf(run, e)),
+  );
+  if (edits.length === 0) return false;
+
+  // A rule's whole batch is proven with one re-parse, and a batch that
+  // fails falls back to one edit at a time, so one bad edit never blocks
+  // the rest.
+  if (edits.length > 1 && !overlaps(edits) && (await attempt(run, doc, edits))) return true;
+  for (const edit of edits) {
+    if (await attempt(run, doc, [edit])) return true;
+    run.refusedKeys.add(keyOf(run, edit));
+    run.refused.push(edit);
+  }
+  return false;
+};
+
+// One pass over the fixers in priority order. It returns the rule whose edit
+// it kept, or undefined when no rule changed the source.
+const runPass = async (run: FixRun): Promise<string | undefined> => {
+  const doc = buildDocModel(run.current, run.kind);
+  for (const rule of run.registry.fixOrder) if (await applyRule(run, doc, rule)) return rule.id;
+  return undefined;
+};
+
 export const fixSourceReport = async (
   src: string,
   file: string,
@@ -47,67 +114,25 @@ export const fixSourceReport = async (
   registry: Registry = BUILTIN,
 ): Promise<FixReport> => {
   checkRunFlags(flags);
-  const kind = documentKind(file);
-  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;
+  const run: FixRun = {
+    file,
+    flags,
+    registry,
+    kind: documentKind(file),
+    current: src,
+    applied: [],
+    refused: [],
+    refusedKeys: new Set<string>(),
+  };
 
   // The rule whose edit each pass kept, so a run that never converges can name
   // the rules still proposing edits at the end.
   const keptBy: string[] = [];
 
   for (let pass = 0; pass < MAX_PASSES; pass++) {
-    const doc = buildDocModel(current, kind);
-    const keyOf = (e: Edit): string => `${e.rule}\u0000${current.slice(e.start, e.end)}\u0000${e.text}`;
-
-    const attempt = async (edits: Edit[]): Promise<boolean> => {
-      const next = splice(current, edits);
-      const after = buildDocModel(next, kind);
-      for (const e of edits) if ((await verify(e, doc, after)) !== "accept") return false;
-      current = next;
-      applied.push(...edits);
-      return true;
-    };
-
-    let progressed = false;
-    for (const rule of registry.fixOrder) {
-      const options = optionsFor(rule, registry.options.get(rule.id), flags, file);
-      const proposed = (await rule.fix?.({ doc, file, options, helpers: HELPERS })) ?? [];
-      const sound = proposed.filter((e) => {
-        if (wellFormed(e, current.length)) return true;
-        const key = `${e.rule}\u0000malformed\u0000${e.start}:${e.end}`;
-        if (!refusedKeys.has(key)) {
-          refusedKeys.add(key);
-          refused.push(e);
-        }
-        return false;
-      });
-      const edits = sound.filter((e) => current.slice(e.start, e.end) !== e.text && !refusedKeys.has(keyOf(e)));
-      if (edits.length === 0) continue;
-
-      // A rule's whole batch is proven with one re-parse, and a batch that
-      // fails falls back to one edit at a time, so one bad edit never blocks
-      // the rest.
-      if (edits.length > 1 && !overlaps(edits) && (await attempt(edits))) {
-        progressed = true;
-      } else {
-        for (const edit of edits) {
-          if (await attempt([edit])) {
-            progressed = true;
-            break;
-          }
-          refusedKeys.add(keyOf(edit));
-          refused.push(edit);
-        }
-      }
-      if (progressed) {
-        keptBy.push(rule.id);
-        break;
-      }
-    }
-    if (!progressed) return { output: current, applied, refused };
+    const kept = await runPass(run);
+    if (kept === undefined) return { output: run.current, applied: run.applied, refused: run.refused };
+    keptBy.push(kept);
   }
   // The last passes show who was still editing: a fixer that never converges
   // keeps one in every pass.

package/src/fix/verify.ts

@@ -16,20 +16,25 @@ const OMIT = new Set(["position", "data"]);
 export const normalise = (node: Node, opts: { blankDiagrams?: boolean } = {}): Plain => {
   const out: Plain = {};
   const isDiagram = node.type === "code" && (node as { lang?: string }).lang === "mermaid";
+  const blank = isDiagram && Boolean(opts.blankDiagrams);
   for (const [key, value] of Object.entries(node)) {
     if (OMIT.has(key)) continue;
-    if (key === "children" && Array.isArray(value)) {
-      out.children = (value as Node[]).map((child) => normalise(child, opts));
-    } else if (key === "value" && typeof value === "string") {
-      if (isDiagram && opts.blankDiagrams) continue;
-      out.value = node.type === "text" ? value.replace(/\s+/g, " ").trim() : value;
-    } else {
-      out[key] = value;
-    }
+    if (blank && isStringValue(key, value)) continue;
+    out[key] = normaliseField(node, key, value, opts);
   }
   return out;
 };
 
+const isStringValue = (key: string, value: unknown): value is string => key === "value" && typeof value === "string";
+
+// One field of the copy: children normalised in turn, and a text node's value
+// with its whitespace collapsed. Every other field is kept as it is.
+const normaliseField = (node: Node, key: string, value: unknown, opts: { blankDiagrams?: boolean }): unknown => {
+  if (key === "children" && Array.isArray(value)) return (value as Node[]).map((child) => normalise(child, opts));
+  if (isStringValue(key, value)) return node.type === "text" ? value.replace(/\s+/g, " ").trim() : value;
+  return value;
+};
+
 const sameJson = (a: unknown, b: unknown): boolean => JSON.stringify(a) === JSON.stringify(b);
 
 const sameTree = (a: Root, b: Root, opts: { blankDiagrams?: boolean }): boolean =>