@jpeakai/mermaidjs-lint 0.3.0 → 0.4.1

package/dist/testing.js

@@ -1,6 +1,82 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/errors.ts
+class MermaidLintError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = new.target.name;
+  }
+}
+
+class UsageError extends MermaidLintError {
+  constructor(message, code = "usage") {
+    super(code, message);
+  }
+}
+
+class FlagError extends UsageError {
+  flag;
+  constructor(flag, message) {
+    super(message, "flag");
+    this.flag = flag;
+  }
+}
+class UnknownRuleError extends UsageError {
+  file;
+  rule;
+  known;
+  constructor(file, rule, known) {
+    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;
+  }
+}
+
+class RuleOptionError extends UsageError {
+  file;
+  rule;
+  option;
+  constructor(file, rule, option, message) {
+    super(`${file}: ${message}`, "rule-option");
+    this.file = file;
+    this.rule = rule;
+    this.option = option;
+  }
+}
+class FixNotConvergingError extends MermaidLintError {
+  file;
+  rules;
+  constructor(file, passes, rules) {
+    super("fix-not-converging", `${file}: --fix did not converge after ${passes} passes; ${rules.join(", ")} kept proposing edits. A fixer must propose nothing once its edit is applied`);
+    this.file = file;
+    this.rules = rules;
+  }
+}
+
+class PluginLoadError extends MermaidLintError {
+  source;
+  constructor(source, reason, code = "plugin") {
+    super(code, `plugin ${source}: ${reason}`);
+    this.source = source;
+  }
+}
+class PluginContractError extends PluginLoadError {
+  constructor(source, reason) {
+    super(source, reason, "plugin-contract");
+  }
+}
+class PluginFixerError extends MermaidLintError {
+  rule;
+  constructor(rule, reason) {
+    super("plugin-fixer", `plugin rule ${rule} ${reason}`);
+    this.rule = rule;
+  }
+}
+
 // src/model.ts
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
@@ -203,6 +279,7 @@ async function extractStats(content) {
     edges: 0,
     subgraphs: 0,
     max_subgraph_depth: 0,
+    max_tree_depth: 0,
     node_ids: [],
     subgraph_names: [],
     parser_used: langium ? "langium" : "mermaid-core",
@@ -252,6 +329,7 @@ async function extractLangiumStats(content, keyword) {
   const subgraphNames = [];
   let edges = 0;
   let maxDepth = 0;
+  let treeDepth = 0;
   switch (mapped) {
     case "architecture": {
       const services = ast.services ?? [];
@@ -298,7 +376,7 @@ async function extractLangiumStats(content, keyword) {
       const stats = indentTreeStats(nodes.map((n, i) => ({ label: n.name ?? `node_${i}`, indent: n.indent ?? 0 })));
       nodeIds.push(...stats.labels);
       edges = stats.edges;
-      maxDepth = stats.depth;
+      treeDepth = stats.depth;
       break;
     }
     case "treemap": {
@@ -306,7 +384,7 @@ async function extractLangiumStats(content, keyword) {
       const stats = indentTreeStats(rows.map((r, i) => ({ label: r.item?.name ?? `row_${i}`, indent: r.indent ?? 0 })));
       nodeIds.push(...stats.labels);
       edges = stats.edges;
-      maxDepth = stats.depth;
+      treeDepth = stats.depth;
       break;
     }
     case "wardley": {
@@ -326,6 +404,7 @@ async function extractLangiumStats(content, keyword) {
     edges,
     subgraphs: subgraphNames.length,
     max_subgraph_depth: maxDepth,
+    max_tree_depth: treeDepth,
     node_ids: [...new Set(nodeIds.filter(Boolean))].sort(),
     subgraph_names: subgraphNames,
     parser_used: "langium",
@@ -376,12 +455,13 @@ async function extractCoreStats(content, keyword) {
   if (!adapter) {
     throw new Error(`no core adapter for diagram.type="${diagramType}" (keyword="${keyword}")`);
   }
-  const { nodeIds, edges, subgraphNames, maxDepth } = adapter(diagram.db);
+  const { nodeIds, edges, subgraphNames, maxDepth, treeDepth = 0 } = adapter(diagram.db);
   return {
     nodes: nodeIds.length,
     edges,
     subgraphs: subgraphNames.length,
     max_subgraph_depth: maxDepth,
+    max_tree_depth: treeDepth,
     node_ids: [...nodeIds].sort(),
     subgraph_names: subgraphNames,
     parser_used: "mermaid-core",
@@ -392,6 +472,7 @@ async function extractCoreStats(content, keyword) {
 var CORE_ADAPTERS = {
   "flowchart-v2": adaptFlowchart,
   flowchart: adaptFlowchart,
+  "flowchart-elk": adaptFlowchart,
   graph: adaptFlowchart,
   classDiagram: adaptClass,
   "classDiagram-v2": adaptClass,
@@ -515,7 +596,13 @@ function adaptIshikawa(db) {
       walk(c, depth + 1);
   };
   walk(root, 0);
-  return { nodeIds: labels, edges: Math.max(0, labels.length - 1), subgraphNames: [], maxDepth };
+  return {
+    nodeIds: labels,
+    edges: Math.max(0, labels.length - 1),
+    subgraphNames: [],
+    maxDepth: 0,
+    treeDepth: maxDepth
+  };
 }
 function adaptKanban(db) {
   const data = callGetter(db, "getData");
@@ -543,7 +630,13 @@ function adaptMindmap(db) {
       walk(c, depth + 1);
   };
   walk(root, 0);
-  return { nodeIds: labels, edges: Math.max(0, labels.length - 1), subgraphNames: [], maxDepth };
+  return {
+    nodeIds: labels,
+    edges: Math.max(0, labels.length - 1),
+    subgraphNames: [],
+    maxDepth: 0,
+    treeDepth: maxDepth
+  };
 }
 function adaptQuadrantChart(db) {
   const data = callGetter(db, "getQuadrantData");
@@ -759,74 +852,6 @@ var buildDocModel = (src, kind = "markdown") => {
   return { src, kind, tree, diagrams };
 };
 
-// src/errors.ts
-class MermaidLintError extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = new.target.name;
-  }
-}
-
-class UsageError extends MermaidLintError {
-  constructor(message, code = "usage") {
-    super(code, message);
-  }
-}
-class UnknownRuleError extends UsageError {
-  file;
-  rule;
-  known;
-  constructor(file, rule, known) {
-    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;
-  }
-}
-
-class RuleOptionError extends UsageError {
-  file;
-  rule;
-  option;
-  constructor(file, rule, option, message) {
-    super(`${file}: ${message}`, "rule-option");
-    this.file = file;
-    this.rule = rule;
-    this.option = option;
-  }
-}
-class FixNotConvergingError extends MermaidLintError {
-  file;
-  rules;
-  constructor(file, passes, rules) {
-    super("fix-not-converging", `${file}: --fix did not converge after ${passes} passes; ${rules.join(", ")} kept proposing edits. A fixer must propose nothing once its edit is applied`);
-    this.file = file;
-    this.rules = rules;
-  }
-}
-
-class PluginLoadError extends MermaidLintError {
-  source;
-  constructor(source, reason, code = "plugin") {
-    super(code, `plugin ${source}: ${reason}`);
-    this.source = source;
-  }
-}
-class PluginContractError extends PluginLoadError {
-  constructor(source, reason) {
-    super(source, reason, "plugin-contract");
-  }
-}
-class PluginFixerError extends MermaidLintError {
-  rule;
-  constructor(rule, reason) {
-    super("plugin-fixer", `plugin rule ${rule} ${reason}`);
-    this.rule = rule;
-  }
-}
-
 // src/parse/contrast.ts
 import { existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
@@ -1168,7 +1193,7 @@ var calculateComplexity = (stats, config) => {
   const n = stats.nodes;
   const e = stats.edges;
   const s = stats.subgraphs;
-  const d = stats.max_subgraph_depth;
+  const d = Math.max(stats.max_subgraph_depth, stats.max_tree_depth);
   const base = n + e * config.edge_weight + s * config.subgraph_weight;
   const vcs = base * (1 + d * config.depth_weight);
   const maxEdges = n > 1 ? n * (n - 1) : 0;
@@ -1505,7 +1530,7 @@ var parseFenceUnterminated = {
   id: RULE.FENCE_UNTERMINATED,
   category: "parse",
   summary: "a mermaid fence that is never closed",
-  check: (ctx) => ctx.doc.diagrams.filter((d) => !d.terminated).map((d) => finding(ctx, d, RULE.FENCE_UNTERMINATED, `mermaid fence opened at line ${d.startLine} is never closed`, "Add a closing fence after the last line of the diagram.")),
+  check: (ctx) => ctx.doc.diagrams.filter((d) => !d.terminated).map((d) => finding(ctx, d, RULE.FENCE_UNTERMINATED, `mermaid fence opened at line ${d.startLine} is never closed`, "Add a closing fence directly after the last line of the diagram, with the opening line's prefix: `> ` in a quote, the item's indent in a list.")),
   fix: (ctx) => {
     const edits = [];
     const { src } = ctx.doc;
@@ -1621,6 +1646,15 @@ var buildRegistry = (input) => {
 var BUILTIN = buildRegistry({ rules: RULES, fixOrder: FIX_ORDER, categories: BUILTIN_CATEGORIES });
 
 // src/check.ts
+var checkRunFlags = (flags, prefix = "") => {
+  const { preset, profile } = flags;
+  if (preset !== undefined && canonicalPreset(preset) === null) {
+    throw new FlagError(`${prefix}preset`, `${prefix}preset must be one of ${PRESET_NAMES.join(", ")}, not "${preset}"`);
+  }
+  if (profile !== undefined && !PROFILES.includes(profile)) {
+    throw new FlagError(`${prefix}profile`, `${prefix}profile must be one of ${PROFILES.join(", ")}, not "${profile}"`);
+  }
+};
 var optionsFor = (rule, configured, flags) => {
   const options = { ...configured };
   for (const name of ["preset", "profile"]) {
@@ -1631,6 +1665,7 @@ var optionsFor = (rule, configured, flags) => {
   return options;
 };
 var checkModel = async (doc, file, flags = {}, registry = BUILTIN) => {
+  checkRunFlags(flags);
   const perRule = registry.rules.map((rule) => rule.check({ doc, file, options: optionsFor(rule, registry.options.get(rule.id), flags), helpers: HELPERS }));
   const findings = (await Promise.all(perRule)).flat();
   return findings.sort((a, b) => a.line - b.line || a.rule.localeCompare(b.rule));
@@ -1669,26 +1704,40 @@ var sameDiagrams = async (before, after) => {
     if (!now || was.keyword !== now.keyword)
       return false;
     const [a, b] = await Promise.all([was.stats(), now.stats()]);
-    const shape = (s) => [
+    const shape = (s, source) => [
+      parseFailed(source, s),
       s.diagram_type,
       s.nodes,
       s.edges,
       s.subgraphs,
       s.max_subgraph_depth,
+      s.max_tree_depth,
       s.node_ids,
       s.subgraph_names
     ];
-    if (!sameJson(shape(a), shape(b)))
+    if (!sameJson(shape(a, was.source), shape(b, now.source)))
       return false;
   }
   return true;
 };
+var breaksAParse = async (before, after) => {
+  for (const [i, was] of before.diagrams.entries()) {
+    const now = after.diagrams[i];
+    if (!now)
+      continue;
+    const [a, b] = await Promise.all([was.stats(), now.stats()]);
+    if (!parseFailed(was.source, a) && parseFailed(now.source, b))
+      return true;
+  }
+  return false;
+};
 var verify = async (edit, before, after) => {
   if (edit.expect.kind === "same-tree") {
     if (!sameTree(before.tree, after.tree, {}))
       return "refuse";
-    if (before.kind === "markdown" && after.kind === "markdown")
-      return "accept";
+    if (before.kind === "markdown" && after.kind === "markdown") {
+      return await breaksAParse(before, after) ? "refuse" : "accept";
+    }
   }
   return await sameDiagrams(before, after) ? "accept" : "refuse";
 };
@@ -1708,6 +1757,7 @@ var overlaps = (edits) => {
 };
 var wellFormed = (e, length) => Number.isInteger(e.start) && Number.isInteger(e.end) && e.start >= 0 && e.start <= e.end && e.end <= length && typeof e.text === "string";
 var fixSourceReport = async (src, file, flags = {}, registry = BUILTIN) => {
+  checkRunFlags(flags);
   const kind = documentKind(file);
   const applied = [];
   const refused = [];

package/dist/types/check.d.ts

@@ -5,6 +5,7 @@ export interface RunFlags {
     preset?: string;
     profile?: string;
 }
+export declare const checkRunFlags: (flags: RunFlags, prefix?: string) => void;
 export declare const optionsFor: (rule: Rule, configured: RuleOptions | undefined, flags: RunFlags) => RuleOptions;
 export declare const checkModel: (doc: DocModel, file: string, flags?: RunFlags, registry?: Registry) => Promise<Finding[]>;
 export declare const checkMarkdown: (src: string, file: string, flags?: RunFlags, registry?: Registry) => Promise<Finding[]>;

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

@@ -3,6 +3,7 @@ export interface DiagramStats {
     edges: number;
     subgraphs: number;
     max_subgraph_depth: number;
+    max_tree_depth: number;
     node_ids: string[];
     subgraph_names: string[];
     parser_used: "langium" | "mermaid-core";

package/package.json

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

package/src/check.ts

@@ -4,7 +4,10 @@
 // them. A rule may be synchronous or return a promise, so a rule that waits on
 // a tool or a service overlaps with the others.
 
+import { FlagError } from "./errors.ts";
 import { buildDocModel, type DocModel, documentKind } from "./model.ts";
+import { PROFILES } from "./parse/contrast.ts";
+import { canonicalPreset, PRESET_NAMES } from "./parse/metrics.ts";
 import { BUILTIN, HELPERS, type Registry } from "./rules/registry.ts";
 import type { Finding, Rule, RuleOptions } from "./rules/types.ts";
 
@@ -15,6 +18,22 @@ export interface RunFlags {
   profile?: string;
 }
 
+// A preset or profile that no rule can take fails as a usage error, with the
+// code the command gives a bad flag, so a library caller can branch on it. The
+// command passes "--" as the prefix, so the message names its own flag.
+export const checkRunFlags = (flags: RunFlags, prefix = ""): void => {
+  const { preset, profile } = flags;
+  if (preset !== undefined && canonicalPreset(preset) === null) {
+    throw new FlagError(
+      `${prefix}preset`,
+      `${prefix}preset must be one of ${PRESET_NAMES.join(", ")}, not "${preset}"`,
+    );
+  }
+  if (profile !== undefined && !PROFILES.includes(profile as (typeof PROFILES)[number])) {
+    throw new FlagError(`${prefix}profile`, `${prefix}profile must be one of ${PROFILES.join(", ")}, not "${profile}"`);
+  }
+};
+
 // The options a rule runs with: its configured options, then a flag for any
 // option the rule declares.
 export const optionsFor = (rule: Rule, configured: RuleOptions | undefined, flags: RunFlags): RuleOptions => {
@@ -32,6 +51,7 @@ export const checkModel = async (
   flags: RunFlags = {},
   registry: Registry = BUILTIN,
 ): Promise<Finding[]> => {
+  checkRunFlags(flags);
   const perRule = registry.rules.map((rule) =>
     rule.check({ doc, file, options: optionsFor(rule, registry.options.get(rule.id), flags), helpers: HELPERS }),
   );

package/src/cli.ts

@@ -5,13 +5,13 @@ import { lstat, readFile, realpath, writeFile } from "node:fs/promises";
 import { isAbsolute, relative, resolve } from "node:path";
 import { parseArgs } from "node:util";
 import pkg from "../package.json" with { type: "json" };
-import { checkModel, type RunFlags } from "./check.ts";
+import { checkModel, checkRunFlags, type RunFlags } from "./check.ts";
 import { FixOutsideRootError, FlagError, MermaidLintError, UsageError } from "./errors.ts";
 import { collectFiles, DIAGRAM_FILE_EXTS, SKIP_DIRS } from "./files.ts";
 import { fixSourceReport } from "./fix/engine.ts";
 import { buildDocModel, DIAGRAM_EXTS, documentKind } from "./model.ts";
 import { PROFILES } from "./parse/contrast.ts";
-import { canonicalPreset, PRESET_NAMES } from "./parse/metrics.ts";
+import { PRESET_NAMES } from "./parse/metrics.ts";
 import type { PluginFailure } from "./plugins/index.ts";
 import { setUp } from "./project.ts";
 import { RULES } from "./rules/index.ts";
@@ -52,6 +52,7 @@ Examples of every rule, with fixes: https://jpeakai.github.io/jpai-mermaidjs-lin
   numeric threshold set in the config overrides both.
 --profile NAME sets how contrast is read: ${PROFILES.join(", ")}. It overrides a profile set in the config.
   auto reads mkdocs-material when any parent folder holds mkdocs.yml or mkdocs.yaml, else github.
+--json prints one JSON object instead of text lines.
 --fix applies every fix it can prove safe, then reports what remains.
 A fixer that is unsure leaves the text alone and the finding stays.
 --config FILE reads that config instead of mermaidjs-lint.config.json or .mjs at the project root.
@@ -220,12 +221,7 @@ const run = async (argv: string[], cwd: string): Promise<number> => {
   }
   const listing = values["list-rules"];
   const validating = values["validate-plugins"];
-  if (values.preset !== undefined && canonicalPreset(values.preset) === null) {
-    throw new FlagError("--preset", `--preset must be one of ${PRESET_NAMES.join(", ")}, not "${values.preset}"`);
-  }
-  if (values.profile !== undefined && !PROFILES.includes(values.profile as (typeof PROFILES)[number])) {
-    throw new FlagError("--profile", `--profile must be one of ${PROFILES.join(", ")}, not "${values.profile}"`);
-  }
+  checkRunFlags({ preset: values.preset, profile: values.profile }, "--");
   if (values["no-plugins"] && values["lenient-plugins"]) {
     throw new FlagError("--lenient-plugins", "--no-plugins and --lenient-plugins contradict each other");
   }

package/src/errors.ts

@@ -138,7 +138,7 @@ export class FixOutsideRootError extends UsageError {
 
   constructor(file: string, target: string, root: string) {
     super(
-      `${file} is a symbolic link to ${target}, outside the project root ${root}; --fix does not write through it. Fix the target in its own project, or name it directly`,
+      `${file} is a symbolic link to ${target}, outside the project root ${root}; --fix does not write through it. Fix the target in its own project, or run on the target path itself`,
       "fix-outside-root",
     );
     this.file = file;

package/src/fix/engine.ts

@@ -3,7 +3,7 @@
 // or single edit that survives verification. Offsets are only valid for the source they were
 // computed from, so every accepted edit restarts the pass.
 
-import { optionsFor, type RunFlags } from "../check.ts";
+import { checkRunFlags, optionsFor, type RunFlags } from "../check.ts";
 import { FixNotConvergingError } from "../errors.ts";
 import { buildDocModel, documentKind } from "../model.ts";
 import { BUILTIN, HELPERS, type Registry } from "../rules/registry.ts";
@@ -46,6 +46,7 @@ export const fixSourceReport = async (
   flags: RunFlags = {},
   registry: Registry = BUILTIN,
 ): Promise<FixReport> => {
+  checkRunFlags(flags);
   const kind = documentKind(file);
   const applied: Edit[] = [];
   const refused: Edit[] = [];

package/src/fix/verify.ts

@@ -4,6 +4,7 @@
 
 import type { Node, Root } from "mdast";
 import type { DocModel } from "../model.ts";
+import { parseFailed } from "../parse/metrics.ts";
 import type { Edit } from "../rules/types.ts";
 
 type Plain = { [k: string]: unknown };
@@ -43,28 +44,50 @@ const sameDiagrams = async (before: DocModel, after: DocModel): Promise<boolean>
     const now = after.diagrams[i];
     if (!now || was.keyword !== now.keyword) return false;
     const [a, b] = await Promise.all([was.stats(), now.stats()]);
-    const shape = (s: typeof a): unknown => [
+    const shape = (s: typeof a, source: string): unknown => [
+      parseFailed(source, s),
       s.diagram_type,
       s.nodes,
       s.edges,
       s.subgraphs,
       s.max_subgraph_depth,
+      s.max_tree_depth,
       s.node_ids,
       s.subgraph_names,
     ];
-    if (!sameJson(shape(a), shape(b))) return false;
+    if (!sameJson(shape(a, was.source), shape(b, now.source))) return false;
   }
   return true;
 };
 
+// Whether a diagram that parsed before the edit fails to parse after it. The
+// diagrams are matched by position, which same-tree's identical tree already
+// pins. Asked of same-tree edits as a belt to the tree comparison's braces: a
+// diagram's text sits in the tree, so an unchanged tree cannot break it today,
+// but no edit may ever trade a parseable diagram for an unparseable one.
+const breaksAParse = async (before: DocModel, after: DocModel): Promise<boolean> => {
+  for (const [i, was] of before.diagrams.entries()) {
+    const now = after.diagrams[i];
+    if (!now) continue;
+    const [a, b] = await Promise.all([was.stats(), now.stats()]);
+    if (!parseFailed(was.source, a) && parseFailed(now.source, b)) return true;
+  }
+  return false;
+};
+
 // A raw diagram file (.mmd, .mermaid) has no markdown around its diagram, so
 // its tree is an empty root and comparing trees would prove nothing. There,
 // same-tree also demands what same-diagrams does: the diagram is still there
-// and parses to the same structure.
+// and parses to the same structure. same-diagrams compares parse success too
+// (parseFailed, the test parse-diagram-unparseable applies), so an edit can
+// neither break a diagram that parsed nor claim to have kept the diagrams the
+// same while making an unparseable one parse.
 export const verify = async (edit: Edit, before: DocModel, after: DocModel): Promise<Verdict> => {
   if (edit.expect.kind === "same-tree") {
     if (!sameTree(before.tree, after.tree, {})) return "refuse";
-    if (before.kind === "markdown" && after.kind === "markdown") return "accept";
+    if (before.kind === "markdown" && after.kind === "markdown") {
+      return (await breaksAParse(before, after)) ? "refuse" : "accept";
+    }
   }
   return (await sameDiagrams(before, after)) ? "accept" : "refuse";
 };

package/src/parse/metrics.ts

@@ -152,11 +152,18 @@ const round4 = (x: number): number => Math.round(x * 10000) / 10000;
 // (nodes + edges*w_e + subgraphs*w_s) * (1 + depth*w_d). Edge density is
 // reported as 0 below two nodes rather than dividing by a fallback, which gave
 // nonsense when a parser returned edges but no nodes.
+//
+// The depth is subgraph nesting or, for a tree-shaped type (mindmap, treemap,
+// treeView, ishikawa), tree depth; a diagram has only one of the two. A deep
+// tree is as hard to follow as deep nesting, so its depth still weighs on the
+// score, and the score of those types is unchanged from when tree depth was
+// counted as nesting. Only complexity-subgraph-nesting-too-deep ignores it,
+// because its remedy (flatten subgraphs) cannot apply to a tree.
 export const calculateComplexity = (stats: DiagramStats, config: ThresholdConfig): ComplexityMetrics => {
   const n = stats.nodes;
   const e = stats.edges;
   const s = stats.subgraphs;
-  const d = stats.max_subgraph_depth;
+  const d = Math.max(stats.max_subgraph_depth, stats.max_tree_depth);
   const base = n + e * config.edge_weight + s * config.subgraph_weight;
   const vcs = base * (1 + d * config.depth_weight);
   const maxEdges = n > 1 ? n * (n - 1) : 0;

package/src/parse/stats.ts

@@ -36,7 +36,14 @@ export interface DiagramStats {
   nodes: number;
   edges: number;
   subgraphs: number;
+  // How deep real containers nest: flowchart subgraphs, composite states,
+  // architecture groups and the like.
   max_subgraph_depth: number;
+  // How far a tree-shaped diagram (mindmap, treemap, treeView, ishikawa)
+  // reaches below its root. Those types draw no subgraphs, so their depth is
+  // kept apart from max_subgraph_depth and the nesting rule never reads it.
+  // It is 0 for every other type.
+  max_tree_depth: number;
   node_ids: string[];
   subgraph_names: string[];
   // The parser that read the diagram, or, on a failure, the one whose reason
@@ -137,6 +144,7 @@ export async function extractStats(content: string): Promise<MermaidStats> {
     edges: 0,
     subgraphs: 0,
     max_subgraph_depth: 0,
+    max_tree_depth: 0,
     node_ids: [],
     subgraph_names: [],
     parser_used: langium ? "langium" : "mermaid-core",
@@ -200,6 +208,7 @@ async function extractLangiumStats(content: string, keyword: string): Promise<Me
   const subgraphNames: string[] = [];
   let edges = 0;
   let maxDepth = 0;
+  let treeDepth = 0;
 
   switch (mapped) {
     case "architecture": {
@@ -246,7 +255,7 @@ async function extractLangiumStats(content: string, keyword: string): Promise<Me
       const stats = indentTreeStats(nodes.map((n, i) => ({ label: n.name ?? `node_${i}`, indent: n.indent ?? 0 })));
       nodeIds.push(...stats.labels);
       edges = stats.edges;
-      maxDepth = stats.depth;
+      treeDepth = stats.depth;
       break;
     }
     case "treemap": {
@@ -255,7 +264,7 @@ async function extractLangiumStats(content: string, keyword: string): Promise<Me
       const stats = indentTreeStats(rows.map((r, i) => ({ label: r.item?.name ?? `row_${i}`, indent: r.indent ?? 0 })));
       nodeIds.push(...stats.labels);
       edges = stats.edges;
-      maxDepth = stats.depth;
+      treeDepth = stats.depth;
       break;
     }
     case "wardley": {
@@ -277,6 +286,7 @@ async function extractLangiumStats(content: string, keyword: string): Promise<Me
     edges,
     subgraphs: subgraphNames.length,
     max_subgraph_depth: maxDepth,
+    max_tree_depth: treeDepth,
     node_ids: [...new Set(nodeIds.filter(Boolean))].sort(),
     subgraph_names: subgraphNames,
     parser_used: "langium",
@@ -340,6 +350,8 @@ interface Structure {
   edges: number;
   subgraphNames: string[];
   maxDepth: number;
+  // Set only by the tree-shaped types: see max_tree_depth.
+  treeDepth?: number;
 }
 type CoreAdapter = (db: AnyDb) => Structure;
 
@@ -362,13 +374,14 @@ async function extractCoreStats(content: string, keyword: string): Promise<Merma
   if (!adapter) {
     throw new Error(`no core adapter for diagram.type="${diagramType}" (keyword="${keyword}")`);
   }
-  const { nodeIds, edges, subgraphNames, maxDepth } = adapter(diagram.db);
+  const { nodeIds, edges, subgraphNames, maxDepth, treeDepth = 0 } = adapter(diagram.db);
 
   return {
     nodes: nodeIds.length,
     edges,
     subgraphs: subgraphNames.length,
     max_subgraph_depth: maxDepth,
+    max_tree_depth: treeDepth,
     node_ids: [...nodeIds].sort(),
     subgraph_names: subgraphNames,
     parser_used: "mermaid-core",
@@ -386,6 +399,9 @@ async function extractCoreStats(content: string, keyword: string): Promise<Merma
 const CORE_ADAPTERS: Record<string, CoreAdapter> = {
   "flowchart-v2": adaptFlowchart,
   flowchart: adaptFlowchart,
+  // `flowchart-elk` is a flowchart drawn with the ELK layout. Mermaid parses it
+  // with the flowchart grammar into the same DB, and only the layout differs.
+  "flowchart-elk": adaptFlowchart,
   graph: adaptFlowchart,
   classDiagram: adaptClass,
   "classDiagram-v2": adaptClass,
@@ -557,7 +573,13 @@ function adaptIshikawa(db: AnyDb): Structure {
     for (const c of node.children ?? []) walk(c, depth + 1);
   };
   walk(root, 0);
-  return { nodeIds: labels, edges: Math.max(0, labels.length - 1), subgraphNames: [], maxDepth };
+  return {
+    nodeIds: labels,
+    edges: Math.max(0, labels.length - 1),
+    subgraphNames: [],
+    maxDepth: 0,
+    treeDepth: maxDepth,
+  };
 }
 
 interface KanbanNode {
@@ -596,7 +618,13 @@ function adaptMindmap(db: AnyDb): Structure {
     for (const c of node.children ?? []) walk(c, depth + 1);
   };
   walk(root, 0);
-  return { nodeIds: labels, edges: Math.max(0, labels.length - 1), subgraphNames: [], maxDepth };
+  return {
+    nodeIds: labels,
+    edges: Math.max(0, labels.length - 1),
+    subgraphNames: [],
+    maxDepth: 0,
+    treeDepth: maxDepth,
+  };
 }
 
 type QuadrantText = { text?: string } | string | undefined;