@statelyai/graph 0.11.0 → 0.11.1

package/README.md

@@ -1,3 +1,7 @@
+---
+title: '@statelyai/graph'
+---
+
 # @statelyai/graph
 
 A TypeScript graph library built on plain JSON objects. Supports directed/undirected graphs, hierarchical nodes, graph algorithms, visual properties, and serialization to DOT, GraphML, Mermaid, and more.
@@ -12,6 +16,8 @@ npm install @statelyai/graph
 
 Optional peers are only needed for specific adapters:
 
+<!-- optional peer dependencies derived from package.json#peerDependencies -->
+
 | Package | Needed for |
 | --- | --- |
 | `fast-xml-parser` | `@statelyai/graph/gexf`, `@statelyai/graph/graphml` |
@@ -135,7 +141,9 @@ getEdgesByPort(graph, 'render', 'input'); // [e1]
 
 ## Algorithms
 
-Includes traversal (BFS, DFS), pathfinding (shortest path, simple paths, all-pairs shortest paths), centrality/link analysis (degree, closeness, betweenness, PageRank, HITS, eigenvector), community detection (label propagation, Girvan-Newman, greedy modularity, modularity scoring), cycle detection, connected/strongly-connected components, bridges, articulation points, biconnected components, isomorphism, topological sort, minimum spanning tree, and more. Many algorithms have lazy generator variants (`gen*`) for early exit.
+<!-- algorithm functions exported from src/algorithms.ts -->
+
+Includes traversal (BFS, DFS, preorder/postorder), pathfinding (shortest path, simple paths, all-pairs shortest paths, A*), centrality/link analysis (degree, closeness, betweenness, PageRank, HITS, eigenvector), community detection (label propagation, Girvan-Newman, greedy modularity, modularity scoring), cycle detection, connected/strongly-connected components, bridges, articulation points, biconnected components, isomorphism, topological sort, minimum spanning tree, and more. Many algorithms have lazy generator variants (`gen*`) for early exit.
 
 ```ts
 import {
@@ -203,7 +211,9 @@ const d3Data = toD3Graph(graph);             // D3.js { nodes, links }
 const imported = fromGEXF(gexfXmlString);    // GEXF (Gephi)
 ```
 
-**Supported formats:** Cytoscape.js JSON, D3.js JSON, JSON Graph Format, GEXF, GraphML, GML, TGF, DOT, Mermaid (flowchart, state, sequence, class, ER, mindmap, block), adjacency list, and edge list.
+<!-- supported format adapters derived from src/formats/* subdirectories -->
+
+**Supported formats:** Cytoscape.js JSON, D3.js JSON, JSON Graph Format, GEXF, GraphML, GML, TGF, DOT, Mermaid (flowchart, state, sequence, class, ER, mindmap, block, Ishikawa), ELK, xyflow, adjacency list, and edge list.
 
 Each bidirectional format also has a converter object:
 
@@ -218,19 +228,27 @@ Some formats have optional peer dependencies: `fast-xml-parser` (GEXF, GraphML)
 
 Format-specific docs live alongside the source:
 
+<!-- format README files under src/formats/*/README.md -->
+
+- [Adjacency list](./src/formats/adjacency-list/README.md)
+- [Cytoscape](./src/formats/cytoscape/README.md)
+- [D3](./src/formats/d3/README.md)
 - [DOT](./src/formats/dot/README.md)
-- [GraphML](./src/formats/graphml/README.md)
+- [Edge list](./src/formats/edge-list/README.md)
+- [ELK](./src/formats/elk/README.md)
 - [GEXF](./src/formats/gexf/README.md)
 - [GML](./src/formats/gml/README.md)
+- [GraphML](./src/formats/graphml/README.md)
 - [JGF](./src/formats/jgf/README.md)
-- [TGF](./src/formats/tgf/README.md)
-- [Cytoscape](./src/formats/cytoscape/README.md)
-- [D3](./src/formats/d3/README.md)
 - [Mermaid](./src/formats/mermaid/README.md)
+- [TGF](./src/formats/tgf/README.md)
+- [xyflow](./src/formats/xyflow/README.md)
 - [Converter helpers](./src/formats/converter/README.md)
 
 ## Examples
 
+<!-- runnable example files under examples/ -->
+
 The repo includes runnable examples under [`examples/`](./examples):
 
 - [Flow-based math](./examples/flow-based-math.ts) shows ports, topological ordering, and value propagation.
@@ -238,6 +256,8 @@ The repo includes runnable examples under [`examples/`](./examples):
 
 ## Development
 
+<!-- dev commands from package.json#scripts -->
+
 ```bash
 pnpm install
 pnpm verify

package/dist/format-support.mjs

@@ -240,6 +240,21 @@ const FORMAT_SUPPORT_MATRIX = [
 		},
 		notes: ["Index-based `linkStyle` metadata is fragile after graph mutation.", "Mermaid init directives are not fully preserved."]
 	},
+	{
+		id: "mermaid/ishikawa",
+		importPath: "@statelyai/graph/mermaid",
+		features: {
+			directed: "full",
+			undirected: "none",
+			hierarchy: "full",
+			ports: "none",
+			visual: "none",
+			style: "none",
+			weight: "none",
+			roundTrip: "partial"
+		},
+		notes: ["Indentation is preserved as hierarchy; renderer-specific fishbone layout is not represented."]
+	},
 	{
 		id: "mermaid/mindmap",
 		importPath: "@statelyai/graph/mermaid",

package/dist/formats/graphml/index.mjs

@@ -100,6 +100,24 @@ function toGraphML(graph) {
 			"@_for": "edge",
 			"@_attr.name": "weight",
 			"@_attr.type": "double"
+		},
+		{
+			"@_id": "ports",
+			"@_for": "node",
+			"@_attr.name": "ports",
+			"@_attr.type": "string"
+		},
+		{
+			"@_id": "sourcePort",
+			"@_for": "edge",
+			"@_attr.name": "sourcePort",
+			"@_attr.type": "string"
+		},
+		{
+			"@_id": "targetPort",
+			"@_for": "edge",
+			"@_attr.name": "targetPort",
+			"@_attr.type": "string"
 		}
 	];
 	const nodes = graph.nodes.map((node) => {
@@ -148,6 +166,10 @@ function toGraphML(graph) {
 			"@_key": "color",
 			"#text": node.color
 		});
+		if (node.ports !== void 0) data.push({
+			"@_key": "ports",
+			"#text": JSON.stringify(node.ports)
+		});
 		return {
 			"@_id": node.id,
 			...data.length > 0 && { data }
@@ -191,6 +213,14 @@ function toGraphML(graph) {
 			"@_key": "weight",
 			"#text": edge.weight
 		});
+		if (edge.sourcePort !== void 0) data.push({
+			"@_key": "sourcePort",
+			"#text": edge.sourcePort
+		});
+		if (edge.targetPort !== void 0) data.push({
+			"@_key": "targetPort",
+			"#text": edge.targetPort
+		});
 		return {
 			"@_id": edge.id,
 			"@_source": edge.sourceId,
@@ -279,6 +309,7 @@ function fromGraphML(xml) {
 		if (dataMap.shape !== void 0) node.shape = dataMap.shape;
 		if (dataMap.color !== void 0) node.color = dataMap.color;
 		if (dataMap.style !== void 0) node.style = tryParseJSON(dataMap.style);
+		if (dataMap.ports !== void 0) node.ports = tryParseJSON(dataMap.ports);
 		return node;
 	});
 	const edges = asArray(graphEl.edge).map((edgeEl) => {
@@ -298,6 +329,8 @@ function fromGraphML(xml) {
 		if (dataMap.height !== void 0) edge.height = parseNumber(dataMap.height);
 		if (dataMap.color !== void 0) edge.color = dataMap.color;
 		if (dataMap.style !== void 0) edge.style = tryParseJSON(dataMap.style);
+		if (dataMap.sourcePort !== void 0) edge.sourcePort = dataMap.sourcePort;
+		if (dataMap.targetPort !== void 0) edge.targetPort = dataMap.targetPort;
 		return edge;
 	});
 	const graph = {

package/dist/formats/mermaid/index.d.mts

@@ -19,8 +19,10 @@ interface SequenceNodeData {
 interface SequenceEdgeData {
   kind: 'message' | 'activation' | 'deactivation';
   stroke?: 'solid' | 'dotted';
-  arrowType?: 'filled' | 'open' | 'cross' | 'async';
+  arrowType?: 'filled' | 'open' | 'cross' | 'async' | 'half-top' | 'half-bottom' | 'half-reverse-top' | 'half-reverse-bottom' | 'stick-half-top' | 'stick-half-bottom' | 'stick-half-reverse-top' | 'stick-half-reverse-bottom';
   bidirectional?: boolean;
+  centralSource?: boolean;
+  centralTarget?: boolean;
   sequenceNumber?: number;
 }
 /**
@@ -396,4 +398,46 @@ declare function toMermaidBlock(graph: MermaidBlockGraph): string;
  */
 declare const mermaidBlockConverter: GraphFormatConverter<string, BlockNodeData, BlockEdgeData, BlockGraphData>;
 //#endregion
-export { type BlockEdgeData, type BlockGraphData, type BlockNodeData, type ClassEdgeData, type ClassGraphData, type ClassNodeData, type EREdgeData, type ERGraphData, type ERNodeData, type FlowchartEdgeData, type FlowchartGraphData, type FlowchartNodeData, type MermaidBlockGraph, type MermaidClassGraph, type MermaidERGraph, type MermaidFlowchartGraph, type MermaidMindmapGraph, type MermaidSequenceGraph, type MermaidStateGraph, type MindmapEdgeData, type MindmapGraphData, type MindmapNodeData, type SequenceBlock, type SequenceEdgeData, type SequenceGraphData, type SequenceNodeData, type StateEdgeData, type StateGraphData, type StateNodeData, fromMermaidBlock, fromMermaidClass, fromMermaidER, fromMermaidFlowchart, fromMermaidMindmap, fromMermaidSequence, fromMermaidState, mermaidBlockConverter, mermaidClassConverter, mermaidERConverter, mermaidFlowchartConverter, mermaidMindmapConverter, mermaidSequenceConverter, mermaidStateConverter, toMermaidBlock, toMermaidClass, toMermaidER, toMermaidFlowchart, toMermaidMindmap, toMermaidSequence, toMermaidState };
+//#region src/formats/mermaid/ishikawa.d.ts
+interface IshikawaNodeData {
+  kind: 'effect' | 'cause';
+}
+interface IshikawaEdgeData {}
+interface IshikawaGraphData {
+  diagramType: 'ishikawa';
+}
+type MermaidIshikawaGraph = Graph<IshikawaNodeData, IshikawaEdgeData, IshikawaGraphData>;
+/**
+ * Parses a Mermaid Ishikawa diagram string into a Graph.
+ *
+ * @example
+ * const graph = fromMermaidIshikawa(`
+ * ishikawa-beta
+ * Problem
+ *     Cause
+ *         Sub-cause
+ * `);
+ */
+declare function fromMermaidIshikawa(input: string): MermaidIshikawaGraph;
+/**
+ * Converts an Ishikawa Graph to a Mermaid Ishikawa diagram string.
+ *
+ * @example
+ * const mermaid = toMermaidIshikawa(graph);
+ * // "ishikawa-beta\nProblem\n    Cause"
+ */
+declare function toMermaidIshikawa(graph: MermaidIshikawaGraph): string;
+/**
+ * Bidirectional converter for Mermaid Ishikawa diagram format.
+ *
+ * @example
+ * const graph = mermaidIshikawaConverter.from(`
+ * ishikawa-beta
+ * Problem
+ *     Cause
+ * `);
+ * const str = mermaidIshikawaConverter.to(graph);
+ */
+declare const mermaidIshikawaConverter: GraphFormatConverter<string, IshikawaNodeData, IshikawaEdgeData, IshikawaGraphData>;
+//#endregion
+export { type BlockEdgeData, type BlockGraphData, type BlockNodeData, type ClassEdgeData, type ClassGraphData, type ClassNodeData, type EREdgeData, type ERGraphData, type ERNodeData, type FlowchartEdgeData, type FlowchartGraphData, type FlowchartNodeData, type IshikawaEdgeData, type IshikawaGraphData, type IshikawaNodeData, type MermaidBlockGraph, type MermaidClassGraph, type MermaidERGraph, type MermaidFlowchartGraph, type MermaidIshikawaGraph, type MermaidMindmapGraph, type MermaidSequenceGraph, type MermaidStateGraph, type MindmapEdgeData, type MindmapGraphData, type MindmapNodeData, type SequenceBlock, type SequenceEdgeData, type SequenceGraphData, type SequenceNodeData, type StateEdgeData, type StateGraphData, type StateNodeData, fromMermaidBlock, fromMermaidClass, fromMermaidER, fromMermaidFlowchart, fromMermaidIshikawa, fromMermaidMindmap, fromMermaidSequence, fromMermaidState, mermaidBlockConverter, mermaidClassConverter, mermaidERConverter, mermaidFlowchartConverter, mermaidIshikawaConverter, mermaidMindmapConverter, mermaidSequenceConverter, mermaidStateConverter, toMermaidBlock, toMermaidClass, toMermaidER, toMermaidFlowchart, toMermaidIshikawa, toMermaidMindmap, toMermaidSequence, toMermaidState };

package/dist/formats/mermaid/index.mjs

@@ -98,6 +98,46 @@ const ARROW_PATTERNS = [
 		arrowType: "async",
 		bidirectional: false
 	}],
+	["--|\\", {
+		stroke: "dotted",
+		arrowType: "half-top",
+		bidirectional: false
+	}],
+	["--|/", {
+		stroke: "dotted",
+		arrowType: "half-bottom",
+		bidirectional: false
+	}],
+	["/|--", {
+		stroke: "dotted",
+		arrowType: "half-reverse-top",
+		bidirectional: false
+	}],
+	["\\|--", {
+		stroke: "dotted",
+		arrowType: "half-reverse-bottom",
+		bidirectional: false
+	}],
+	["--\\\\", {
+		stroke: "dotted",
+		arrowType: "stick-half-top",
+		bidirectional: false
+	}],
+	["--//", {
+		stroke: "dotted",
+		arrowType: "stick-half-bottom",
+		bidirectional: false
+	}],
+	["//--", {
+		stroke: "dotted",
+		arrowType: "stick-half-reverse-top",
+		bidirectional: false
+	}],
+	["\\\\--", {
+		stroke: "dotted",
+		arrowType: "stick-half-reverse-bottom",
+		bidirectional: false
+	}],
 	["->>", {
 		stroke: "solid",
 		arrowType: "filled",
@@ -117,12 +157,56 @@ const ARROW_PATTERNS = [
 		stroke: "solid",
 		arrowType: "async",
 		bidirectional: false
+	}],
+	["-|\\", {
+		stroke: "solid",
+		arrowType: "half-top",
+		bidirectional: false
+	}],
+	["-|/", {
+		stroke: "solid",
+		arrowType: "half-bottom",
+		bidirectional: false
+	}],
+	["/|-", {
+		stroke: "solid",
+		arrowType: "half-reverse-top",
+		bidirectional: false
+	}],
+	["\\|-", {
+		stroke: "solid",
+		arrowType: "half-reverse-bottom",
+		bidirectional: false
+	}],
+	["-\\\\", {
+		stroke: "solid",
+		arrowType: "stick-half-top",
+		bidirectional: false
+	}],
+	["-//", {
+		stroke: "solid",
+		arrowType: "stick-half-bottom",
+		bidirectional: false
+	}],
+	["//-", {
+		stroke: "solid",
+		arrowType: "stick-half-reverse-top",
+		bidirectional: false
+	}],
+	["\\\\-", {
+		stroke: "solid",
+		arrowType: "stick-half-reverse-bottom",
+		bidirectional: false
 	}]
 ];
-function parseArrow(arrow) {
+function getEscapedRegExp(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getParsedArrow(arrow) {
 	for (const [pattern, info] of ARROW_PATTERNS) if (arrow === pattern) return info;
 }
-const MESSAGE_RE = /^(\S+?)\s*(<<-->>|<<->>|-->>|-->|--x|--\)|->>|->|-x|-\))\s*(\S+?)\s*:\s*(.*)$/;
+const ARROW_PATTERN_SOURCE = ARROW_PATTERNS.map(([pattern]) => getEscapedRegExp(pattern)).join("|");
+const MESSAGE_RE = /* @__PURE__ */ new RegExp(`^(\\S+?)\\s*(${ARROW_PATTERN_SOURCE})(\\(\\))?\\s*(\\S+?)\\s*:\\s*(.*)$`);
 /**
 * Parses a Mermaid sequence diagram string into a Graph.
 *
@@ -346,8 +430,14 @@ function fromMermaidSequence(input) {
 		if (msgMatch) {
 			let sourceId = msgMatch[1];
 			const arrowStr = msgMatch[2];
-			let targetId = msgMatch[3];
-			const messageText = msgMatch[4].trim();
+			const centralTarget = msgMatch[3] === "()";
+			let targetId = msgMatch[4];
+			const messageText = msgMatch[5].trim();
+			let centralSource = false;
+			if (sourceId.endsWith("()")) {
+				centralSource = true;
+				sourceId = sourceId.slice(0, -2);
+			}
 			let activationOnTarget = null;
 			if (targetId.startsWith("+")) {
 				activationOnTarget = "activation";
@@ -366,7 +456,7 @@ function fromMermaidSequence(input) {
 			}
 			ensureNode(sourceId);
 			ensureNode(targetId);
-			const arrowInfo = parseArrow(arrowStr);
+			const arrowInfo = getParsedArrow(arrowStr);
 			if (!arrowInfo) continue;
 			const edgeId = generateEdgeId(sourceId, targetId, edgeCounter++);
 			const data = {
@@ -374,6 +464,8 @@ function fromMermaidSequence(input) {
 				stroke: arrowInfo.stroke,
 				arrowType: arrowInfo.arrowType,
 				...arrowInfo.bidirectional && { bidirectional: true },
+				...centralSource && { centralSource: true },
+				...centralTarget && { centralTarget: true },
 				...autonumber && { sequenceNumber: ++seqNum }
 			};
 			addEdge({
@@ -464,13 +556,29 @@ const ARROW_MAP = {
 		open: "->",
 		filled: "->>",
 		cross: "-x",
-		async: "-)"
+		async: "-)",
+		"half-top": "-|\\",
+		"half-bottom": "-|/",
+		"half-reverse-top": "/|-",
+		"half-reverse-bottom": "\\|-",
+		"stick-half-top": "-\\\\",
+		"stick-half-bottom": "-//",
+		"stick-half-reverse-top": "//-",
+		"stick-half-reverse-bottom": "\\\\-"
 	},
 	dotted: {
 		open: "-->",
 		filled: "-->>",
 		cross: "--x",
-		async: "--)"
+		async: "--)",
+		"half-top": "--|\\",
+		"half-bottom": "--|/",
+		"half-reverse-top": "/|--",
+		"half-reverse-bottom": "\\|--",
+		"stick-half-top": "--\\\\",
+		"stick-half-bottom": "--//",
+		"stick-half-reverse-top": "//--",
+		"stick-half-reverse-bottom": "\\\\--"
 	}
 };
 /**
@@ -672,8 +780,9 @@ function toMermaidSequence(graph) {
 			let arrow;
 			if (d.bidirectional) arrow = stroke === "dotted" ? "<<-->>" : "<<->>";
 			else arrow = ARROW_MAP[stroke]?.[arrowType] ?? "->>";
+			if (d.centralTarget) arrow += "()";
 			const label = edge.label ? `: ${escapeMermaidLabel(edge.label)}` : ":";
-			lines.push(`${indent()}${edge.sourceId}${arrow}${edge.targetId}${label}`);
+			lines.push(`${indent()}${edge.sourceId}${d.centralSource ? "()" : ""}${arrow}${edge.targetId}${label}`);
 		}
 		const afters = afterEdge.get(edge.id);
 		if (afters) for (const _ev of afters) {
@@ -1987,12 +2096,14 @@ const mermaidClassConverter = createFormatConverter(toMermaidClass, fromMermaidC
 //#region src/formats/mermaid/er-diagram.ts
 const LEFT_CARDINALITY = {
 	"||": "one",
+	"1": "one",
 	"|o": "zero-or-one",
 	"}|": "one-or-more",
 	"}o": "zero-or-more"
 };
 const RIGHT_CARDINALITY = {
 	"||": "one",
+	"1": "one",
 	"o|": "zero-or-one",
 	"|{": "one-or-more",
 	"o{": "zero-or-more"
@@ -2009,25 +2120,18 @@ const CARDINALITY_TO_RIGHT = {
 	"one-or-more": "|{",
 	"zero-or-more": "o{"
 };
-function parseERRelationship(symbol) {
-	if (symbol.length < 6) return null;
-	const left = symbol.slice(0, 2);
-	const mid = symbol.slice(2, 4);
-	const right = symbol.slice(4, 6);
-	const srcCard = LEFT_CARDINALITY[left];
-	const tgtCard = RIGHT_CARDINALITY[right];
-	if (!srcCard || !tgtCard) return null;
-	let identifying;
-	if (mid === "--") identifying = true;
-	else if (mid === "..") identifying = false;
-	else return null;
-	return {
-		sourceCardinality: srcCard,
-		targetCardinality: tgtCard,
-		identifying
-	};
+function getParsedERRelationship(symbol) {
+	for (const left of Object.keys(LEFT_CARDINALITY).sort((a, b) => b.length - a.length)) for (const mid of ["--", ".."]) for (const right of Object.keys(RIGHT_CARDINALITY).sort((a, b) => b.length - a.length)) {
+		if (symbol !== `${left}${mid}${right}`) continue;
+		return {
+			sourceCardinality: LEFT_CARDINALITY[left],
+			targetCardinality: RIGHT_CARDINALITY[right],
+			identifying: mid === "--"
+		};
+	}
+	return null;
 }
-const ER_LINE_RE = /^(\S+)\s+([|}{o.][|}{o.][-.][-.][|}{o.][|}{o.])\s+(\S+)\s*:\s*"?([^"]*)"?\s*$/;
+const ER_LINE_RE = /^(\S+)\s+([|}{o1.]{1,2}[-.][-.][|}{o1.]{1,2})\s+(\S+)\s*:\s*"?([^"]*)"?\s*$/;
 /**
 * Parses a Mermaid ER diagram string into a Graph.
 *
@@ -2099,7 +2203,7 @@ function fromMermaidER(input) {
 			const label = relMatch[4].trim();
 			ensureNode(leftEntity);
 			ensureNode(rightEntity);
-			const rel = parseERRelationship(symbol);
+			const rel = getParsedERRelationship(symbol);
 			if (rel) {
 				const edgeId = generateEdgeId(leftEntity, rightEntity, edgeCounter++);
 				edges.push({
@@ -2532,4 +2636,105 @@ function toMermaidBlock(graph) {
 const mermaidBlockConverter = createFormatConverter(toMermaidBlock, fromMermaidBlock);
 
 //#endregion
-export { fromMermaidBlock, fromMermaidClass, fromMermaidER, fromMermaidFlowchart, fromMermaidMindmap, fromMermaidSequence, fromMermaidState, mermaidBlockConverter, mermaidClassConverter, mermaidERConverter, mermaidFlowchartConverter, mermaidMindmapConverter, mermaidSequenceConverter, mermaidStateConverter, toMermaidBlock, toMermaidClass, toMermaidER, toMermaidFlowchart, toMermaidMindmap, toMermaidSequence, toMermaidState };
+//#region src/formats/mermaid/ishikawa.ts
+/**
+* Parses a Mermaid Ishikawa diagram string into a Graph.
+*
+* @example
+* const graph = fromMermaidIshikawa(`
+* ishikawa-beta
+* Problem
+*     Cause
+*         Sub-cause
+* `);
+*/
+function fromMermaidIshikawa(input) {
+	validateInput(input, "Mermaid Ishikawa");
+	const { lines } = prepareLines(input);
+	const header = lines[0]?.trim();
+	if (!header || !header.startsWith("ishikawa-beta")) throw new Error("Mermaid Ishikawa: expected \"ishikawa-beta\" header");
+	const nodes = [];
+	const edges = [];
+	const stack = [];
+	let nodeCounter = 0;
+	let edgeCounter = 0;
+	for (let i = 1; i < lines.length; i++) {
+		const rawLine = lines[i];
+		if (!rawLine.trim()) continue;
+		const indent = rawLine.length - rawLine.trimStart().length;
+		const label = rawLine.trim();
+		const id = `ish_${nodeCounter++}`;
+		while (stack.length > 0 && stack[stack.length - 1].indent >= indent) stack.pop();
+		const parent = stack[stack.length - 1];
+		const node = {
+			type: "node",
+			id,
+			parentId: parent?.id ?? null,
+			initialNodeId: null,
+			label,
+			data: { kind: parent ? "cause" : "effect" }
+		};
+		if (parent) edges.push({
+			type: "edge",
+			id: generateEdgeId(parent.id, id, edgeCounter++),
+			sourceId: parent.id,
+			targetId: id,
+			label: "",
+			data: {}
+		});
+		nodes.push(node);
+		stack.push({
+			id,
+			indent
+		});
+	}
+	return {
+		id: "",
+		type: "directed",
+		initialNodeId: null,
+		nodes,
+		edges,
+		data: { diagramType: "ishikawa" }
+	};
+}
+/**
+* Converts an Ishikawa Graph to a Mermaid Ishikawa diagram string.
+*
+* @example
+* const mermaid = toMermaidIshikawa(graph);
+* // "ishikawa-beta\nProblem\n    Cause"
+*/
+function toMermaidIshikawa(graph) {
+	const lines = ["ishikawa-beta"];
+	const childrenMap = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		const parentId = node.parentId ?? null;
+		const children = childrenMap.get(parentId) ?? [];
+		children.push(node);
+		childrenMap.set(parentId, children);
+	}
+	const addIshikawaNodes = (parentId, depth) => {
+		for (const node of childrenMap.get(parentId) ?? []) {
+			const indent = "    ".repeat(depth);
+			lines.push(`${indent}${escapeMermaidLabel(node.label ?? node.id)}`);
+			addIshikawaNodes(node.id, depth + 1);
+		}
+	};
+	addIshikawaNodes(null, 0);
+	return lines.join("\n");
+}
+/**
+* Bidirectional converter for Mermaid Ishikawa diagram format.
+*
+* @example
+* const graph = mermaidIshikawaConverter.from(`
+* ishikawa-beta
+* Problem
+*     Cause
+* `);
+* const str = mermaidIshikawaConverter.to(graph);
+*/
+const mermaidIshikawaConverter = createFormatConverter(toMermaidIshikawa, fromMermaidIshikawa);
+
+//#endregion
+export { fromMermaidBlock, fromMermaidClass, fromMermaidER, fromMermaidFlowchart, fromMermaidIshikawa, fromMermaidMindmap, fromMermaidSequence, fromMermaidState, mermaidBlockConverter, mermaidClassConverter, mermaidERConverter, mermaidFlowchartConverter, mermaidIshikawaConverter, mermaidMindmapConverter, mermaidSequenceConverter, mermaidStateConverter, toMermaidBlock, toMermaidClass, toMermaidER, toMermaidFlowchart, toMermaidIshikawa, toMermaidMindmap, toMermaidSequence, toMermaidState };

package/dist/schemas.d.mts

@@ -21,7 +21,7 @@ declare const NodeSchema: z.ZodObject<{
   id: z.ZodString;
   parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
   initialNodeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-  label: z.ZodOptional<z.ZodString>;
+  label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
   data: z.ZodAny;
   x: z.ZodOptional<z.ZodNumber>;
   y: z.ZodOptional<z.ZodNumber>;
@@ -75,7 +75,7 @@ declare const GraphSchema: z.ZodObject<{
     id: z.ZodString;
     parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     initialNodeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    label: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     data: z.ZodAny;
     x: z.ZodOptional<z.ZodNumber>;
     y: z.ZodOptional<z.ZodNumber>;

package/dist/schemas.mjs

@@ -23,7 +23,7 @@ const NodeSchema = z.object({
 	id: z.string(),
 	parentId: z.string().nullable().optional(),
 	initialNodeId: z.string().nullable().optional(),
-	label: z.string().optional(),
+	label: z.string().nullable().optional(),
 	data: z.any(),
 	x: z.number().optional(),
 	y: z.number().optional(),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@statelyai/graph",
   "type": "module",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "A TypeScript-first graph library with plain JSON-serializable objects",
   "author": "David Khourshid <david@stately.ai>",
   "license": "MIT",
@@ -104,6 +104,7 @@
     "build": "tsdown",
     "bench": "vitest bench --run",
     "dev": "tsdown --watch",
+    "fix:generated": "pnpm generate-schema",
     "test": "vitest",
     "typecheck": "tsc --noEmit",
     "check:generated": "tsx scripts/generate-json-schema.ts --check",

package/schemas/graph.schema.json

@@ -55,7 +55,14 @@
             ]
           },
           "label": {
-            "type": "string"
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
           },
           "data": {},
           "x": {

package/schemas/node.schema.json

@@ -30,7 +30,14 @@
       ]
     },
     "label": {
-      "type": "string"
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "null"
+        }
+      ]
     },
     "data": {},
     "x": {