@jpeakai/mermaidjs-lint 0.7.4 → 0.8.0

package/dist/bin.js

@@ -9,7 +9,7 @@ import { parseArgs } from "node:util";
 // package.json
 var package_default = {
   name: "@jpeakai/mermaidjs-lint",
-  version: "0.7.4",
+  version: "0.8.0",
   type: "module",
   description: "Deterministic lint gates and verified fixers for Mermaid diagrams in markdown",
   license: "MIT",
@@ -381,6 +381,7 @@ var extractStyleDirectives = (source) => {
 
 // src/parse/stats.ts
 import { parse as langiumParse } from "@mermaid-js/parser";
+import Color2 from "colorjs.io";
 import { Window } from "happy-dom";
 var installDomShim = () => {
   const g = globalThis;
@@ -395,6 +396,23 @@ var installDomShim = () => {
   g.DocumentFragment = win.DocumentFragment;
   g.NodeFilter = win.NodeFilter;
   g.getComputedStyle = win.getComputedStyle.bind(win);
+  const css = win.CSS;
+  if (css) {
+    const supports = css.supports.bind(css);
+    const fixed = {
+      ...css,
+      supports: (property, value) => property === "color" && value !== undefined ? isCssColour(value) : supports(property, value)
+    };
+    Object.defineProperty(win, "CSS", { value: fixed, configurable: true });
+  }
+};
+var isCssColour = (value) => {
+  try {
+    new Color2(value);
+    return true;
+  } catch {
+    return false;
+  }
 };
 var mermaidCore = null;
 var getMermaid = async () => {
@@ -470,6 +488,7 @@ async function extractStats(content) {
     subgraphs: 0,
     max_subgraph_depth: 0,
     max_tree_depth: 0,
+    rows: 0,
     node_ids: [],
     subgraph_names: [],
     parser_used: langium ? "langium" : "mermaid-core",
@@ -522,6 +541,7 @@ async function extractLangiumStats(content, keyword) {
     subgraphs: subgraphNames.length,
     max_subgraph_depth: maxDepth,
     max_tree_depth: treeDepth,
+    rows: 0,
     node_ids: [...new Set(nodeIds.filter(Boolean))].sort(),
     subgraph_names: subgraphNames,
     parser_used: "langium",
@@ -651,13 +671,14 @@ async function extractCoreStats(content, keyword) {
   if (!adapter) {
     throw new Error(`no core adapter for diagram.type="${diagramType}" (keyword="${keyword}")`);
   }
-  const { nodeIds, edges, subgraphNames, maxDepth, treeDepth = 0 } = adapter(diagram.db);
+  const { nodeIds, edges, subgraphNames, maxDepth, treeDepth = 0, rows = 0 } = adapter(diagram.db);
   return {
     nodes: nodeIds.length,
     edges,
     subgraphs: subgraphNames.length,
     max_subgraph_depth: maxDepth,
     max_tree_depth: treeDepth,
+    rows,
     node_ids: [...nodeIds].sort(),
     subgraph_names: subgraphNames,
     parser_used: "mermaid-core",
@@ -706,21 +727,50 @@ function adaptFlowchart(db) {
     maxDepth: subgraphNestingDepth(subGraphs)
   };
 }
+var lengthOf = (x) => Array.isArray(x) ? x.length : 0;
 function adaptClass(db) {
   const classes = db.classes instanceof Map ? db.classes : new Map;
   const relations = Array.isArray(db.relations) ? db.relations : [];
-  return { nodeIds: [...classes.keys()], edges: relations.length, subgraphNames: [], maxDepth: 0 };
+  const namespaces = db.namespaces instanceof Map ? db.namespaces : new Map;
+  const groups = [...namespaces].map(([id, ns]) => ({ id, in: ns.parent, label: ns.label || id }));
+  let rows = 0;
+  for (const c of classes.values())
+    rows += lengthOf(c.members) + lengthOf(c.methods);
+  return {
+    nodeIds: [...classes.keys()],
+    edges: relations.length,
+    subgraphNames: groups.map((g) => g.label),
+    maxDepth: architectureDepth(groups),
+    rows
+  };
 }
+var SEQ_NOTE = 2;
+var SEQUENCE_BLOCK_OPEN = new Set([10, 12, 15, 19, 27, 30, 32]);
+var SEQUENCE_BLOCK_CLOSE = new Set([11, 14, 16, 21, 29, 31]);
+var isSequenceMessage = (m) => m.type !== SEQ_NOTE && typeof m.from === "string" && typeof m.to === "string";
 function adaptSequence(db) {
   const state = db.state?.records;
   const actors = state?.actors instanceof Map ? state.actors : new Map;
   const rawMessages = state?.messages;
-  const messages = Array.isArray(rawMessages) ? rawMessages : [];
+  const records = Array.isArray(rawMessages) ? rawMessages : [];
+  const boxes = Array.isArray(state?.boxes) ? state.boxes : [];
+  const subgraphNames = boxes.map((b, i) => b.name || `box_${i}`);
+  let depth = 0;
+  let maxBlockDepth = 0;
+  for (const r of records) {
+    if (r.type !== undefined && SEQUENCE_BLOCK_OPEN.has(r.type)) {
+      depth++;
+      maxBlockDepth = Math.max(maxBlockDepth, depth);
+      subgraphNames.push(typeof r.message === "string" && r.message ? r.message : `block_${subgraphNames.length}`);
+    } else if (r.type !== undefined && SEQUENCE_BLOCK_CLOSE.has(r.type)) {
+      depth = Math.max(0, depth - 1);
+    }
+  }
   return {
     nodeIds: [...actors.keys()],
-    edges: messages.length,
-    subgraphNames: [],
-    maxDepth: 0
+    edges: records.filter(isSequenceMessage).length,
+    subgraphNames,
+    maxDepth: Math.max(boxes.length > 0 ? 1 : 0, maxBlockDepth)
   };
 }
 function adaptBlock(db) {
@@ -761,11 +811,15 @@ function adaptC4(db) {
 function adaptEr(db) {
   const entities = db.entities instanceof Map ? db.entities : new Map;
   const relationships = Array.isArray(db.relationships) ? db.relationships : [];
+  let rows = 0;
+  for (const e of entities.values())
+    rows += lengthOf(e.attributes);
   return {
     nodeIds: [...entities.keys()],
     edges: relationships.length,
     subgraphNames: [],
-    maxDepth: 0
+    maxDepth: 0,
+    rows
   };
 }
 function adaptGantt(db) {
@@ -862,9 +916,17 @@ function adaptSankey(db) {
     maxDepth: 0
   };
 }
+var STATE_NOT_A_STATE = new Set(["stateStart", "stateEnd", "note", "noteGroup"]);
+var isCountedState = (n) => !STATE_NOT_A_STATE.has(n.shape ?? "");
+var countedStateElements = (db) => {
+  const all = db.nodes ?? [];
+  const nodes = all.filter(isCountedState);
+  const kept = new Set(nodes.map((n) => n.id ?? ""));
+  const edges = (db.edges ?? []).filter((e) => kept.has(e.start ?? "") && kept.has(e.end ?? ""));
+  return { nodes, edges };
+};
 function adaptState(db) {
-  const nodes = db.nodes ?? [];
-  const edges = db.edges ?? [];
+  const { nodes, edges } = countedStateElements(db);
   const groups = nodes.filter((n) => n.isGroup === true);
   const parentOf = new Map(nodes.map((n) => [n.id ?? "", n.parentId]));
   let maxDepth = 0;
@@ -1489,7 +1551,7 @@ var PRESET_ALIASES = {
   permissive: "high-density",
   default: "high-density"
 };
-var VCS_WEIGHTS = { edge: 0.5, subgraph: 3, depth: 0.1 };
+var VCS_WEIGHTS = { edge: 0.5, row: 0.25, subgraph: 3, depth: 0.1 };
 var THRESHOLD_OPTIONS = {
   nodeIdeal: "node_ideal",
   nodeAcceptable: "node_acceptable",
@@ -1502,6 +1564,7 @@ var THRESHOLD_OPTIONS = {
   nodeTarget: "node_target",
   vcsTarget: "vcs_target",
   edgeWeight: "edge_weight",
+  rowWeight: "row_weight",
   subgraphWeight: "subgraph_weight",
   depthWeight: "depth_weight"
 };
@@ -1520,6 +1583,7 @@ var configFromPreset = (name) => {
   return {
     ...preset,
     edge_weight: VCS_WEIGHTS.edge,
+    row_weight: VCS_WEIGHTS.row,
     subgraph_weight: VCS_WEIGHTS.subgraph,
     depth_weight: VCS_WEIGHTS.depth,
     preset_name: canonical
@@ -1547,7 +1611,7 @@ var calculateComplexity = (stats, config) => {
   const e = stats.edges;
   const s = stats.subgraphs;
   const d = Math.max(stats.max_subgraph_depth, stats.max_tree_depth);
-  const base = n + e * config.edge_weight + s * config.subgraph_weight;
+  const base = n + e * config.edge_weight + stats.rows * config.row_weight + s * config.subgraph_weight;
   const vcs = base * (1 + d * config.depth_weight);
   const maxEdges = n > 1 ? n * (n - 1) : 0;
   return {
@@ -1583,6 +1647,7 @@ var COMPLEXITY_OPTIONS = {
   nodeTarget: "number",
   vcsTarget: "number",
   edgeWeight: "number",
+  rowWeight: "number",
   subgraphWeight: "number",
   depthWeight: "number"
 };
@@ -2273,6 +2338,7 @@ var sameDiagrams = async (before, after) => {
       s.subgraphs,
       s.max_subgraph_depth,
       s.max_tree_depth,
+      s.rows,
       s.node_ids,
       s.subgraph_names
     ];

package/dist/index.js

@@ -303,6 +303,7 @@ var extractStyleDirectives = (source) => {
 
 // src/parse/stats.ts
 import { parse as langiumParse } from "@mermaid-js/parser";
+import Color2 from "colorjs.io";
 import { Window } from "happy-dom";
 var installDomShim = () => {
   const g = globalThis;
@@ -317,6 +318,23 @@ var installDomShim = () => {
   g.DocumentFragment = win.DocumentFragment;
   g.NodeFilter = win.NodeFilter;
   g.getComputedStyle = win.getComputedStyle.bind(win);
+  const css = win.CSS;
+  if (css) {
+    const supports = css.supports.bind(css);
+    const fixed = {
+      ...css,
+      supports: (property, value) => property === "color" && value !== undefined ? isCssColour(value) : supports(property, value)
+    };
+    Object.defineProperty(win, "CSS", { value: fixed, configurable: true });
+  }
+};
+var isCssColour = (value) => {
+  try {
+    new Color2(value);
+    return true;
+  } catch {
+    return false;
+  }
 };
 var mermaidCore = null;
 var getMermaid = async () => {
@@ -392,6 +410,7 @@ async function extractStats(content) {
     subgraphs: 0,
     max_subgraph_depth: 0,
     max_tree_depth: 0,
+    rows: 0,
     node_ids: [],
     subgraph_names: [],
     parser_used: langium ? "langium" : "mermaid-core",
@@ -444,6 +463,7 @@ async function extractLangiumStats(content, keyword) {
     subgraphs: subgraphNames.length,
     max_subgraph_depth: maxDepth,
     max_tree_depth: treeDepth,
+    rows: 0,
     node_ids: [...new Set(nodeIds.filter(Boolean))].sort(),
     subgraph_names: subgraphNames,
     parser_used: "langium",
@@ -573,13 +593,14 @@ async function extractCoreStats(content, keyword) {
   if (!adapter) {
     throw new Error(`no core adapter for diagram.type="${diagramType}" (keyword="${keyword}")`);
   }
-  const { nodeIds, edges, subgraphNames, maxDepth, treeDepth = 0 } = adapter(diagram.db);
+  const { nodeIds, edges, subgraphNames, maxDepth, treeDepth = 0, rows = 0 } = adapter(diagram.db);
   return {
     nodes: nodeIds.length,
     edges,
     subgraphs: subgraphNames.length,
     max_subgraph_depth: maxDepth,
     max_tree_depth: treeDepth,
+    rows,
     node_ids: [...nodeIds].sort(),
     subgraph_names: subgraphNames,
     parser_used: "mermaid-core",
@@ -628,21 +649,50 @@ function adaptFlowchart(db) {
     maxDepth: subgraphNestingDepth(subGraphs)
   };
 }
+var lengthOf = (x) => Array.isArray(x) ? x.length : 0;
 function adaptClass(db) {
   const classes = db.classes instanceof Map ? db.classes : new Map;
   const relations = Array.isArray(db.relations) ? db.relations : [];
-  return { nodeIds: [...classes.keys()], edges: relations.length, subgraphNames: [], maxDepth: 0 };
+  const namespaces = db.namespaces instanceof Map ? db.namespaces : new Map;
+  const groups = [...namespaces].map(([id, ns]) => ({ id, in: ns.parent, label: ns.label || id }));
+  let rows = 0;
+  for (const c of classes.values())
+    rows += lengthOf(c.members) + lengthOf(c.methods);
+  return {
+    nodeIds: [...classes.keys()],
+    edges: relations.length,
+    subgraphNames: groups.map((g) => g.label),
+    maxDepth: architectureDepth(groups),
+    rows
+  };
 }
+var SEQ_NOTE = 2;
+var SEQUENCE_BLOCK_OPEN = new Set([10, 12, 15, 19, 27, 30, 32]);
+var SEQUENCE_BLOCK_CLOSE = new Set([11, 14, 16, 21, 29, 31]);
+var isSequenceMessage = (m) => m.type !== SEQ_NOTE && typeof m.from === "string" && typeof m.to === "string";
 function adaptSequence(db) {
   const state = db.state?.records;
   const actors = state?.actors instanceof Map ? state.actors : new Map;
   const rawMessages = state?.messages;
-  const messages = Array.isArray(rawMessages) ? rawMessages : [];
+  const records = Array.isArray(rawMessages) ? rawMessages : [];
+  const boxes = Array.isArray(state?.boxes) ? state.boxes : [];
+  const subgraphNames = boxes.map((b, i) => b.name || `box_${i}`);
+  let depth = 0;
+  let maxBlockDepth = 0;
+  for (const r of records) {
+    if (r.type !== undefined && SEQUENCE_BLOCK_OPEN.has(r.type)) {
+      depth++;
+      maxBlockDepth = Math.max(maxBlockDepth, depth);
+      subgraphNames.push(typeof r.message === "string" && r.message ? r.message : `block_${subgraphNames.length}`);
+    } else if (r.type !== undefined && SEQUENCE_BLOCK_CLOSE.has(r.type)) {
+      depth = Math.max(0, depth - 1);
+    }
+  }
   return {
     nodeIds: [...actors.keys()],
-    edges: messages.length,
-    subgraphNames: [],
-    maxDepth: 0
+    edges: records.filter(isSequenceMessage).length,
+    subgraphNames,
+    maxDepth: Math.max(boxes.length > 0 ? 1 : 0, maxBlockDepth)
   };
 }
 function adaptBlock(db) {
@@ -683,11 +733,15 @@ function adaptC4(db) {
 function adaptEr(db) {
   const entities = db.entities instanceof Map ? db.entities : new Map;
   const relationships = Array.isArray(db.relationships) ? db.relationships : [];
+  let rows = 0;
+  for (const e of entities.values())
+    rows += lengthOf(e.attributes);
   return {
     nodeIds: [...entities.keys()],
     edges: relationships.length,
     subgraphNames: [],
-    maxDepth: 0
+    maxDepth: 0,
+    rows
   };
 }
 function adaptGantt(db) {
@@ -784,9 +838,17 @@ function adaptSankey(db) {
     maxDepth: 0
   };
 }
+var STATE_NOT_A_STATE = new Set(["stateStart", "stateEnd", "note", "noteGroup"]);
+var isCountedState = (n) => !STATE_NOT_A_STATE.has(n.shape ?? "");
+var countedStateElements = (db) => {
+  const all = db.nodes ?? [];
+  const nodes = all.filter(isCountedState);
+  const kept = new Set(nodes.map((n) => n.id ?? ""));
+  const edges = (db.edges ?? []).filter((e) => kept.has(e.start ?? "") && kept.has(e.end ?? ""));
+  return { nodes, edges };
+};
 function adaptState(db) {
-  const nodes = db.nodes ?? [];
-  const edges = db.edges ?? [];
+  const { nodes, edges } = countedStateElements(db);
   const groups = nodes.filter((n) => n.isGroup === true);
   const parentOf = new Map(nodes.map((n) => [n.id ?? "", n.parentId]));
   let maxDepth = 0;
@@ -1411,7 +1473,7 @@ var PRESET_ALIASES = {
   permissive: "high-density",
   default: "high-density"
 };
-var VCS_WEIGHTS = { edge: 0.5, subgraph: 3, depth: 0.1 };
+var VCS_WEIGHTS = { edge: 0.5, row: 0.25, subgraph: 3, depth: 0.1 };
 var THRESHOLD_OPTIONS = {
   nodeIdeal: "node_ideal",
   nodeAcceptable: "node_acceptable",
@@ -1424,6 +1486,7 @@ var THRESHOLD_OPTIONS = {
   nodeTarget: "node_target",
   vcsTarget: "vcs_target",
   edgeWeight: "edge_weight",
+  rowWeight: "row_weight",
   subgraphWeight: "subgraph_weight",
   depthWeight: "depth_weight"
 };
@@ -1442,6 +1505,7 @@ var configFromPreset = (name) => {
   return {
     ...preset,
     edge_weight: VCS_WEIGHTS.edge,
+    row_weight: VCS_WEIGHTS.row,
     subgraph_weight: VCS_WEIGHTS.subgraph,
     depth_weight: VCS_WEIGHTS.depth,
     preset_name: canonical
@@ -1469,7 +1533,7 @@ var calculateComplexity = (stats, config) => {
   const e = stats.edges;
   const s = stats.subgraphs;
   const d = Math.max(stats.max_subgraph_depth, stats.max_tree_depth);
-  const base = n + e * config.edge_weight + s * config.subgraph_weight;
+  const base = n + e * config.edge_weight + stats.rows * config.row_weight + s * config.subgraph_weight;
   const vcs = base * (1 + d * config.depth_weight);
   const maxEdges = n > 1 ? n * (n - 1) : 0;
   return {
@@ -1505,6 +1569,7 @@ var COMPLEXITY_OPTIONS = {
   nodeTarget: "number",
   vcsTarget: "number",
   edgeWeight: "number",
+  rowWeight: "number",
   subgraphWeight: "number",
   depthWeight: "number"
 };
@@ -2095,7 +2160,7 @@ import { parseArgs } from "node:util";
 // package.json
 var package_default = {
   name: "@jpeakai/mermaidjs-lint",
-  version: "0.7.4",
+  version: "0.8.0",
   type: "module",
   description: "Deterministic lint gates and verified fixers for Mermaid diagrams in markdown",
   license: "MIT",
@@ -2272,6 +2337,7 @@ var sameDiagrams = async (before, after) => {
       s.subgraphs,
       s.max_subgraph_depth,
       s.max_tree_depth,
+      s.rows,
       s.node_ids,
       s.subgraph_names
     ];

package/dist/testing.js

@@ -201,6 +201,7 @@ var extractStyleDirectives = (source) => {
 
 // src/parse/stats.ts
 import { parse as langiumParse } from "@mermaid-js/parser";
+import Color2 from "colorjs.io";
 import { Window } from "happy-dom";
 var installDomShim = () => {
   const g = globalThis;
@@ -215,6 +216,23 @@ var installDomShim = () => {
   g.DocumentFragment = win.DocumentFragment;
   g.NodeFilter = win.NodeFilter;
   g.getComputedStyle = win.getComputedStyle.bind(win);
+  const css = win.CSS;
+  if (css) {
+    const supports = css.supports.bind(css);
+    const fixed = {
+      ...css,
+      supports: (property, value) => property === "color" && value !== undefined ? isCssColour(value) : supports(property, value)
+    };
+    Object.defineProperty(win, "CSS", { value: fixed, configurable: true });
+  }
+};
+var isCssColour = (value) => {
+  try {
+    new Color2(value);
+    return true;
+  } catch {
+    return false;
+  }
 };
 var mermaidCore = null;
 var getMermaid = async () => {
@@ -290,6 +308,7 @@ async function extractStats(content) {
     subgraphs: 0,
     max_subgraph_depth: 0,
     max_tree_depth: 0,
+    rows: 0,
     node_ids: [],
     subgraph_names: [],
     parser_used: langium ? "langium" : "mermaid-core",
@@ -342,6 +361,7 @@ async function extractLangiumStats(content, keyword) {
     subgraphs: subgraphNames.length,
     max_subgraph_depth: maxDepth,
     max_tree_depth: treeDepth,
+    rows: 0,
     node_ids: [...new Set(nodeIds.filter(Boolean))].sort(),
     subgraph_names: subgraphNames,
     parser_used: "langium",
@@ -471,13 +491,14 @@ async function extractCoreStats(content, keyword) {
   if (!adapter) {
     throw new Error(`no core adapter for diagram.type="${diagramType}" (keyword="${keyword}")`);
   }
-  const { nodeIds, edges, subgraphNames, maxDepth, treeDepth = 0 } = adapter(diagram.db);
+  const { nodeIds, edges, subgraphNames, maxDepth, treeDepth = 0, rows = 0 } = adapter(diagram.db);
   return {
     nodes: nodeIds.length,
     edges,
     subgraphs: subgraphNames.length,
     max_subgraph_depth: maxDepth,
     max_tree_depth: treeDepth,
+    rows,
     node_ids: [...nodeIds].sort(),
     subgraph_names: subgraphNames,
     parser_used: "mermaid-core",
@@ -526,21 +547,50 @@ function adaptFlowchart(db) {
     maxDepth: subgraphNestingDepth(subGraphs)
   };
 }
+var lengthOf = (x) => Array.isArray(x) ? x.length : 0;
 function adaptClass(db) {
   const classes = db.classes instanceof Map ? db.classes : new Map;
   const relations = Array.isArray(db.relations) ? db.relations : [];
-  return { nodeIds: [...classes.keys()], edges: relations.length, subgraphNames: [], maxDepth: 0 };
+  const namespaces = db.namespaces instanceof Map ? db.namespaces : new Map;
+  const groups = [...namespaces].map(([id, ns]) => ({ id, in: ns.parent, label: ns.label || id }));
+  let rows = 0;
+  for (const c of classes.values())
+    rows += lengthOf(c.members) + lengthOf(c.methods);
+  return {
+    nodeIds: [...classes.keys()],
+    edges: relations.length,
+    subgraphNames: groups.map((g) => g.label),
+    maxDepth: architectureDepth(groups),
+    rows
+  };
 }
+var SEQ_NOTE = 2;
+var SEQUENCE_BLOCK_OPEN = new Set([10, 12, 15, 19, 27, 30, 32]);
+var SEQUENCE_BLOCK_CLOSE = new Set([11, 14, 16, 21, 29, 31]);
+var isSequenceMessage = (m) => m.type !== SEQ_NOTE && typeof m.from === "string" && typeof m.to === "string";
 function adaptSequence(db) {
   const state = db.state?.records;
   const actors = state?.actors instanceof Map ? state.actors : new Map;
   const rawMessages = state?.messages;
-  const messages = Array.isArray(rawMessages) ? rawMessages : [];
+  const records = Array.isArray(rawMessages) ? rawMessages : [];
+  const boxes = Array.isArray(state?.boxes) ? state.boxes : [];
+  const subgraphNames = boxes.map((b, i) => b.name || `box_${i}`);
+  let depth = 0;
+  let maxBlockDepth = 0;
+  for (const r of records) {
+    if (r.type !== undefined && SEQUENCE_BLOCK_OPEN.has(r.type)) {
+      depth++;
+      maxBlockDepth = Math.max(maxBlockDepth, depth);
+      subgraphNames.push(typeof r.message === "string" && r.message ? r.message : `block_${subgraphNames.length}`);
+    } else if (r.type !== undefined && SEQUENCE_BLOCK_CLOSE.has(r.type)) {
+      depth = Math.max(0, depth - 1);
+    }
+  }
   return {
     nodeIds: [...actors.keys()],
-    edges: messages.length,
-    subgraphNames: [],
-    maxDepth: 0
+    edges: records.filter(isSequenceMessage).length,
+    subgraphNames,
+    maxDepth: Math.max(boxes.length > 0 ? 1 : 0, maxBlockDepth)
   };
 }
 function adaptBlock(db) {
@@ -581,11 +631,15 @@ function adaptC4(db) {
 function adaptEr(db) {
   const entities = db.entities instanceof Map ? db.entities : new Map;
   const relationships = Array.isArray(db.relationships) ? db.relationships : [];
+  let rows = 0;
+  for (const e of entities.values())
+    rows += lengthOf(e.attributes);
   return {
     nodeIds: [...entities.keys()],
     edges: relationships.length,
     subgraphNames: [],
-    maxDepth: 0
+    maxDepth: 0,
+    rows
   };
 }
 function adaptGantt(db) {
@@ -682,9 +736,17 @@ function adaptSankey(db) {
     maxDepth: 0
   };
 }
+var STATE_NOT_A_STATE = new Set(["stateStart", "stateEnd", "note", "noteGroup"]);
+var isCountedState = (n) => !STATE_NOT_A_STATE.has(n.shape ?? "");
+var countedStateElements = (db) => {
+  const all = db.nodes ?? [];
+  const nodes = all.filter(isCountedState);
+  const kept = new Set(nodes.map((n) => n.id ?? ""));
+  const edges = (db.edges ?? []).filter((e) => kept.has(e.start ?? "") && kept.has(e.end ?? ""));
+  return { nodes, edges };
+};
 function adaptState(db) {
-  const nodes = db.nodes ?? [];
-  const edges = db.edges ?? [];
+  const { nodes, edges } = countedStateElements(db);
   const groups = nodes.filter((n) => n.isGroup === true);
   const parentOf = new Map(nodes.map((n) => [n.id ?? "", n.parentId]));
   let maxDepth = 0;
@@ -1309,7 +1371,7 @@ var PRESET_ALIASES = {
   permissive: "high-density",
   default: "high-density"
 };
-var VCS_WEIGHTS = { edge: 0.5, subgraph: 3, depth: 0.1 };
+var VCS_WEIGHTS = { edge: 0.5, row: 0.25, subgraph: 3, depth: 0.1 };
 var THRESHOLD_OPTIONS = {
   nodeIdeal: "node_ideal",
   nodeAcceptable: "node_acceptable",
@@ -1322,6 +1384,7 @@ var THRESHOLD_OPTIONS = {
   nodeTarget: "node_target",
   vcsTarget: "vcs_target",
   edgeWeight: "edge_weight",
+  rowWeight: "row_weight",
   subgraphWeight: "subgraph_weight",
   depthWeight: "depth_weight"
 };
@@ -1340,6 +1403,7 @@ var configFromPreset = (name) => {
   return {
     ...preset,
     edge_weight: VCS_WEIGHTS.edge,
+    row_weight: VCS_WEIGHTS.row,
     subgraph_weight: VCS_WEIGHTS.subgraph,
     depth_weight: VCS_WEIGHTS.depth,
     preset_name: canonical
@@ -1367,7 +1431,7 @@ var calculateComplexity = (stats, config) => {
   const e = stats.edges;
   const s = stats.subgraphs;
   const d = Math.max(stats.max_subgraph_depth, stats.max_tree_depth);
-  const base = n + e * config.edge_weight + s * config.subgraph_weight;
+  const base = n + e * config.edge_weight + stats.rows * config.row_weight + s * config.subgraph_weight;
   const vcs = base * (1 + d * config.depth_weight);
   const maxEdges = n > 1 ? n * (n - 1) : 0;
   return {
@@ -1403,6 +1467,7 @@ var COMPLEXITY_OPTIONS = {
   nodeTarget: "number",
   vcsTarget: "number",
   edgeWeight: "number",
+  rowWeight: "number",
   subgraphWeight: "number",
   depthWeight: "number"
 };
@@ -2025,6 +2090,7 @@ var sameDiagrams = async (before, after) => {
       s.subgraphs,
       s.max_subgraph_depth,
       s.max_tree_depth,
+      s.rows,
       s.node_ids,
       s.subgraph_names
     ];

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

@@ -15,6 +15,7 @@ export declare const PRESETS: Record<string, Preset>;
 export declare const DEFAULT_PRESET = "high-density";
 export interface ThresholdConfig extends Preset {
     edge_weight: number;
+    row_weight: number;
     subgraph_weight: number;
     depth_weight: number;
     preset_name: string;
@@ -31,6 +32,7 @@ export declare const THRESHOLD_OPTIONS: {
     readonly nodeTarget: "node_target";
     readonly vcsTarget: "vcs_target";
     readonly edgeWeight: "edge_weight";
+    readonly rowWeight: "row_weight";
     readonly subgraphWeight: "subgraph_weight";
     readonly depthWeight: "depth_weight";
 };

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

@@ -17,6 +17,7 @@ export interface DiagramStats {
     subgraphs: number;
     max_subgraph_depth: number;
     max_tree_depth: number;
+    rows: number;
     node_ids: string[];
     subgraph_names: string[];
     parser_used: "langium" | "mermaid-core";
@@ -35,4 +36,32 @@ export declare function indentTreeStats(items: Array<{
     edges: number;
     depth: number;
 };
+type AnyDb = Record<string, unknown>;
+interface SequenceRecord {
+    type?: number;
+    from?: unknown;
+    to?: unknown;
+    message?: unknown;
+}
+export declare const SEQUENCE_BLOCK_OPEN: ReadonlySet<number>;
+export declare const SEQUENCE_BLOCK_CLOSE: ReadonlySet<number>;
+export declare const isSequenceMessage: (m: SequenceRecord) => boolean;
+interface StateNode {
+    id?: string;
+    type?: string;
+    shape?: string;
+    isGroup?: boolean;
+    parentId?: string;
+}
+interface StateEdge {
+    start?: string;
+    end?: string;
+}
+export declare const isCountedState: (n: {
+    shape?: string;
+}) => boolean;
+export declare const countedStateElements: <N extends StateNode, E extends StateEdge>(db: AnyDb) => {
+    nodes: N[];
+    edges: E[];
+};
 export {};

package/package.json

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

package/src/fix/verify.ts

@@ -57,6 +57,7 @@ const sameDiagrams = async (before: DocModel, after: DocModel): Promise<boolean>
       s.subgraphs,
       s.max_subgraph_depth,
       s.max_tree_depth,
+      s.rows,
       s.node_ids,
       s.subgraph_names,
     ];

package/src/parse/graph.ts

@@ -4,7 +4,13 @@
 // the docs site can draw what the parser returned beside the score it earns.
 // Only the types the site draws are read, and any other type throws.
 
-import { getMermaidCore } from "./stats.ts";
+import {
+  countedStateElements,
+  getMermaidCore,
+  isSequenceMessage,
+  SEQUENCE_BLOCK_CLOSE,
+  SEQUENCE_BLOCK_OPEN,
+} from "./stats.ts";
 
 export interface GraphNode {
   id: string;
@@ -80,11 +86,122 @@ const mindmapGraph = (type: string, db: AnyDb): DiagramGraph => {
   return { diagram_type: type, nodes, edges, subgraphs: [] };
 };
 
+interface SequenceActor {
+  description?: string;
+  box?: { name?: string };
+}
+interface SequenceRecord {
+  type?: number;
+  from?: unknown;
+  to?: unknown;
+  message?: unknown;
+}
+
+// A participant is a node, and a message an edge between two. A box holds its
+// participants. A block (loop, alt, opt, par and the rest) frames messages,
+// not participants, so it holds no node; it is drawn as an empty boundary,
+// inside the block around it.
+const sequenceGraph = (type: string, db: AnyDb): DiagramGraph => {
+  const records = (db.state as { records?: Record<string, unknown> } | undefined)?.records ?? {};
+  const actors = records.actors instanceof Map ? (records.actors as Map<string, SequenceActor>) : new Map();
+  const boxes = (Array.isArray(records.boxes) ? records.boxes : []) as Array<{ name?: string }>;
+  const messages = (Array.isArray(records.messages) ? records.messages : []) as SequenceRecord[];
+  const boxId = (i: number): string => `box_${i}`;
+  const subgraphs: GraphNode[] = boxes.map((b, i) => ({ id: boxId(i), label: b.name || boxId(i), parent: null }));
+  const nodes: GraphNode[] = [...actors].map(([id, a]) => {
+    const i = a.box ? boxes.indexOf(a.box) : -1;
+    return { id, label: a.description ?? id, parent: i >= 0 ? boxId(i) : null };
+  });
+  const edges = messages.filter(isSequenceMessage).map((r) => ({ source: r.from as string, target: r.to as string }));
+  return { diagram_type: type, nodes, edges, subgraphs: [...subgraphs, ...sequenceBlocks(messages, subgraphs.length)] };
+};
+
+// Each block in statement order, inside the block open around it. Ids number
+// on from the boxes, so a block and a box never share one.
+const sequenceBlocks = (records: SequenceRecord[], first: number): GraphNode[] => {
+  const blocks: GraphNode[] = [];
+  const open: string[] = [];
+  for (const r of records) {
+    if (r.type === undefined) continue;
+    if (SEQUENCE_BLOCK_OPEN.has(r.type)) {
+      const id = `block_${first + blocks.length}`;
+      const label = typeof r.message === "string" && r.message ? r.message : id;
+      blocks.push({ id, label, parent: open[open.length - 1] ?? null });
+      open.push(id);
+    } else if (SEQUENCE_BLOCK_CLOSE.has(r.type)) {
+      open.pop();
+    }
+  }
+  return blocks;
+};
+
+interface ErEntity {
+  id?: string;
+  alias?: string;
+}
+interface ErRelationship {
+  entityA?: string;
+  entityB?: string;
+}
+
+// An entity is a node and a relationship an edge. The db keys entities by
+// name, and a relationship names its two ends by the entity's own id.
+const erGraph = (type: string, db: AnyDb): DiagramGraph => {
+  const entities = db.entities instanceof Map ? (db.entities as Map<string, ErEntity>) : new Map();
+  const rels = (Array.isArray(db.relationships) ? db.relationships : []) as ErRelationship[];
+  const nameOf = new Map([...entities].map(([name, e]) => [e.id ?? name, name]));
+  return {
+    diagram_type: type,
+    nodes: [...entities].map(([name, e]) => ({ id: name, label: e.alias || name, parent: null })),
+    edges: rels.map((r) => ({
+      source: nameOf.get(r.entityA ?? "") ?? r.entityA ?? "",
+      target: nameOf.get(r.entityB ?? "") ?? r.entityB ?? "",
+    })),
+    subgraphs: [],
+  };
+};
+
+interface StateNode {
+  id?: string;
+  label?: string;
+  isGroup?: boolean;
+  parentId?: string;
+}
+interface StateEdge {
+  start?: string;
+  end?: string;
+}
+
+// The states and transitions stats.ts counts, without start and end markers or
+// notes. A composite state is both a node and the subgraph that holds its
+// children, as the stats count it; the node is named apart from its box, since
+// cytoscape cannot draw one element as both.
+const stateGraph = (type: string, db: AnyDb): DiagramGraph => {
+  const { nodes, edges } = countedStateElements<StateNode, StateEdge>(db);
+  const groupId = (id: string): string => `${id}__group`;
+  const groups = new Set(nodes.filter((n) => n.isGroup).map((n) => n.id ?? ""));
+  const parentOf = (n: StateNode): string | null => (n.parentId && groups.has(n.parentId) ? groupId(n.parentId) : null);
+  return {
+    diagram_type: type,
+    nodes: nodes.map((n) => ({
+      id: n.id ?? "",
+      label: n.label ?? n.id ?? "",
+      parent: n.isGroup ? groupId(n.id ?? "") : parentOf(n),
+    })),
+    edges: edges.map((e) => ({ source: e.start ?? "", target: e.end ?? "" })),
+    subgraphs: nodes.filter((n) => n.isGroup).map((n) => ({ id: groupId(n.id ?? ""), label: "", parent: parentOf(n) })),
+  };
+};
+
 const READERS: Record<string, (type: string, db: AnyDb) => DiagramGraph> = {
   "flowchart-v2": flowchartGraph,
   flowchart: flowchartGraph,
   graph: flowchartGraph,
   mindmap: mindmapGraph,
+  sequence: sequenceGraph,
+  er: erGraph,
+  stateDiagram: stateGraph,
+  "stateDiagram-v2": stateGraph,
 };
 
 export const extractGraph = async (content: string): Promise<DiagramGraph> => {

package/src/parse/metrics.ts

@@ -73,10 +73,13 @@ const PRESET_ALIASES: Record<string, string> = {
   default: "high-density",
 };
 
-const VCS_WEIGHTS = { edge: 0.5, subgraph: 3.0, depth: 0.1 } as const;
+// A row (an entity's attribute, a class's member) weighs half an edge: it is
+// text to read, but inside a box the reader has already found.
+const VCS_WEIGHTS = { edge: 0.5, row: 0.25, subgraph: 3.0, depth: 0.1 } as const;
 
 export interface ThresholdConfig extends Preset {
   edge_weight: number;
+  row_weight: number;
   subgraph_weight: number;
   depth_weight: number;
   preset_name: string;
@@ -96,6 +99,7 @@ export const THRESHOLD_OPTIONS = {
   nodeTarget: "node_target",
   vcsTarget: "vcs_target",
   edgeWeight: "edge_weight",
+  rowWeight: "row_weight",
   subgraphWeight: "subgraph_weight",
   depthWeight: "depth_weight",
 } as const;
@@ -117,6 +121,7 @@ export const configFromPreset = (name: string): ThresholdConfig => {
   return {
     ...preset,
     edge_weight: VCS_WEIGHTS.edge,
+    row_weight: VCS_WEIGHTS.row,
     subgraph_weight: VCS_WEIGHTS.subgraph,
     depth_weight: VCS_WEIGHTS.depth,
     preset_name: canonical,
@@ -149,7 +154,7 @@ export interface ComplexityMetrics {
 const round2 = (x: number): number => Math.round(x * 100) / 100;
 const round4 = (x: number): number => Math.round(x * 10000) / 10000;
 
-// (nodes + edges*w_e + subgraphs*w_s) * (1 + depth*w_d). Edge density is
+// (nodes + edges*w_e + rows*w_r + 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.
 //
@@ -164,7 +169,7 @@ export const calculateComplexity = (stats: DiagramStats, config: ThresholdConfig
   const e = stats.edges;
   const s = stats.subgraphs;
   const d = Math.max(stats.max_subgraph_depth, stats.max_tree_depth);
-  const base = n + e * config.edge_weight + s * config.subgraph_weight;
+  const base = n + e * config.edge_weight + stats.rows * config.row_weight + s * config.subgraph_weight;
   const vcs = base * (1 + d * config.depth_weight);
   const maxEdges = n > 1 ? n * (n - 1) : 0;
   return {

package/src/parse/stats.ts

@@ -5,6 +5,7 @@
 // diagram is measured the way mermaid itself reads it.
 
 import { parse as langiumParse } from "@mermaid-js/parser";
+import Color from "colorjs.io";
 import { Window } from "happy-dom";
 
 // mermaid core registers DOMPurify hooks while its grammars run, and DOMPurify
@@ -22,6 +23,31 @@ const installDomShim = (): void => {
   g.DocumentFragment = win.DocumentFragment;
   g.NodeFilter = win.NodeFilter;
   g.getComputedStyle = win.getComputedStyle.bind(win);
+  // happy-dom's CSS.supports("color", v) is true for any word, where a browser
+  // checks that v is a colour. Mermaid asks it to split `box Shop` into a fill
+  // and a title, so the shim's answer gave every one-word box title away as
+  // its fill. A colour is whatever colorjs.io can parse, as in color.ts.
+  // happy-dom builds a fresh CSS object on each read, so the window's CSS is
+  // replaced by one fixed object that carries the corrected check.
+  const css = (win as unknown as { CSS?: { supports: (p: string, v?: string) => boolean } }).CSS;
+  if (css) {
+    const supports = css.supports.bind(css);
+    const fixed = {
+      ...css,
+      supports: (property: string, value?: string): boolean =>
+        property === "color" && value !== undefined ? isCssColour(value) : supports(property, value),
+    };
+    Object.defineProperty(win, "CSS", { value: fixed, configurable: true });
+  }
+};
+
+const isCssColour = (value: string): boolean => {
+  try {
+    new Color(value);
+    return true;
+  } catch {
+    return false;
+  }
 };
 
 let mermaidCore: typeof import("mermaid").default | null = null;
@@ -58,6 +84,11 @@ export interface DiagramStats {
   // kept apart from max_subgraph_depth and the nesting rule never reads it.
   // It is 0 for every other type.
   max_tree_depth: number;
+  // The rows drawn inside a node: an erDiagram entity's attributes, and a
+  // classDiagram class's attributes and methods. A row is text to read, but it
+  // sits in a box the reader has already found, so it is not a node. It is 0
+  // for every other type.
+  rows: number;
   node_ids: string[];
   subgraph_names: string[];
   // The parser that read the diagram, or, on a failure, the one whose reason
@@ -167,6 +198,7 @@ export async function extractStats(content: string): Promise<MermaidStats> {
     subgraphs: 0,
     max_subgraph_depth: 0,
     max_tree_depth: 0,
+    rows: 0,
     node_ids: [],
     subgraph_names: [],
     parser_used: langium ? "langium" : "mermaid-core",
@@ -233,6 +265,7 @@ async function extractLangiumStats(content: string, keyword: string): Promise<Me
     subgraphs: subgraphNames.length,
     max_subgraph_depth: maxDepth,
     max_tree_depth: treeDepth,
+    rows: 0,
     node_ids: [...new Set(nodeIds.filter(Boolean))].sort(),
     subgraph_names: subgraphNames,
     parser_used: "langium",
@@ -395,6 +428,8 @@ interface Structure {
   maxDepth: number;
   // Set only by the tree-shaped types: see max_tree_depth.
   treeDepth?: number;
+  // Set only by the types that draw rows inside a node: see rows.
+  rows?: number;
 }
 type CoreAdapter = (db: AnyDb) => Structure;
 
@@ -417,7 +452,7 @@ 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, treeDepth = 0 } = adapter(diagram.db);
+  const { nodeIds, edges, subgraphNames, maxDepth, treeDepth = 0, rows = 0 } = adapter(diagram.db);
 
   return {
     nodes: nodeIds.length,
@@ -425,6 +460,7 @@ async function extractCoreStats(content: string, keyword: string): Promise<Merma
     subgraphs: subgraphNames.length,
     max_subgraph_depth: maxDepth,
     max_tree_depth: treeDepth,
+    rows,
     node_ids: [...nodeIds].sort(),
     subgraph_names: subgraphNames,
     parser_used: "mermaid-core",
@@ -491,30 +527,88 @@ function adaptFlowchart(db: AnyDb): Structure {
   };
 }
 
+const lengthOf = (x: unknown): number => (Array.isArray(x) ? x.length : 0);
+
 function adaptClass(db: AnyDb): Structure {
   // classDb exposes data on direct properties: db.classes (Map), db.relations (Array).
-  const classes = (db.classes instanceof Map ? db.classes : new Map()) as Map<string, unknown>;
+  const classes = (db.classes instanceof Map ? db.classes : new Map()) as Map<
+    string,
+    { members?: unknown; methods?: unknown }
+  >;
   const relations = (Array.isArray(db.relations) ? db.relations : []) as Array<unknown>;
-  return { nodeIds: [...classes.keys()], edges: relations.length, subgraphNames: [], maxDepth: 0 };
+  // Each namespace draws a box, and one may sit inside another through parent.
+  const namespaces = (db.namespaces instanceof Map ? db.namespaces : new Map()) as Map<
+    string,
+    { label?: string; parent?: string }
+  >;
+  const groups = [...namespaces].map(([id, ns]) => ({ id, in: ns.parent, label: ns.label || id }));
+  let rows = 0;
+  for (const c of classes.values()) rows += lengthOf(c.members) + lengthOf(c.methods);
+  return {
+    nodeIds: [...classes.keys()],
+    edges: relations.length,
+    subgraphNames: groups.map((g) => g.label),
+    maxDepth: architectureDepth(groups),
+    rows,
+  };
 }
 
+interface SequenceRecord {
+  type?: number;
+  from?: unknown;
+  to?: unknown;
+  message?: unknown;
+}
 interface SequenceState {
   records?: {
     actors?: Map<string, unknown>;
     messages?: Array<unknown>;
+    boxes?: Array<{ name?: string }>;
   };
 }
+// Mermaid's sequence LINETYPE codes. Its messages list holds every statement in
+// order: a message, but also a note, an activation and each line that opens,
+// divides or closes a block. A block opens with one code, may be divided
+// (else, and, option), and closes with another. A par_over block closes with
+// PAR_END, like par.
+const SEQ_NOTE = 2;
+// loop, alt, opt, par, critical, break, par_over. A `rect` (22, 23) is left
+// out: it tints the background behind its messages, with no title or border,
+// so it is a highlight rather than a boundary to track.
+export const SEQUENCE_BLOCK_OPEN: ReadonlySet<number> = new Set([10, 12, 15, 19, 27, 30, 32]);
+export const SEQUENCE_BLOCK_CLOSE: ReadonlySet<number> = new Set([11, 14, 16, 21, 29, 31]);
+
+// A message runs from one participant to another (or itself). A note also
+// names both, so it is told apart by its code, and an activation names only one.
+export const isSequenceMessage = (m: SequenceRecord): boolean =>
+  m.type !== SEQ_NOTE && typeof m.from === "string" && typeof m.to === "string";
+
 function adaptSequence(db: AnyDb): Structure {
-  // sequenceDb stores state under db.state.records.{actors,messages}.
+  // sequenceDb stores state under db.state.records.{actors,messages,boxes}.
   const state = (db.state as SequenceState | undefined)?.records;
   const actors = state?.actors instanceof Map ? state.actors : new Map<string, unknown>();
   const rawMessages = state?.messages;
-  const messages = Array.isArray(rawMessages) ? rawMessages : [];
+  const records = (Array.isArray(rawMessages) ? rawMessages : []) as SequenceRecord[];
+  const boxes = Array.isArray(state?.boxes) ? state.boxes : [];
+  // A box groups participants and a block frames messages: both are drawn as
+  // a labelled boundary. Boxes cannot nest, and blocks nest inside each other.
+  const subgraphNames = boxes.map((b, i) => b.name || `box_${i}`);
+  let depth = 0;
+  let maxBlockDepth = 0;
+  for (const r of records) {
+    if (r.type !== undefined && SEQUENCE_BLOCK_OPEN.has(r.type)) {
+      depth++;
+      maxBlockDepth = Math.max(maxBlockDepth, depth);
+      subgraphNames.push(typeof r.message === "string" && r.message ? r.message : `block_${subgraphNames.length}`);
+    } else if (r.type !== undefined && SEQUENCE_BLOCK_CLOSE.has(r.type)) {
+      depth = Math.max(0, depth - 1);
+    }
+  }
   return {
     nodeIds: [...actors.keys()],
-    edges: messages.length,
-    subgraphNames: [],
-    maxDepth: 0,
+    edges: records.filter(isSequenceMessage).length,
+    subgraphNames,
+    maxDepth: Math.max(boxes.length > 0 ? 1 : 0, maxBlockDepth),
   };
 }
 
@@ -572,13 +666,16 @@ function adaptC4(db: AnyDb): Structure {
 function adaptEr(db: AnyDb): Structure {
   // ER db exposes data on direct properties. entities is a Map keyed on
   // entity name (CAR, NAMED-DRIVER); relationships is an Array.
-  const entities = db.entities instanceof Map ? db.entities : new Map<string, unknown>();
+  const entities = (db.entities instanceof Map ? db.entities : new Map()) as Map<string, { attributes?: unknown }>;
   const relationships = (Array.isArray(db.relationships) ? db.relationships : []) as Array<unknown>;
+  let rows = 0;
+  for (const e of entities.values()) rows += lengthOf(e.attributes);
   return {
     nodeIds: [...entities.keys()],
     edges: relationships.length,
     subgraphNames: [],
     maxDepth: 0,
+    rows,
   };
 }
 
@@ -713,21 +810,42 @@ function adaptSankey(db: AnyDb): Structure {
 interface StateNode {
   id?: string;
   type?: string;
+  shape?: string;
   isGroup?: boolean;
   parentId?: string;
 }
 interface StateEdge {
-  id1?: string;
-  id2?: string;
-}
+  start?: string;
+  end?: string;
+}
+// The shapes stateDb gives what is not a state: the start and end markers
+// ([*], one pair per composite state), and a note with the group mermaid wraps
+// it in. A marker only says where a path begins or ends, and a note is an
+// annotation, as notes are in every other type.
+const STATE_NOT_A_STATE = new Set(["stateStart", "stateEnd", "note", "noteGroup"]);
+
+export const isCountedState = (n: { shape?: string }): boolean => !STATE_NOT_A_STATE.has(n.shape ?? "");
+
+// The states and transitions a stateDiagram draws, without markers or notes.
+// A transition into or out of a marker goes with it, as does a note's
+// connector. graph.ts draws the same set, so the two never disagree.
+export const countedStateElements = <N extends StateNode, E extends StateEdge>(
+  db: AnyDb,
+): { nodes: N[]; edges: E[] } => {
+  const all = (db.nodes as N[] | undefined) ?? [];
+  const nodes = all.filter(isCountedState);
+  const kept = new Set(nodes.map((n) => n.id ?? ""));
+  const edges = ((db.edges as E[] | undefined) ?? []).filter((e) => kept.has(e.start ?? "") && kept.has(e.end ?? ""));
+  return { nodes, edges };
+};
+
 // A composite state (`state A { ... }`) is a group that holds other states,
 // so it counts as a subgraph too, and its nesting depth is read from each
 // state's parentId chain. It stays a node as well, because it is drawn as a
 // labelled state.
 function adaptState(db: AnyDb): Structure {
   // stateDiagram db exposes data on direct properties.
-  const nodes = (db.nodes as StateNode[] | undefined) ?? [];
-  const edges = (db.edges as StateEdge[] | undefined) ?? [];
+  const { nodes, edges } = countedStateElements<StateNode, StateEdge>(db);
   const groups = nodes.filter((n) => n.isGroup === true);
   const parentOf = new Map(nodes.map((n) => [n.id ?? "", n.parentId]));
   let maxDepth = 0;

package/src/rules/shared.ts

@@ -35,6 +35,7 @@ export const COMPLEXITY_OPTIONS: OptionSpec = {
   nodeTarget: "number",
   vcsTarget: "number",
   edgeWeight: "number",
+  rowWeight: "number",
   subgraphWeight: "number",
   depthWeight: "number",
 };