@statelyai/graph 0.9.0 → 0.11.0

package/dist/{algorithms-3xvCxHzo.mjs → algorithms-BHHg7lGq.mjs}

@@ -1,4 +1,4 @@
-import { a as indexUpdateEdgeEndpoints, i as indexReparentNode, n as indexAddEdge, o as invalidateIndex, r as indexAddNode, t as getIndex } from "./indexing-DyfgLuzw.mjs";
+import { a as indexUpdateEdgeEndpoints, i as indexReparentNode, n as indexAddEdge, o as invalidateIndex, r as indexAddNode, t as getIndex } from "./indexing-CJc-ul8e.mjs";
 
 //#region src/graph.ts
 /**
@@ -49,7 +49,7 @@ function createGraphNode(config) {
 		id: config.id,
 		...config.parentId !== void 0 && { parentId: config.parentId ?? null },
 		...config.initialNodeId !== void 0 && { initialNodeId: config.initialNodeId ?? null },
-		label: config.label ?? "",
+		label: config.label ?? null,
 		data: config.data
 	};
 	if (config.ports !== void 0 && config.ports.length > 0) {
@@ -650,893 +650,691 @@ function collectDescendants(graph, id) {
 }
 
 //#endregion
-//#region src/algorithms/centrality.ts
-function getNodeIds(graph) {
-	return graph.nodes.map((node) => node.id);
-}
-function getNeighborIds$1(graph, nodeId) {
-	const idx = getIndex(graph);
-	const neighbors = [];
-	for (const edgeId of idx.outEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) neighbors.push(graph.edges[edgeIndex].targetId);
+//#region src/algorithms/shared.ts
+var MinPriorityQueue = class {
+	items = [];
+	constructor(compare) {
+		this.compare = compare;
 	}
-	if (graph.type === "undirected") for (const edgeId of idx.inEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) neighbors.push(graph.edges[edgeIndex].sourceId);
+	get size() {
+		return this.items.length;
 	}
-	return neighbors;
-}
-function getIncomingIds(graph, nodeId) {
-	const idx = getIndex(graph);
-	const incoming = [];
-	for (const edgeId of idx.inEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) incoming.push(graph.edges[edgeIndex].sourceId);
+	push(item) {
+		this.items.push(item);
+		this.bubbleUp(this.items.length - 1);
 	}
-	if (graph.type === "undirected") for (const edgeId of idx.outEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) incoming.push(graph.edges[edgeIndex].targetId);
+	pop() {
+		if (this.items.length === 0) return void 0;
+		const first = this.items[0];
+		const last = this.items.pop();
+		if (this.items.length > 0) {
+			this.items[0] = last;
+			this.bubbleDown(0);
+		}
+		return first;
 	}
-	return incoming;
-}
-function createEmptyScoreMap(graph) {
-	return Object.fromEntries(graph.nodes.map((node) => [node.id, 0]));
-}
-function normalizeVector(scores) {
-	const magnitude = Math.sqrt(Object.values(scores).reduce((sum, value) => sum + value * value, 0));
-	if (magnitude === 0) return scores;
-	for (const key of Object.keys(scores)) scores[key] /= magnitude;
-	return scores;
-}
-function maxDiff(previous, next) {
-	let diff = 0;
-	for (const key of Object.keys(next)) diff = Math.max(diff, Math.abs((previous[key] ?? 0) - next[key]));
-	return diff;
-}
-function getReachableDistances(graph, startId) {
-	const distances = /* @__PURE__ */ new Map();
-	const queue = [startId];
-	distances.set(startId, 0);
-	while (queue.length > 0) {
-		const currentId = queue.shift();
-		const currentDistance = distances.get(currentId);
-		for (const neighborId of getNeighborIds$1(graph, currentId)) {
-			if (distances.has(neighborId)) continue;
-			distances.set(neighborId, currentDistance + 1);
-			queue.push(neighborId);
+	bubbleUp(index) {
+		let current = index;
+		while (current > 0) {
+			const parent = Math.floor((current - 1) / 2);
+			if (this.compare(this.items[current], this.items[parent]) >= 0) break;
+			[this.items[current], this.items[parent]] = [this.items[parent], this.items[current]];
+			current = parent;
 		}
 	}
-	return distances;
-}
-/**
-* Returns degree centrality scores for all nodes.
-*
-* Degree centrality is the node degree normalized by `n - 1`.
-*
-* @example
-* ```ts
-* const scores = getDegreeCentrality(graph);
-* console.log(scores.a); // 0.5
-* ```
-*/
-function getDegreeCentrality(graph) {
-	const scale = graph.nodes.length > 1 ? 1 / (graph.nodes.length - 1) : 0;
+	bubbleDown(index) {
+		let current = index;
+		while (true) {
+			const left = current * 2 + 1;
+			const right = left + 1;
+			let smallest = current;
+			if (left < this.items.length && this.compare(this.items[left], this.items[smallest]) < 0) smallest = left;
+			if (right < this.items.length && this.compare(this.items[right], this.items[smallest]) < 0) smallest = right;
+			if (smallest === current) break;
+			[this.items[current], this.items[smallest]] = [this.items[smallest], this.items[current]];
+			current = smallest;
+		}
+	}
+};
+function getNeighborIds$1(graph, nodeId) {
 	const idx = getIndex(graph);
-	const scores = createEmptyScoreMap(graph);
-	for (const node of graph.nodes) {
-		const outDegree = idx.outEdges.get(node.id)?.length ?? 0;
-		const inDegree = idx.inEdges.get(node.id)?.length ?? 0;
-		const degree = graph.type === "undirected" ? new Set([...idx.outEdges.get(node.id) ?? [], ...idx.inEdges.get(node.id) ?? []]).size : outDegree + inDegree;
-		scores[node.id] = degree * scale;
+	const ids = [];
+	for (const eid of idx.outEdges.get(nodeId) ?? []) {
+		const ai = idx.edgeById.get(eid);
+		if (ai !== void 0) ids.push(graph.edges[ai].targetId);
 	}
-	return scores;
+	if (graph.type === "undirected") for (const eid of idx.inEdges.get(nodeId) ?? []) {
+		const ai = idx.edgeById.get(eid);
+		if (ai !== void 0) ids.push(graph.edges[ai].sourceId);
+	}
+	return ids;
 }
-/**
-* Returns in-degree centrality scores for all nodes.
-*
-* In-degree centrality is the incoming degree normalized by `n - 1`.
-*/
-function getInDegreeCentrality(graph) {
-	const scale = graph.nodes.length > 1 ? 1 / (graph.nodes.length - 1) : 0;
+function getSuccessorIds(graph, nodeId) {
 	const idx = getIndex(graph);
-	const scores = createEmptyScoreMap(graph);
-	for (const node of graph.nodes) scores[node.id] = (idx.inEdges.get(node.id)?.length ?? 0) * scale;
-	return scores;
+	return (idx.outEdges.get(nodeId) ?? []).map((eid) => graph.edges[idx.edgeById.get(eid)].targetId);
 }
-/**
-* Returns out-degree centrality scores for all nodes.
-*
-* Out-degree centrality is the outgoing degree normalized by `n - 1`.
-*/
-function getOutDegreeCentrality(graph) {
-	const scale = graph.nodes.length > 1 ? 1 / (graph.nodes.length - 1) : 0;
-	const idx = getIndex(graph);
-	const scores = createEmptyScoreMap(graph);
-	for (const node of graph.nodes) scores[node.id] = (idx.outEdges.get(node.id)?.length ?? 0) * scale;
-	return scores;
+function resolveFrom(graph, opts) {
+	if (opts?.from) return opts.from;
+	if (graph.initialNodeId) return graph.initialNodeId;
+	const inDeg = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) inDeg.set(node.id, 0);
+	for (const edge of graph.edges) inDeg.set(edge.targetId, (inDeg.get(edge.targetId) ?? 0) + 1);
+	const roots = [...inDeg.entries()].filter(([, degree]) => degree === 0).map(([id]) => id);
+	if (roots.length === 1) return roots[0];
+	throw new Error("Cannot determine start node — provide opts.from or set graph.initialNodeId");
 }
-/**
-* Returns closeness centrality scores for all nodes.
-*
-* Distances are computed over unweighted shortest paths using the graph's
-* existing directed or undirected edge semantics.
-*/
-function getClosenessCentrality(graph) {
-	const scores = createEmptyScoreMap(graph);
-	const order = graph.nodes.length;
-	for (const node of graph.nodes) {
-		const distances = getReachableDistances(graph, node.id);
-		distances.delete(node.id);
-		if (distances.size === 0) continue;
-		const totalDistance = [...distances.values()].reduce((sum, distance) => sum + distance, 0);
-		if (totalDistance === 0) continue;
-		const reachable = distances.size;
-		const closeness = reachable / totalDistance;
-		scores[node.id] = order > 1 ? closeness * (reachable / (order - 1)) : closeness;
+function getNeighborEdges(graph, nodeId) {
+	const idx = getIndex(graph);
+	const result = [];
+	for (const eid of idx.outEdges.get(nodeId) ?? []) {
+		const ai = idx.edgeById.get(eid);
+		if (ai !== void 0) {
+			const edge = graph.edges[ai];
+			result.push({
+				neighborId: edge.targetId,
+				edge
+			});
+		}
 	}
-	return scores;
+	if (graph.type === "undirected") for (const eid of idx.inEdges.get(nodeId) ?? []) {
+		const ai = idx.edgeById.get(eid);
+		if (ai !== void 0) {
+			const edge = graph.edges[ai];
+			result.push({
+				neighborId: edge.sourceId,
+				edge
+			});
+		}
+	}
+	return result;
 }
-/**
-* Returns betweenness centrality scores for all nodes.
-*
-* Uses Brandes' algorithm over unweighted shortest paths and returns
-* normalized scores.
-*/
-function getBetweennessCentrality(graph) {
-	const scores = createEmptyScoreMap(graph);
-	for (const source of graph.nodes) {
-		const stack = [];
-		const predecessors = /* @__PURE__ */ new Map();
-		const sigma = /* @__PURE__ */ new Map();
-		const distance = /* @__PURE__ */ new Map();
-		const queue = [source.id];
-		for (const node of graph.nodes) {
-			predecessors.set(node.id, []);
-			sigma.set(node.id, 0);
-			distance.set(node.id, -1);
+function getNeighborEdgesAll(graph, nodeId) {
+	const idx = getIndex(graph);
+	const result = [];
+	for (const eid of idx.outEdges.get(nodeId) ?? []) {
+		const ai = idx.edgeById.get(eid);
+		if (ai !== void 0) {
+			const edge = graph.edges[ai];
+			result.push({
+				neighborId: edge.targetId,
+				edge
+			});
 		}
-		sigma.set(source.id, 1);
-		distance.set(source.id, 0);
+	}
+	for (const eid of idx.inEdges.get(nodeId) ?? []) {
+		const ai = idx.edgeById.get(eid);
+		if (ai !== void 0) {
+			const edge = graph.edges[ai];
+			result.push({
+				neighborId: edge.sourceId,
+				edge
+			});
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/algorithms/paths.ts
+function computeShortestDistances(graph, sourceId, getWeight, algorithm) {
+	if (algorithm === "bellman-ford") return bellmanFord(graph, sourceId, getWeight);
+	const dist = /* @__PURE__ */ new Map();
+	const prev = /* @__PURE__ */ new Map();
+	dist.set(sourceId, 0);
+	prev.set(sourceId, []);
+	if (!getWeight && !graph.edges.some((edge) => edge.weight !== void 0)) {
+		const queue = [sourceId];
 		while (queue.length > 0) {
-			const currentId = queue.shift();
-			stack.push(currentId);
-			for (const neighborId of getNeighborIds$1(graph, currentId)) {
-				if (distance.get(neighborId) === -1) {
+			const id = queue.shift();
+			const distance = dist.get(id);
+			for (const { neighborId, edge } of getNeighborEdges(graph, id)) {
+				const nextDistance = distance + 1;
+				const existing = dist.get(neighborId);
+				if (existing === void 0) {
+					dist.set(neighborId, nextDistance);
+					prev.set(neighborId, [{
+						from: id,
+						edge
+					}]);
 					queue.push(neighborId);
-					distance.set(neighborId, distance.get(currentId) + 1);
-				}
-				if (distance.get(neighborId) === distance.get(currentId) + 1) {
-					sigma.set(neighborId, sigma.get(neighborId) + sigma.get(currentId));
-					predecessors.get(neighborId).push(currentId);
-				}
+				} else if (existing === nextDistance) prev.get(neighborId).push({
+					from: id,
+					edge
+				});
 			}
 		}
-		const delta = /* @__PURE__ */ new Map();
-		for (const node of graph.nodes) delta.set(node.id, 0);
-		while (stack.length > 0) {
-			const nodeId = stack.pop();
-			const sigmaNode = sigma.get(nodeId);
-			if (sigmaNode === 0) continue;
-			for (const predecessorId of predecessors.get(nodeId)) {
-				const contribution = sigma.get(predecessorId) / sigmaNode * (1 + delta.get(nodeId));
-				delta.set(predecessorId, delta.get(predecessorId) + contribution);
+	} else {
+		const effectiveWeight = getWeight ?? ((edge) => edge.weight ?? 1);
+		const visited = /* @__PURE__ */ new Set();
+		const pq = new MinPriorityQueue((a, b) => a.dist - b.dist);
+		pq.push({
+			id: sourceId,
+			dist: 0
+		});
+		while (pq.size > 0) {
+			const { id, dist: distance } = pq.pop();
+			if (visited.has(id) || distance !== dist.get(id)) continue;
+			visited.add(id);
+			for (const { neighborId, edge } of getNeighborEdges(graph, id)) {
+				const nextDistance = distance + effectiveWeight(edge);
+				const existing = dist.get(neighborId);
+				if (existing === void 0 || nextDistance < existing) {
+					dist.set(neighborId, nextDistance);
+					prev.set(neighborId, [{
+						from: id,
+						edge
+					}]);
+					pq.push({
+						id: neighborId,
+						dist: nextDistance
+					});
+				} else if (existing === nextDistance) prev.get(neighborId).push({
+					from: id,
+					edge
+				});
 			}
-			if (nodeId !== source.id) scores[nodeId] += delta.get(nodeId);
 		}
 	}
-	const order = graph.nodes.length;
-	if (order <= 2) return scores;
-	const scale = graph.type === "undirected" ? 1 / ((order - 1) * (order - 2) / 2) : 1 / ((order - 1) * (order - 2));
-	for (const nodeId of Object.keys(scores)) {
-		if (graph.type === "undirected") scores[nodeId] /= 2;
-		scores[nodeId] *= scale;
-	}
-	return scores;
+	return {
+		dist,
+		prev
+	};
 }
-/**
-* Returns PageRank scores for all nodes.
-*
-* Uses power iteration with damping factor `alpha`.
-*/
-function getPageRank(graph, options) {
-	const nodeIds = getNodeIds(graph);
-	if (nodeIds.length === 0) return {};
-	const alpha = options?.alpha ?? .85;
-	const maxIterations = options?.maxIterations ?? 100;
-	const tolerance = options?.tolerance ?? 1e-6;
-	let scores = Object.fromEntries(nodeIds.map((nodeId) => [nodeId, 1 / nodeIds.length]));
-	for (let iteration = 0; iteration < maxIterations; iteration++) {
-		const nextScores = Object.fromEntries(nodeIds.map((nodeId) => [nodeId, (1 - alpha) / nodeIds.length]));
-		let danglingMass = 0;
-		for (const nodeId of nodeIds) {
-			const neighbors = getNeighborIds$1(graph, nodeId);
-			if (neighbors.length === 0) {
-				danglingMass += scores[nodeId];
-				continue;
+function bellmanFord(graph, sourceId, getWeight) {
+	const dist = /* @__PURE__ */ new Map();
+	const prev = /* @__PURE__ */ new Map();
+	const effectiveWeight = getWeight ?? ((edge) => edge.weight ?? 1);
+	const isUndirected = graph.type === "undirected";
+	for (const node of graph.nodes) {
+		dist.set(node.id, Infinity);
+		prev.set(node.id, []);
+	}
+	dist.set(sourceId, 0);
+	const directedEdges = [];
+	for (const edge of graph.edges) {
+		directedEdges.push({
+			fromId: edge.sourceId,
+			toId: edge.targetId,
+			edge
+		});
+		if (isUndirected) directedEdges.push({
+			fromId: edge.targetId,
+			toId: edge.sourceId,
+			edge
+		});
+	}
+	for (let i = 0; i < graph.nodes.length - 1; i++) {
+		let changed = false;
+		for (const { fromId, toId, edge } of directedEdges) {
+			const distance = dist.get(fromId);
+			if (distance === Infinity) continue;
+			const nextDistance = distance + effectiveWeight(edge);
+			const existing = dist.get(toId);
+			if (nextDistance < existing) {
+				dist.set(toId, nextDistance);
+				prev.set(toId, [{
+					from: fromId,
+					edge
+				}]);
+				changed = true;
+			} else if (nextDistance === existing && existing !== Infinity) {
+				const predecessors = prev.get(toId);
+				if (!predecessors.some((entry) => entry.from === fromId && entry.edge === edge)) predecessors.push({
+					from: fromId,
+					edge
+				});
 			}
-			const share = scores[nodeId] / neighbors.length;
-			for (const neighborId of neighbors) nextScores[neighborId] += alpha * share;
-		}
-		if (danglingMass > 0) {
-			const share = alpha * danglingMass / nodeIds.length;
-			for (const nodeId of nodeIds) nextScores[nodeId] += share;
-		}
-		if (maxDiff(scores, nextScores) <= tolerance) {
-			scores = nextScores;
-			break;
 		}
-		scores = nextScores;
+		if (!changed) break;
 	}
-	const total = Object.values(scores).reduce((sum, value) => sum + value, 0);
-	if (total !== 0) for (const nodeId of nodeIds) scores[nodeId] /= total;
-	return scores;
-}
-/**
-* Returns HITS hub and authority scores for all nodes.
-*
-* Uses power iteration and L2 normalization per iteration.
-*/
-function getHITS(graph, options) {
-	const nodeIds = getNodeIds(graph);
-	if (nodeIds.length === 0) return {
-		hubs: {},
-		authorities: {}
-	};
-	const maxIterations = options?.maxIterations ?? 100;
-	const tolerance = options?.tolerance ?? 1e-6;
-	let hubs = Object.fromEntries(nodeIds.map((nodeId) => [nodeId, 1]));
-	let authorities = createEmptyScoreMap(graph);
-	for (let iteration = 0; iteration < maxIterations; iteration++) {
-		const nextAuthorities = createEmptyScoreMap(graph);
-		for (const nodeId of nodeIds) for (const predecessorId of getIncomingIds(graph, nodeId)) nextAuthorities[nodeId] += hubs[predecessorId];
-		normalizeVector(nextAuthorities);
-		const nextHubs = createEmptyScoreMap(graph);
-		for (const nodeId of nodeIds) for (const neighborId of getNeighborIds$1(graph, nodeId)) nextHubs[nodeId] += nextAuthorities[neighborId];
-		normalizeVector(nextHubs);
-		const hubDiff = maxDiff(hubs, nextHubs);
-		const authorityDiff = maxDiff(authorities, nextAuthorities);
-		hubs = nextHubs;
-		authorities = nextAuthorities;
-		if (Math.max(hubDiff, authorityDiff) <= tolerance) break;
+	for (const { fromId, toId, edge } of directedEdges) {
+		const distance = dist.get(fromId);
+		if (distance === Infinity) continue;
+		if (distance + effectiveWeight(edge) < dist.get(toId)) throw new Error("Graph contains a negative-weight cycle reachable from the source node");
+	}
+	for (const [id, distance] of dist) if (distance === Infinity) {
+		dist.delete(id);
+		prev.delete(id);
 	}
 	return {
-		hubs,
-		authorities
+		dist,
+		prev
 	};
 }
-/**
-* Returns eigenvector centrality scores for all nodes.
-*
-* Uses power iteration over incoming neighbors for directed graphs and
-* undirected adjacency for undirected graphs.
-*/
-function getEigenvectorCentrality(graph, options) {
-	const nodeIds = getNodeIds(graph);
-	if (nodeIds.length === 0) return {};
-	const maxIterations = options?.maxIterations ?? 100;
-	const tolerance = options?.tolerance ?? 1e-6;
-	let scores = Object.fromEntries(nodeIds.map((nodeId) => [nodeId, 1]));
-	normalizeVector(scores);
-	for (let iteration = 0; iteration < maxIterations; iteration++) {
-		const nextScores = createEmptyScoreMap(graph);
-		for (const nodeId of nodeIds) for (const predecessorId of getIncomingIds(graph, nodeId)) nextScores[nodeId] += scores[predecessorId];
-		normalizeVector(nextScores);
-		const diff = maxDiff(scores, nextScores);
-		scores = nextScores;
-		if (diff <= tolerance) break;
+function* reconstructPaths(graph, prev, sourceNode, targetId) {
+	if (targetId === sourceNode.id) {
+		yield {
+			source: sourceNode,
+			steps: []
+		};
+		return;
 	}
-	return scores;
+	const predecessors = prev.get(targetId);
+	if (!predecessors || predecessors.length === 0) return;
+	const targetNi = getIndex(graph).nodeById.get(targetId);
+	const targetNode = targetNi !== void 0 ? graph.nodes[targetNi] : graph.nodes.find((node) => node.id === targetId);
+	for (const { from, edge } of predecessors) for (const prefix of reconstructPaths(graph, prev, sourceNode, from)) yield {
+		source: sourceNode,
+		steps: [...prefix.steps, {
+			edge,
+			node: targetNode
+		}]
+	};
 }
-
-//#endregion
-//#region src/algorithms/community.ts
-function getUndirectedNeighbors$1(graph, nodeId) {
+function* genShortestPaths(graph, opts) {
 	const idx = getIndex(graph);
-	const neighbors = [];
-	for (const edgeId of idx.outEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) neighbors.push({
-			nodeId: graph.edges[edgeIndex].targetId,
-			edgeId
-		});
-	}
-	for (const edgeId of idx.inEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) neighbors.push({
-			nodeId: graph.edges[edgeIndex].sourceId,
-			edgeId
-		});
-	}
-	return neighbors;
+	const sourceId = resolveFrom(graph, opts);
+	const { dist, prev } = computeShortestDistances(graph, sourceId, opts?.getWeight, opts?.algorithm);
+	const targets = opts?.to ? [opts.to].filter((id) => dist.has(id)) : [...dist.keys()].filter((id) => id !== sourceId);
+	const sourceNi = idx.nodeById.get(sourceId);
+	const sourceNode = sourceNi !== void 0 ? graph.nodes[sourceNi] : graph.nodes.find((node) => node.id === sourceId);
+	for (const targetId of targets) yield* reconstructPaths(graph, prev, sourceNode, targetId);
 }
-function getUndirectedConnectedComponents(graph) {
+function getShortestPaths(graph, opts) {
+	return [...genShortestPaths(graph, opts)];
+}
+function getShortestPath(graph, opts) {
+	for (const path of genShortestPaths(graph, opts)) return path;
+}
+function getSimplePaths(graph, opts) {
+	return [...genSimplePaths(graph, opts)];
+}
+function* genSimplePaths(graph, opts) {
 	const idx = getIndex(graph);
+	const sourceId = resolveFrom(graph, opts);
+	const sourceNi = idx.nodeById.get(sourceId);
+	const sourceNode = sourceNi !== void 0 ? graph.nodes[sourceNi] : graph.nodes.find((node) => node.id === sourceId);
+	const targetId = opts?.to;
 	const visited = /* @__PURE__ */ new Set();
-	const communities = [];
-	for (const node of graph.nodes) {
-		if (visited.has(node.id)) continue;
-		const community = [];
-		const queue = [node.id];
-		visited.add(node.id);
-		while (queue.length > 0) {
-			const currentId = queue.shift();
-			const nodeIndex = idx.nodeById.get(currentId);
-			if (nodeIndex !== void 0) community.push(graph.nodes[nodeIndex]);
-			for (const neighbor of getUndirectedNeighbors$1(graph, currentId)) {
-				if (visited.has(neighbor.nodeId)) continue;
-				visited.add(neighbor.nodeId);
-				queue.push(neighbor.nodeId);
+	const currentSteps = [];
+	function* dfsCollect(nodeId) {
+		visited.add(nodeId);
+		if (targetId !== void 0) {
+			if (nodeId === targetId) {
+				yield {
+					source: sourceNode,
+					steps: [...currentSteps]
+				};
+				visited.delete(nodeId);
+				return;
 			}
+		} else if (currentSteps.length > 0) yield {
+			source: sourceNode,
+			steps: [...currentSteps]
+		};
+		for (const { neighborId, edge } of getNeighborEdges(graph, nodeId)) if (!visited.has(neighborId)) {
+			const neighborNi = idx.nodeById.get(neighborId);
+			const neighborNode = neighborNi !== void 0 ? graph.nodes[neighborNi] : graph.nodes.find((node) => node.id === neighborId);
+			currentSteps.push({
+				edge,
+				node: neighborNode
+			});
+			yield* dfsCollect(neighborId);
+			currentSteps.pop();
 		}
-		communities.push(community.sort((a, b) => a.id.localeCompare(b.id)));
+		visited.delete(nodeId);
 	}
-	return communities.sort((a, b) => a[0].id.localeCompare(b[0].id));
-}
-function getNodeMap(graph) {
-	return new Map(graph.nodes.map((node) => [node.id, node]));
+	yield* dfsCollect(sourceId);
 }
-function normalizeCommunities(graph, labels) {
-	const nodeMap = getNodeMap(graph);
-	const grouped = /* @__PURE__ */ new Map();
-	for (const [nodeId, label] of Object.entries(labels)) {
-		if (!grouped.has(label)) grouped.set(label, []);
-		const node = nodeMap.get(nodeId);
-		if (node) grouped.get(label).push(node);
-	}
-	return [...grouped.values()].map((community) => community.sort((a, b) => a.id.localeCompare(b.id))).sort((a, b) => a[0].id.localeCompare(b[0].id));
+function getSimplePath(graph, opts) {
+	for (const path of genSimplePaths(graph, opts)) return path;
 }
-function getEdgeBetweenness(graph) {
-	const scores = Object.fromEntries(graph.edges.map((edge) => [edge.id, 0]));
-	for (const source of graph.nodes) {
-		const stack = [];
-		const predecessors = /* @__PURE__ */ new Map();
-		const sigma = /* @__PURE__ */ new Map();
-		const distance = /* @__PURE__ */ new Map();
-		const queue = [source.id];
-		for (const node of graph.nodes) {
-			predecessors.set(node.id, []);
-			sigma.set(node.id, 0);
-			distance.set(node.id, -1);
-		}
-		sigma.set(source.id, 1);
-		distance.set(source.id, 0);
-		while (queue.length > 0) {
-			const currentId = queue.shift();
-			stack.push(currentId);
-			for (const neighbor of getUndirectedNeighbors$1(graph, currentId)) {
-				if (distance.get(neighbor.nodeId) === -1) {
-					queue.push(neighbor.nodeId);
-					distance.set(neighbor.nodeId, distance.get(currentId) + 1);
-				}
-				if (distance.get(neighbor.nodeId) === distance.get(currentId) + 1) {
-					sigma.set(neighbor.nodeId, sigma.get(neighbor.nodeId) + sigma.get(currentId));
-					predecessors.get(neighbor.nodeId).push({
-						nodeId: currentId,
-						edgeId: neighbor.edgeId
-					});
-				}
-			}
+function getStronglyConnectedComponents(graph) {
+	const idx = getIndex(graph);
+	let indexCounter = 0;
+	const nodeIndex = /* @__PURE__ */ new Map();
+	const lowlink = /* @__PURE__ */ new Map();
+	const onStack = /* @__PURE__ */ new Set();
+	const stack = [];
+	const result = [];
+	function strongconnect(id) {
+		nodeIndex.set(id, indexCounter);
+		lowlink.set(id, indexCounter);
+		indexCounter++;
+		stack.push(id);
+		onStack.add(id);
+		for (const eid of idx.outEdges.get(id) ?? []) {
+			const ai = idx.edgeById.get(eid);
+			if (ai === void 0) continue;
+			const neighborId = graph.edges[ai].targetId;
+			if (!nodeIndex.has(neighborId)) {
+				strongconnect(neighborId);
+				lowlink.set(id, Math.min(lowlink.get(id), lowlink.get(neighborId)));
+			} else if (onStack.has(neighborId)) lowlink.set(id, Math.min(lowlink.get(id), nodeIndex.get(neighborId)));
 		}
-		const delta = /* @__PURE__ */ new Map();
-		for (const node of graph.nodes) delta.set(node.id, 0);
-		while (stack.length > 0) {
-			const nodeId = stack.pop();
-			const sigmaNode = sigma.get(nodeId);
-			if (sigmaNode === 0) continue;
-			for (const predecessor of predecessors.get(nodeId)) {
-				const contribution = sigma.get(predecessor.nodeId) / sigmaNode * (1 + delta.get(nodeId));
-				scores[predecessor.edgeId] += contribution;
-				delta.set(predecessor.nodeId, delta.get(predecessor.nodeId) + contribution);
-			}
+		if (lowlink.get(id) === nodeIndex.get(id)) {
+			const component = [];
+			let neighborId;
+			do {
+				neighborId = stack.pop();
+				onStack.delete(neighborId);
+				const ni = idx.nodeById.get(neighborId);
+				if (ni !== void 0) component.push(graph.nodes[ni]);
+			} while (neighborId !== id);
+			result.push(component);
 		}
 	}
-	for (const edgeId of Object.keys(scores)) scores[edgeId] /= 2;
-	return scores;
+	for (const node of graph.nodes) if (!nodeIndex.has(node.id)) strongconnect(node.id);
+	return result;
 }
-function cloneWithEdges(graph, edges) {
-	return {
-		...graph,
-		nodes: [...graph.nodes],
-		edges
-	};
+function getCycles(graph) {
+	return [...genCycles(graph)];
 }
-function toCommunityIds(communities) {
-	return communities.map((community) => new Set(community.map((node) => node.id)));
+function* genCycles(graph) {
+	if (graph.type === "undirected") yield* genCyclesUndirected(graph);
+	else yield* genCyclesDirected(graph);
 }
-/**
-* Returns label-propagation communities for the graph.
-*
-* The implementation is deterministic: ties are broken by lexicographic label
-* order so test results remain stable.
-*/
-function getLabelPropagationCommunities(graph, options) {
-	if (graph.nodes.length === 0) return [];
-	const maxIterations = options?.maxIterations ?? 50;
-	let labels = Object.fromEntries(graph.nodes.map((node) => [node.id, node.id]));
-	const nodeIds = graph.nodes.map((node) => node.id).sort();
-	for (let iteration = 0; iteration < maxIterations; iteration++) {
-		const nextLabels = { ...labels };
-		let changed = false;
-		for (const nodeId of nodeIds) {
-			const counts = /* @__PURE__ */ new Map();
-			for (const neighbor of getUndirectedNeighbors$1(graph, nodeId)) {
-				const label = labels[neighbor.nodeId];
-				counts.set(label, (counts.get(label) ?? 0) + 1);
-			}
-			if (counts.size === 0) continue;
-			const bestLabel = [...counts.entries()].sort((a, b) => {
-				if (b[1] !== a[1]) return b[1] - a[1];
-				return a[0].localeCompare(b[0]);
-			})[0][0];
-			if (bestLabel !== labels[nodeId]) {
-				nextLabels[nodeId] = bestLabel;
-				changed = true;
+function* genCyclesDirected(graph) {
+	const idx = getIndex(graph);
+	const sortedIds = graph.nodes.map((node) => node.id).sort();
+	for (let startIndex = 0; startIndex < sortedIds.length; startIndex++) {
+		const startId = sortedIds[startIndex];
+		const allowed = new Set(sortedIds.slice(startIndex));
+		const visited = /* @__PURE__ */ new Set();
+		const steps = [];
+		const startNi = idx.nodeById.get(startId);
+		const startNode = graph.nodes[startNi];
+		const found = [];
+		function dfsFind(currentId) {
+			visited.add(currentId);
+			for (const eid of idx.outEdges.get(currentId) ?? []) {
+				const ai = idx.edgeById.get(eid);
+				if (ai === void 0) continue;
+				const edge = graph.edges[ai];
+				const neighborId = edge.targetId;
+				if (neighborId === startId && (steps.length > 0 || currentId === startId)) found.push({
+					source: startNode,
+					steps: [...steps, {
+						edge,
+						node: startNode
+					}]
+				});
+				else if (allowed.has(neighborId) && !visited.has(neighborId)) {
+					const ni = idx.nodeById.get(neighborId);
+					steps.push({
+						edge,
+						node: graph.nodes[ni]
+					});
+					dfsFind(neighborId);
+					steps.pop();
+				}
 			}
+			visited.delete(currentId);
 		}
-		labels = nextLabels;
-		if (!changed) break;
+		dfsFind(startId);
+		yield* found;
 	}
-	return normalizeCommunities(graph, labels);
 }
-/**
-* Lazily yields Girvan-Newman community splits as edge betweenness removes
-* bridge-like edges from the graph.
-*/
-function* genGirvanNewmanCommunities(graph, options) {
-	if (graph.nodes.length === 0 || graph.edges.length === 0) return;
-	const maxLevels = options?.maxLevels ?? Number.POSITIVE_INFINITY;
-	let yielded = 0;
-	let edges = [...graph.edges];
-	let previousCount = getUndirectedConnectedComponents(graph).length;
-	while (edges.length > 0 && yielded < maxLevels) {
-		const betweenness = getEdgeBetweenness(cloneWithEdges(graph, edges));
-		const maxScore = Math.max(...Object.values(betweenness));
-		edges = edges.filter((edge) => betweenness[edge.id] < maxScore - 1e-12);
-		const components = getUndirectedConnectedComponents(cloneWithEdges(graph, edges));
-		if (components.length > previousCount) {
-			yield components;
-			yielded++;
-			previousCount = components.length;
+function* genCyclesUndirected(graph) {
+	const idx = getIndex(graph);
+	const sortedIds = graph.nodes.map((node) => node.id).sort();
+	const seen = /* @__PURE__ */ new Set();
+	for (let startIndex = 0; startIndex < sortedIds.length; startIndex++) {
+		const startId = sortedIds[startIndex];
+		const allowed = new Set(sortedIds.slice(startIndex));
+		const visited = /* @__PURE__ */ new Set();
+		const steps = [];
+		const startNi = idx.nodeById.get(startId);
+		const startNode = graph.nodes[startNi];
+		const found = [];
+		function dfsFind(currentId, parentId) {
+			visited.add(currentId);
+			for (const { neighborId, edge } of getNeighborEdgesAll(graph, currentId)) {
+				if (neighborId === parentId) {
+					parentId = null;
+					continue;
+				}
+				if (neighborId === startId && steps.length >= 2) {
+					const innerIds = steps.map((step) => step.node.id).sort().join(",");
+					if (!seen.has(innerIds)) {
+						seen.add(innerIds);
+						found.push({
+							source: startNode,
+							steps: [...steps, {
+								edge,
+								node: startNode
+							}]
+						});
+					}
+				} else if (allowed.has(neighborId) && !visited.has(neighborId)) {
+					const ni = idx.nodeById.get(neighborId);
+					steps.push({
+						edge,
+						node: graph.nodes[ni]
+					});
+					dfsFind(neighborId, currentId);
+					steps.pop();
+				}
+			}
+			visited.delete(currentId);
 		}
+		dfsFind(startId, null);
+		yield* found;
 	}
 }
-/**
-* Returns the requested Girvan-Newman split level eagerly.
-*
-* `level: 1` returns the first split yielded by `genGirvanNewmanCommunities`.
-*/
-function getGirvanNewmanCommunities(graph, options) {
-	if (graph.nodes.length === 0) return [];
-	const targetLevel = options?.level ?? 1;
-	if (targetLevel <= 0) return getUndirectedConnectedComponents(graph);
-	let last = getUndirectedConnectedComponents(graph);
-	let level = 0;
-	for (const partition of genGirvanNewmanCommunities(graph, { maxLevels: targetLevel })) {
-		last = partition;
-		level++;
-		if (level >= targetLevel) break;
-	}
-	return last;
+function getAllPairsShortestPaths(graph, opts) {
+	const algorithm = opts?.algorithm ?? "dijkstra";
+	if (algorithm === "floyd-warshall") return floydWarshallAllPaths(graph, opts?.getWeight);
+	if (algorithm === "bellman-ford") return bellmanFordAllPaths(graph, opts?.getWeight);
+	return dijkstraAllPaths(graph, opts?.getWeight);
 }
-/**
-* Returns the modularity score for a partition of communities.
-*
-* Community algorithms in this module treat the graph as undirected.
-*/
-function getModularity(graph, communities) {
-	if (graph.edges.length === 0 || communities.length === 0) return 0;
+function bellmanFordAllPaths(graph, getWeight) {
+	const results = [];
+	for (const node of graph.nodes) results.push(...getShortestPaths(graph, {
+		from: node.id,
+		getWeight,
+		algorithm: "bellman-ford"
+	}));
+	return results;
+}
+function dijkstraAllPaths(graph, getWeight) {
+	const results = [];
+	for (const node of graph.nodes) results.push(...getShortestPaths(graph, {
+		from: node.id,
+		getWeight
+	}));
+	return results;
+}
+function floydWarshallAllPaths(graph, getWeight) {
+	const idx = getIndex(graph);
+	const weight = getWeight ?? ((edge) => edge.weight ?? 1);
 	const nodeIds = graph.nodes.map((node) => node.id);
-	const adjacency = /* @__PURE__ */ new Map();
-	const degree = Object.fromEntries(nodeIds.map((nodeId) => [nodeId, 0]));
-	for (const nodeId of nodeIds) adjacency.set(nodeId, /* @__PURE__ */ new Map());
+	const nodeCount = nodeIds.length;
+	const indexOf = /* @__PURE__ */ new Map();
+	for (let i = 0; i < nodeCount; i++) indexOf.set(nodeIds[i], i);
+	const INF = Infinity;
+	const dist = Array.from({ length: nodeCount }, () => Array(nodeCount).fill(INF));
+	const prev = Array.from({ length: nodeCount }, () => Array.from({ length: nodeCount }, () => []));
+	for (let i = 0; i < nodeCount; i++) dist[i][i] = 0;
 	for (const edge of graph.edges) {
-		adjacency.get(edge.sourceId).set(edge.targetId, (adjacency.get(edge.sourceId).get(edge.targetId) ?? 0) + 1);
-		adjacency.get(edge.targetId).set(edge.sourceId, (adjacency.get(edge.targetId).get(edge.sourceId) ?? 0) + 1);
-		degree[edge.sourceId]++;
-		degree[edge.targetId]++;
+		const source = indexOf.get(edge.sourceId);
+		const target = indexOf.get(edge.targetId);
+		const edgeWeight = weight(edge);
+		if (edgeWeight < dist[source][target]) {
+			dist[source][target] = edgeWeight;
+			prev[source][target] = [{
+				from: source,
+				edge
+			}];
+		} else if (edgeWeight === dist[source][target] && edgeWeight < INF) prev[source][target].push({
+			from: source,
+			edge
+		});
+		if (graph.type === "undirected") {
+			if (edgeWeight < dist[target][source]) {
+				dist[target][source] = edgeWeight;
+				prev[target][source] = [{
+					from: target,
+					edge
+				}];
+			} else if (edgeWeight === dist[target][source] && edgeWeight < INF) prev[target][source].push({
+				from: target,
+				edge
+			});
+		}
 	}
-	const m2 = graph.edges.length * 2;
-	let modularity = 0;
-	for (const community of toCommunityIds(communities)) {
-		const ids = [...community];
-		for (const i of ids) for (const j of ids) {
-			const aij = adjacency.get(i).get(j) ?? 0;
-			modularity += aij - degree[i] * degree[j] / m2;
+	for (let k = 0; k < nodeCount; k++) for (let i = 0; i < nodeCount; i++) for (let j = 0; j < nodeCount; j++) {
+		if (dist[i][k] === INF || dist[k][j] === INF) continue;
+		const nextDistance = dist[i][k] + dist[k][j];
+		if (nextDistance < dist[i][j]) {
+			dist[i][j] = nextDistance;
+			prev[i][j] = prev[k][j].map((entry) => ({ ...entry }));
+		} else if (nextDistance === dist[i][j] && nextDistance < INF) {
+			for (const entry of prev[k][j]) if (!prev[i][j].some((existing) => existing.edge.id === entry.edge.id)) prev[i][j].push({ ...entry });
 		}
 	}
-	return modularity / m2;
-}
-/**
-* Returns communities found by greedily merging partitions that improve
-* modularity the most at each step.
-*/
-function getGreedyModularityCommunities(graph) {
-	if (graph.nodes.length === 0) return [];
-	let communities = graph.nodes.map((node) => [node]);
-	let currentScore = getModularity(graph, communities);
-	while (communities.length > 1) {
-		let bestScore = currentScore;
-		let bestMerge;
-		for (let i = 0; i < communities.length; i++) for (let j = i + 1; j < communities.length; j++) {
-			const merged = communities.filter((_, index) => index !== i && index !== j);
-			merged.push([...communities[i], ...communities[j]].sort((a, b) => a.id.localeCompare(b.id)));
-			const score = getModularity(graph, merged);
-			if (score > bestScore + 1e-12) {
-				bestScore = score;
-				bestMerge = merged;
-			}
+	const results = [];
+	for (let i = 0; i < nodeCount; i++) {
+		const sourceNi = idx.nodeById.get(nodeIds[i]);
+		if (sourceNi === void 0) continue;
+		const sourceNode = graph.nodes[sourceNi];
+		for (let j = 0; j < nodeCount; j++) {
+			if (i === j || dist[i][j] === INF) continue;
+			results.push(...fwReconstruct(graph, prev, nodeIds, sourceNode, i, j));
 		}
-		if (!bestMerge) break;
-		communities = bestMerge.sort((a, b) => a[0].id.localeCompare(b[0].id));
-		currentScore = bestScore;
 	}
-	return communities;
+	return results;
 }
-
-//#endregion
-//#region src/algorithms/connectivity.ts
-function getUndirectedNeighbors(graph, nodeId) {
-	const idx = getIndex(graph);
-	const neighbors = [];
-	for (const edgeId of idx.outEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) neighbors.push({
-			nodeId: graph.edges[edgeIndex].targetId,
-			edgeId
-		});
-	}
-	for (const edgeId of idx.inEdges.get(nodeId) ?? []) {
-		const edgeIndex = idx.edgeById.get(edgeId);
-		if (edgeIndex !== void 0) neighbors.push({
-			nodeId: graph.edges[edgeIndex].sourceId,
-			edgeId
+function fwReconstruct(graph, prev, nodeIds, sourceNode, sourceIdx, targetIdx) {
+	if (sourceIdx === targetIdx) return [{
+		source: sourceNode,
+		steps: []
+	}];
+	const predecessors = prev[sourceIdx][targetIdx];
+	if (predecessors.length === 0) return [];
+	const targetNi = getIndex(graph).nodeById.get(nodeIds[targetIdx]);
+	if (targetNi === void 0) return [];
+	const targetNode = graph.nodes[targetNi];
+	const results = [];
+	for (const { from, edge } of predecessors) {
+		const prefixPaths = fwReconstruct(graph, prev, nodeIds, sourceNode, sourceIdx, from);
+		for (const prefix of prefixPaths) results.push({
+			source: sourceNode,
+			steps: [...prefix.steps, {
+				edge,
+				node: targetNode
+			}]
 		});
 	}
-	return neighbors;
-}
-function popComponentUntil(state, stopEdgeId) {
-	const nodeIds = /* @__PURE__ */ new Set();
-	while (state.edgeStack.length > 0) {
-		const edgeId = state.edgeStack.pop();
-		const edge = state.edgeById.get(edgeId);
-		if (edge) {
-			nodeIds.add(edge.sourceId);
-			nodeIds.add(edge.targetId);
-		}
-		if (edgeId === stopEdgeId) break;
-	}
-	if (nodeIds.size > 0) state.components.push(nodeIds);
+	return results;
 }
-function finalizeRemainingComponent(state) {
-	if (state.edgeStack.length === 0) return;
-	const nodeIds = /* @__PURE__ */ new Set();
-	while (state.edgeStack.length > 0) {
-		const edge = state.edgeById.get(state.edgeStack.pop());
-		if (edge) {
-			nodeIds.add(edge.sourceId);
-			nodeIds.add(edge.targetId);
+function getAStarPath(graph, opts) {
+	const idx = getIndex(graph);
+	const { from: sourceId, to: targetId, heuristic } = opts;
+	const getWeight = opts.getWeight ?? ((edge) => edge.weight ?? 1);
+	const sourceNi = idx.nodeById.get(sourceId);
+	if (sourceNi === void 0) return void 0;
+	if (!idx.nodeById.has(targetId)) return void 0;
+	if (sourceId === targetId) return {
+		source: graph.nodes[sourceNi],
+		steps: []
+	};
+	const gScore = /* @__PURE__ */ new Map();
+	const cameFrom = /* @__PURE__ */ new Map();
+	const closedSet = /* @__PURE__ */ new Set();
+	const openSet = new MinPriorityQueue((a, b) => a.f - b.f);
+	gScore.set(sourceId, 0);
+	openSet.push({
+		id: sourceId,
+		f: heuristic(sourceId)
+	});
+	while (openSet.size > 0) {
+		const { id: currentId } = openSet.pop();
+		if (closedSet.has(currentId)) continue;
+		if (currentId === targetId) {
+			const steps = [];
+			let current = targetId;
+			while (current !== sourceId) {
+				const previous = cameFrom.get(current);
+				const ni = idx.nodeById.get(current);
+				steps.unshift({
+					edge: previous.edge,
+					node: graph.nodes[ni]
+				});
+				current = previous.from;
+			}
+			return {
+				source: graph.nodes[sourceNi],
+				steps
+			};
 		}
-	}
-	if (nodeIds.size > 0) state.components.push(nodeIds);
-}
-function traverseConnectivity(graph, nodeId, parentEdgeId, state) {
-	state.time += 1;
-	state.disc.set(nodeId, state.time);
-	state.low.set(nodeId, state.time);
-	let childCount = 0;
-	for (const neighbor of getUndirectedNeighbors(graph, nodeId)) {
-		if (neighbor.edgeId === parentEdgeId) continue;
-		if (!state.disc.has(neighbor.nodeId)) {
-			childCount += 1;
-			state.edgeStack.push(neighbor.edgeId);
-			traverseConnectivity(graph, neighbor.nodeId, neighbor.edgeId, state);
-			state.low.set(nodeId, Math.min(state.low.get(nodeId), state.low.get(neighbor.nodeId)));
-			if (state.low.get(neighbor.nodeId) > state.disc.get(nodeId)) state.bridges.add(neighbor.edgeId);
-			if (parentEdgeId !== null && state.low.get(neighbor.nodeId) >= state.disc.get(nodeId)) {
-				state.articulationPoints.add(nodeId);
-				popComponentUntil(state, neighbor.edgeId);
+		closedSet.add(currentId);
+		for (const { neighborId, edge } of getNeighborEdges(graph, currentId)) {
+			if (closedSet.has(neighborId)) continue;
+			const tentativeScore = (gScore.get(currentId) ?? Infinity) + getWeight(edge);
+			if (tentativeScore < (gScore.get(neighborId) ?? Infinity)) {
+				cameFrom.set(neighborId, {
+					from: currentId,
+					edge
+				});
+				gScore.set(neighborId, tentativeScore);
+				openSet.push({
+					id: neighborId,
+					f: tentativeScore + heuristic(neighborId)
+				});
 			}
-		} else if (state.disc.get(neighbor.nodeId) < state.disc.get(nodeId)) {
-			state.edgeStack.push(neighbor.edgeId);
-			state.low.set(nodeId, Math.min(state.low.get(nodeId), state.disc.get(neighbor.nodeId)));
 		}
 	}
-	if (parentEdgeId === null && childCount > 1) state.articulationPoints.add(nodeId);
 }
-function analyzeConnectivity(graph) {
-	const state = {
-		time: 0,
-		disc: /* @__PURE__ */ new Map(),
-		low: /* @__PURE__ */ new Map(),
-		edgeStack: [],
-		bridges: /* @__PURE__ */ new Set(),
-		articulationPoints: /* @__PURE__ */ new Set(),
-		components: [],
-		nodeById: new Map(graph.nodes.map((node) => [node.id, node])),
-		edgeById: new Map(graph.edges.map((edge) => [edge.id, edge]))
+function joinPaths(headPath, tailPath) {
+	const headEnd = headPath.steps.length > 0 ? headPath.steps[headPath.steps.length - 1].node : headPath.source;
+	if (headEnd.id !== tailPath.source.id) throw new Error(`Paths cannot be joined: head path ends at "${headEnd.id}" but tail path starts at "${tailPath.source.id}"`);
+	return {
+		source: headPath.source,
+		steps: [...headPath.steps, ...tailPath.steps]
 	};
-	for (const node of graph.nodes) {
-		if (state.disc.has(node.id)) continue;
-		traverseConnectivity(graph, node.id, null, state);
-		finalizeRemainingComponent(state);
-	}
-	return state;
-}
-/**
-* Returns bridge edges whose removal disconnects the graph.
-*
-* Connectivity algorithms in this module treat the graph as undirected.
-*/
-function getBridges(graph) {
-	if (graph.edges.length === 0) return [];
-	const state = analyzeConnectivity(graph);
-	return [...state.bridges].map((edgeId) => state.edgeById.get(edgeId)).sort((a, b) => a.id.localeCompare(b.id));
-}
-/**
-* Returns articulation points (cut vertices) for the graph.
-*
-* Connectivity algorithms in this module treat the graph as undirected.
-*/
-function getArticulationPoints(graph) {
-	if (graph.nodes.length === 0) return [];
-	const state = analyzeConnectivity(graph);
-	return [...state.articulationPoints].map((nodeId) => state.nodeById.get(nodeId)).sort((a, b) => a.id.localeCompare(b.id));
-}
-/**
-* Returns biconnected components as arrays of nodes.
-*
-* Articulation points may appear in multiple returned components.
-*/
-function getBiconnectedComponents(graph) {
-	if (graph.edges.length === 0) return [];
-	const state = analyzeConnectivity(graph);
-	return state.components.map((component) => [...component].map((nodeId) => state.nodeById.get(nodeId)).sort((a, b) => a.id.localeCompare(b.id))).sort((a, b) => a[0].id.localeCompare(b[0].id));
 }
 
 //#endregion
-//#region src/algorithms/isomorphism.ts
-function getDegreeSignature(graph, nodeId) {
+//#region src/algorithms/traversal.ts
+function* bfs(graph, startId) {
 	const idx = getIndex(graph);
-	const outDegree = idx.outEdges.get(nodeId)?.length ?? 0;
-	const inDegree = idx.inEdges.get(nodeId)?.length ?? 0;
-	if (graph.type === "undirected") return `u:${new Set([...idx.outEdges.get(nodeId) ?? [], ...idx.inEdges.get(nodeId) ?? []]).size}`;
-	return `d:${inDegree}:${outDegree}`;
-}
-function getEdgesBetween(graph, sourceId, targetId) {
-	if (graph.type === "undirected") return graph.edges.filter((edge) => edge.sourceId === sourceId && edge.targetId === targetId || edge.sourceId === targetId && edge.targetId === sourceId);
-	return graph.edges.filter((edge) => edge.sourceId === sourceId && edge.targetId === targetId);
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [startId];
+	visited.add(startId);
+	while (queue.length > 0) {
+		const id = queue.shift();
+		const ni = idx.nodeById.get(id);
+		if (ni === void 0) continue;
+		yield graph.nodes[ni];
+		for (const neighborId of getNeighborIds$1(graph, id)) if (!visited.has(neighborId)) {
+			visited.add(neighborId);
+			queue.push(neighborId);
+		}
+	}
 }
-function edgesAreCompatible(edgesA, edgesB, edgeMatch) {
-	if (edgesA.length !== edgesB.length) return false;
-	if (!edgeMatch || edgesA.length === 0) return true;
-	const remaining = [...edgesB];
-	for (const edgeA of edgesA) {
-		const matchIndex = remaining.findIndex((edgeB) => edgeMatch(edgeA, edgeB));
-		if (matchIndex === -1) return false;
-		remaining.splice(matchIndex, 1);
+function* dfs(graph, startId) {
+	const idx = getIndex(graph);
+	const visited = /* @__PURE__ */ new Set();
+	const stack = [startId];
+	while (stack.length > 0) {
+		const id = stack.pop();
+		if (visited.has(id)) continue;
+		visited.add(id);
+		const ni = idx.nodeById.get(id);
+		if (ni === void 0) continue;
+		yield graph.nodes[ni];
+		for (const neighborId of getNeighborIds$1(graph, id)) if (!visited.has(neighborId)) stack.push(neighborId);
 	}
-	return true;
-}
-/**
-* Returns whether two graphs are structurally isomorphic.
-*
-* Optional `nodeMatch` and `edgeMatch` predicates can refine the match using
-* node and edge payloads.
-*/
-function isIsomorphic(graphA, graphB, options) {
-	if (graphA.type !== graphB.type) return false;
-	if (graphA.nodes.length !== graphB.nodes.length) return false;
-	if (graphA.edges.length !== graphB.edges.length) return false;
-	const nodeMatch = options?.nodeMatch;
-	const edgeMatch = options?.edgeMatch;
-	const nodesA = [...graphA.nodes].sort((a, b) => {
-		const sigDiff = getDegreeSignature(graphA, b.id).localeCompare(getDegreeSignature(graphA, a.id));
-		if (sigDiff !== 0) return sigDiff;
-		return a.id.localeCompare(b.id);
-	});
-	const nodesB = [...graphB.nodes];
-	const signaturesA = nodesA.map((node) => getDegreeSignature(graphA, node.id)).sort();
-	const signaturesB = nodesB.map((node) => getDegreeSignature(graphB, node.id)).sort();
-	if (signaturesA.join("|") !== signaturesB.join("|")) return false;
-	const mapping = /* @__PURE__ */ new Map();
-	const usedB = /* @__PURE__ */ new Set();
-	const backtrack = (index) => {
-		if (index >= nodesA.length) return true;
-		const nodeA = nodesA[index];
-		const signatureA = getDegreeSignature(graphA, nodeA.id);
-		for (const nodeB of nodesB) {
-			if (usedB.has(nodeB.id)) continue;
-			if (getDegreeSignature(graphB, nodeB.id) !== signatureA) continue;
-			if (nodeMatch && !nodeMatch(nodeA, nodeB)) continue;
-			let compatible = true;
-			for (const [mappedAId, mappedBId] of mapping.entries()) {
-				if (!edgesAreCompatible(getEdgesBetween(graphA, nodeA.id, mappedAId), getEdgesBetween(graphB, nodeB.id, mappedBId), edgeMatch)) {
-					compatible = false;
-					break;
-				}
-				if (!edgesAreCompatible(getEdgesBetween(graphA, mappedAId, nodeA.id), getEdgesBetween(graphB, mappedBId, nodeB.id), edgeMatch)) {
-					compatible = false;
-					break;
-				}
-			}
-			if (!compatible) continue;
-			mapping.set(nodeA.id, nodeB.id);
-			usedB.add(nodeB.id);
-			if (backtrack(index + 1)) return true;
-			mapping.delete(nodeA.id);
-			usedB.delete(nodeB.id);
-		}
-		return false;
-	};
-	return backtrack(0);
-}
-
-//#endregion
-//#region src/algorithms.ts
-/**
-* Breadth-first traversal generator yielding nodes level by level.
-*
-* **O(V + E)** time, **O(V)** space.
-*
-* @example
-* ```ts
-* import { createGraph, bfs } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [{ id: 'ab', sourceId: 'a', targetId: 'b' }, { id: 'bc', sourceId: 'b', targetId: 'c' }],
-* });
-*
-* for (const node of bfs(graph, 'a')) {
-*   console.log(node.id); // 'a', 'b', 'c'
-* }
-* ```
-*/
-function* bfs(graph, startId) {
-	const idx = getIndex(graph);
-	const visited = /* @__PURE__ */ new Set();
-	const queue = [startId];
-	visited.add(startId);
-	while (queue.length > 0) {
-		const id = queue.shift();
-		const ni = idx.nodeById.get(id);
-		if (ni === void 0) continue;
-		yield graph.nodes[ni];
-		for (const nId of getNeighborIds(graph, id)) if (!visited.has(nId)) {
-			visited.add(nId);
-			queue.push(nId);
-		}
-	}
-}
-/**
-* Depth-first traversal generator yielding nodes as visited.
-*
-* **O(V + E)** time, **O(V)** space.
-*
-* @example
-* ```ts
-* import { createGraph, dfs } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [{ id: 'ab', sourceId: 'a', targetId: 'b' }, { id: 'bc', sourceId: 'b', targetId: 'c' }],
-* });
-*
-* for (const node of dfs(graph, 'a')) {
-*   console.log(node.id); // 'a', 'b', 'c'
-* }
-* ```
-*/
-function* dfs(graph, startId) {
-	const idx = getIndex(graph);
-	const visited = /* @__PURE__ */ new Set();
-	const stack = [startId];
-	while (stack.length > 0) {
-		const id = stack.pop();
-		if (visited.has(id)) continue;
-		visited.add(id);
-		const ni = idx.nodeById.get(id);
-		if (ni === void 0) continue;
-		yield graph.nodes[ni];
-		for (const nId of getNeighborIds(graph, id)) if (!visited.has(nId)) stack.push(nId);
-	}
-}
-function getNeighborIds(graph, nodeId) {
-	const idx = getIndex(graph);
-	const ids = [];
-	for (const eid of idx.outEdges.get(nodeId) ?? []) {
-		const ai = idx.edgeById.get(eid);
-		if (ai !== void 0) ids.push(graph.edges[ai].targetId);
-	}
-	if (graph.type === "undirected") for (const eid of idx.inEdges.get(nodeId) ?? []) {
-		const ai = idx.edgeById.get(eid);
-		if (ai !== void 0) ids.push(graph.edges[ai].sourceId);
-	}
-	return ids;
-}
-function getSuccessorIds(graph, nodeId) {
-	const idx = getIndex(graph);
-	return (idx.outEdges.get(nodeId) ?? []).map((eid) => graph.edges[idx.edgeById.get(eid)].targetId);
-}
-var MinPriorityQueue = class {
-	items = [];
-	constructor(compare) {
-		this.compare = compare;
-	}
-	get size() {
-		return this.items.length;
-	}
-	push(item) {
-		this.items.push(item);
-		this.bubbleUp(this.items.length - 1);
-	}
-	pop() {
-		if (this.items.length === 0) return void 0;
-		const first = this.items[0];
-		const last = this.items.pop();
-		if (this.items.length > 0) {
-			this.items[0] = last;
-			this.bubbleDown(0);
-		}
-		return first;
-	}
-	bubbleUp(index) {
-		let current = index;
-		while (current > 0) {
-			const parent = Math.floor((current - 1) / 2);
-			if (this.compare(this.items[current], this.items[parent]) >= 0) break;
-			[this.items[current], this.items[parent]] = [this.items[parent], this.items[current]];
-			current = parent;
-		}
-	}
-	bubbleDown(index) {
-		let current = index;
-		while (true) {
-			const left = current * 2 + 1;
-			const right = left + 1;
-			let smallest = current;
-			if (left < this.items.length && this.compare(this.items[left], this.items[smallest]) < 0) smallest = left;
-			if (right < this.items.length && this.compare(this.items[right], this.items[smallest]) < 0) smallest = right;
-			if (smallest === current) break;
-			[this.items[current], this.items[smallest]] = [this.items[smallest], this.items[current]];
-			current = smallest;
-		}
-	}
-};
-/**
-* Checks whether the graph contains no cycles.
-*
-* **O(V + E)** time.
-*
-* @example
-* ```ts
-* import { createGraph, isAcyclic } from '@statelyai/graph';
-*
-* const dag = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }],
-*   edges: [{ id: 'ab', sourceId: 'a', targetId: 'b' }],
-* });
-*
-* isAcyclic(dag); // true
-* ```
-*/
-function isAcyclic(graph) {
-	if (graph.type === "undirected") return isAcyclicUndirected(graph);
-	const WHITE = 0, GRAY = 1, BLACK = 2;
-	const color = /* @__PURE__ */ new Map();
-	for (const n of graph.nodes) color.set(n.id, WHITE);
-	const hasCycle = (id) => {
-		color.set(id, GRAY);
-		for (const nId of getSuccessorIds(graph, id)) {
-			const c = color.get(nId);
-			if (c === GRAY) return true;
-			if (c === WHITE && hasCycle(nId)) return true;
-		}
-		color.set(id, BLACK);
-		return false;
-	};
-	for (const n of graph.nodes) if (color.get(n.id) === WHITE && hasCycle(n.id)) return false;
+}
+function isAcyclic(graph) {
+	if (graph.type === "undirected") return isAcyclicUndirected(graph);
+	const WHITE = 0;
+	const GRAY = 1;
+	const BLACK = 2;
+	const color = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) color.set(node.id, WHITE);
+	const hasCycle = (id) => {
+		color.set(id, GRAY);
+		for (const neighborId of getSuccessorIds(graph, id)) {
+			const current = color.get(neighborId);
+			if (current === GRAY) return true;
+			if (current === WHITE && hasCycle(neighborId)) return true;
+		}
+		color.set(id, BLACK);
+		return false;
+	};
+	for (const node of graph.nodes) if (color.get(node.id) === WHITE && hasCycle(node.id)) return false;
 	return true;
 }
 function isAcyclicUndirected(graph) {
@@ -1562,37 +1360,18 @@ function isAcyclicUndirected(graph) {
 		}
 		return false;
 	};
-	for (const n of graph.nodes) if (!visited.has(n.id) && hasCycle(n.id, null)) return false;
+	for (const node of graph.nodes) if (!visited.has(node.id) && hasCycle(node.id, null)) return false;
 	return true;
 }
-/**
-* Returns connected components as arrays of nodes.
-* Treats all edges as undirected for connectivity.
-*
-* **O(V + E)** time.
-*
-* @example
-* ```ts
-* import { createGraph, getConnectedComponents } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [{ id: 'ab', sourceId: 'a', targetId: 'b' }],
-* });
-*
-* const components = getConnectedComponents(graph);
-* // [[nodeA, nodeB], [nodeC]]
-* ```
-*/
 function getConnectedComponents(graph) {
 	const idx = getIndex(graph);
 	const visited = /* @__PURE__ */ new Set();
 	const components = [];
-	for (const n of graph.nodes) {
-		if (visited.has(n.id)) continue;
+	for (const node of graph.nodes) {
+		if (visited.has(node.id)) continue;
 		const component = [];
-		const queue = [n.id];
-		visited.add(n.id);
+		const queue = [node.id];
+		visited.add(node.id);
 		while (queue.length > 0) {
 			const id = queue.shift();
 			const ni = idx.nodeById.get(id);
@@ -1620,34 +1399,13 @@ function getConnectedComponents(graph) {
 	}
 	return components;
 }
-/**
-* Returns a topological ordering of nodes, or `null` if the graph is cyclic.
-*
-* **O(V + E)** time (Kahn's algorithm).
-*
-* @example
-* ```ts
-* import { createGraph, getTopologicalSort } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'bc', sourceId: 'b', targetId: 'c' },
-*   ],
-* });
-*
-* const sorted = getTopologicalSort(graph);
-* // [nodeA, nodeB, nodeC]
-* ```
-*/
 function getTopologicalSort(graph) {
 	const idx = getIndex(graph);
-	const inDeg = /* @__PURE__ */ new Map();
-	for (const n of graph.nodes) inDeg.set(n.id, 0);
-	for (const e of graph.edges) inDeg.set(e.targetId, (inDeg.get(e.targetId) ?? 0) + 1);
+	const inDegree = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) inDegree.set(node.id, 0);
+	for (const edge of graph.edges) inDegree.set(edge.targetId, (inDegree.get(edge.targetId) ?? 0) + 1);
 	const queue = [];
-	for (const [id, deg] of inDeg) if (deg === 0) queue.push(id);
+	for (const [id, degree] of inDegree) if (degree === 0) queue.push(id);
 	const result = [];
 	while (queue.length > 0) {
 		const id = queue.shift();
@@ -1657,1274 +1415,976 @@ function getTopologicalSort(graph) {
 			const ai = idx.edgeById.get(eid);
 			if (ai === void 0) continue;
 			const targetId = graph.edges[ai].targetId;
-			const newDeg = (inDeg.get(targetId) ?? 1) - 1;
-			inDeg.set(targetId, newDeg);
-			if (newDeg === 0) queue.push(targetId);
+			const nextDegree = (inDegree.get(targetId) ?? 1) - 1;
+			inDegree.set(targetId, nextDegree);
+			if (nextDegree === 0) queue.push(targetId);
 		}
 	}
 	if (result.length !== graph.nodes.length) return null;
 	return result;
 }
-/**
-* Checks whether a path exists between two nodes.
-*
-* **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted).
-*
-* @example
-* ```ts
-* import { createGraph, hasPath } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [{ id: 'ab', sourceId: 'a', targetId: 'b' }],
-* });
-*
-* hasPath(graph, 'a', 'b'); // true
-* hasPath(graph, 'a', 'c'); // false
-* ```
-*/
 function hasPath(graph, sourceId, targetId) {
 	return getShortestPaths(graph, {
 		from: sourceId,
 		to: targetId
 	}).length > 0;
 }
-/**
-* Checks whether the graph is connected (all nodes reachable from any node).
-*
-* **O(V + E)** time.
-*
-* @example
-* ```ts
-* import { createGraph, isConnected } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }],
-*   edges: [{ id: 'ab', sourceId: 'a', targetId: 'b' }],
-* });
-*
-* isConnected(graph); // true
-* ```
-*/
 function isConnected(graph) {
 	if (graph.nodes.length === 0) return true;
 	return getConnectedComponents(graph).length <= 1;
 }
-/**
-* Checks whether the graph is a tree (connected and acyclic).
-*
-* **O(V + E)** time.
-*
-* @example
-* ```ts
-* import { createGraph, isTree } from '@statelyai/graph';
-*
-* const tree = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'ac', sourceId: 'a', targetId: 'c' },
-*   ],
-* });
-*
-* isTree(tree); // true
-* ```
-*/
 function isTree(graph) {
 	return isConnected(graph) && isAcyclic(graph);
 }
-/** Resolve the `from` node ID from opts or graph defaults. */
-function resolveFrom(graph, opts) {
-	if (opts?.from) return opts.from;
-	if (graph.initialNodeId) return graph.initialNodeId;
-	const inDeg = /* @__PURE__ */ new Map();
-	for (const n of graph.nodes) inDeg.set(n.id, 0);
-	for (const e of graph.edges) inDeg.set(e.targetId, (inDeg.get(e.targetId) ?? 0) + 1);
-	const roots = [...inDeg.entries()].filter(([, d]) => d === 0).map(([id]) => id);
-	if (roots.length === 1) return roots[0];
-	throw new Error("Cannot determine start node — provide opts.from or set graph.initialNodeId");
-}
-/** Get neighbor IDs with their connecting edges. */
-function getNeighborEdges(graph, nodeId) {
+
+//#endregion
+//#region src/algorithms/ordering.ts
+function getPreorder(graph, opts) {
 	const idx = getIndex(graph);
-	const result = [];
-	for (const eid of idx.outEdges.get(nodeId) ?? []) {
-		const ai = idx.edgeById.get(eid);
-		if (ai !== void 0) {
-			const e = graph.edges[ai];
-			result.push({
-				neighborId: e.targetId,
-				edge: e
-			});
+	const startId = resolveFrom(graph, opts);
+	const startNi = idx.nodeById.get(startId);
+	if (startNi === void 0) return [];
+	const visited = new Set([startId]);
+	const result = [graph.nodes[startNi]];
+	const stack = [startId];
+	while (stack.length > 0) {
+		const top = stack[stack.length - 1];
+		const next = getNeighborIds$1(graph, top).find((id) => !visited.has(id));
+		if (next === void 0) {
+			stack.pop();
+			continue;
 		}
+		visited.add(next);
+		stack.push(next);
+		const ni = idx.nodeById.get(next);
+		if (ni !== void 0) result.push(graph.nodes[ni]);
 	}
-	if (graph.type === "undirected") for (const eid of idx.inEdges.get(nodeId) ?? []) {
-		const ai = idx.edgeById.get(eid);
-		if (ai !== void 0) {
-			const e = graph.edges[ai];
-			result.push({
-				neighborId: e.sourceId,
-				edge: e
-			});
+	return result;
+}
+function getPostorder(graph, opts) {
+	const idx = getIndex(graph);
+	const startId = resolveFrom(graph, opts);
+	if (idx.nodeById.get(startId) === void 0) return [];
+	const visited = new Set([startId]);
+	const result = [];
+	const stack = [startId];
+	while (stack.length > 0) {
+		const top = stack[stack.length - 1];
+		const next = getNeighborIds$1(graph, top).find((id) => !visited.has(id));
+		if (next === void 0) {
+			stack.pop();
+			const ni = idx.nodeById.get(top);
+			if (ni !== void 0) result.push(graph.nodes[ni]);
+			continue;
 		}
+		visited.add(next);
+		stack.push(next);
 	}
 	return result;
 }
-/**
-* Returns all shortest paths from a source node.
-* Returns all paths of equal minimum length per target (not just one).
-* Uses BFS when all edges are unweighted; Dijkstra otherwise.
-*/
-/** Compute distance + prev maps via BFS or Dijkstra. */
-function computeShortestDistances(graph, sourceId, getWeight) {
-	const dist = /* @__PURE__ */ new Map();
-	const prev = /* @__PURE__ */ new Map();
-	dist.set(sourceId, 0);
-	prev.set(sourceId, []);
-	if (!getWeight && !graph.edges.some((e) => e.weight !== void 0)) {
-		const queue = [sourceId];
-		while (queue.length > 0) {
-			const id = queue.shift();
-			const d = dist.get(id);
-			for (const { neighborId, edge } of getNeighborEdges(graph, id)) {
-				const newDist = d + 1;
-				const existing = dist.get(neighborId);
-				if (existing === void 0) {
-					dist.set(neighborId, newDist);
-					prev.set(neighborId, [{
-						from: id,
-						edge
-					}]);
-					queue.push(neighborId);
-				} else if (existing === newDist) prev.get(neighborId).push({
-					from: id,
-					edge
+function getPreorders(graph, opts) {
+	return [...genPreorders(graph, opts)];
+}
+function getPostorders(graph, opts) {
+	return [...genPostorders(graph, opts)];
+}
+function* genPreorders(graph, opts) {
+	const idx = getIndex(graph);
+	const startId = resolveFrom(graph, opts);
+	const startNi = idx.nodeById.get(startId);
+	const startNode = startNi !== void 0 ? graph.nodes[startNi] : void 0;
+	if (!startNode) return;
+	const queue = [{
+		visited: new Set([startId]),
+		preorder: [startNode],
+		dfsStack: [startId]
+	}];
+	while (queue.length > 0) {
+		const frame = queue.pop();
+		const { visited, dfsStack } = frame;
+		let { preorder } = frame;
+		let branched = false;
+		while (dfsStack.length > 0) {
+			const top = dfsStack[dfsStack.length - 1];
+			const unvisited = getNeighborIds$1(graph, top).filter((id) => !visited.has(id));
+			if (unvisited.length === 0) {
+				dfsStack.pop();
+				continue;
+			}
+			for (const nextId of unvisited) {
+				const ni = idx.nodeById.get(nextId);
+				if (ni === void 0) continue;
+				const newVisited = new Set(visited);
+				newVisited.add(nextId);
+				queue.push({
+					visited: newVisited,
+					preorder: [...preorder, graph.nodes[ni]],
+					dfsStack: [...dfsStack, nextId]
 				});
 			}
+			branched = true;
+			break;
 		}
-	} else {
-		const effectiveWeight = getWeight ?? ((e) => e.weight ?? 1);
-		const visited = /* @__PURE__ */ new Set();
-		const pq = new MinPriorityQueue((a, b) => a.dist - b.dist);
-		pq.push({
-			id: sourceId,
-			dist: 0
-		});
-		while (pq.size > 0) {
-			const { id, dist: d } = pq.pop();
-			if (visited.has(id) || d !== dist.get(id)) continue;
-			visited.add(id);
-			for (const { neighborId, edge } of getNeighborEdges(graph, id)) {
-				const newDist = d + effectiveWeight(edge);
-				const existing = dist.get(neighborId);
-				if (existing === void 0 || newDist < existing) {
-					dist.set(neighborId, newDist);
-					prev.set(neighborId, [{
-						from: id,
-						edge
-					}]);
-					pq.push({
-						id: neighborId,
-						dist: newDist
-					});
-				} else if (existing === newDist) prev.get(neighborId).push({
-					from: id,
-					edge
+		if (!branched) yield preorder;
+	}
+}
+function* genPostorders(graph, opts) {
+	const idx = getIndex(graph);
+	const startId = resolveFrom(graph, opts);
+	if (idx.nodeById.get(startId) === void 0) return;
+	const queue = [{
+		visited: new Set([startId]),
+		postorder: [],
+		dfsStack: [startId]
+	}];
+	while (queue.length > 0) {
+		const frame = queue.pop();
+		const { visited, dfsStack } = frame;
+		let { postorder } = frame;
+		let branched = false;
+		while (dfsStack.length > 0) {
+			const top = dfsStack[dfsStack.length - 1];
+			const unvisited = getNeighborIds$1(graph, top).filter((id) => !visited.has(id));
+			if (unvisited.length === 0) {
+				dfsStack.pop();
+				const ni = idx.nodeById.get(top);
+				if (ni !== void 0) postorder = [...postorder, graph.nodes[ni]];
+				continue;
+			}
+			for (const nextId of unvisited) {
+				if (idx.nodeById.get(nextId) === void 0) continue;
+				const newVisited = new Set(visited);
+				newVisited.add(nextId);
+				queue.push({
+					visited: newVisited,
+					postorder: [...postorder],
+					dfsStack: [...dfsStack, nextId]
 				});
 			}
+			branched = true;
+			break;
 		}
+		if (!branched) yield postorder;
 	}
-	return {
-		dist,
-		prev
-	};
 }
-/** Reconstruct all shortest paths to a target by backtracking through prev map. */
-function* reconstructPaths(graph, prev, sourceNode, targetId) {
-	if (targetId === sourceNode.id) {
-		yield {
-			source: sourceNode,
-			steps: []
-		};
-		return;
-	}
-	const preds = prev.get(targetId);
-	if (!preds || preds.length === 0) return;
-	const targetNi = getIndex(graph).nodeById.get(targetId);
-	const targetNode = targetNi !== void 0 ? graph.nodes[targetNi] : graph.nodes.find((n) => n.id === targetId);
-	for (const { from, edge } of preds) for (const prefix of reconstructPaths(graph, prev, sourceNode, from)) yield {
-		source: sourceNode,
-		steps: [...prefix.steps, {
-			edge,
-			node: targetNode
-		}]
-	};
+
+//#endregion
+//#region src/algorithms/spanning-tree.ts
+function getMinimumSpanningTree(graph, opts) {
+	const algorithm = opts?.algorithm ?? "prim";
+	const getWeight = opts?.getWeight ?? ((edge) => edge.weight ?? 1);
+	const mstEdges = algorithm === "kruskal" ? kruskalMST(graph, getWeight) : primMST(graph, getWeight);
+	return createGraph({
+		id: graph.id,
+		type: graph.type,
+		initialNodeId: graph.initialNodeId ?? void 0,
+		nodes: graph.nodes.map((node) => ({
+			id: node.id,
+			parentId: node.parentId ?? void 0,
+			initialNodeId: node.initialNodeId ?? void 0,
+			label: node.label,
+			data: node.data
+		})),
+		edges: mstEdges.map((edge) => ({
+			id: edge.id,
+			sourceId: edge.sourceId,
+			targetId: edge.targetId,
+			label: edge.label,
+			data: edge.data,
+			...edge.weight !== void 0 && { weight: edge.weight }
+		}))
+	});
 }
-/**
-* Lazily yields all shortest paths from a source node.
-* Use `getShortestPaths` for the full array.
-*
-* **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted),
-* plus **O(P)** per path yielded where P is the path length.
-*
-* @example
-* ```ts
-* import { createGraph, genShortestPaths } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'bc', sourceId: 'b', targetId: 'c' },
-*   ],
-*   initialNodeId: 'a',
-* });
-*
-* for (const path of genShortestPaths(graph)) {
-*   console.log(path.steps.map(s => s.node.id));
-* }
-* ```
-*/
-function* genShortestPaths(graph, opts) {
+function primMST(graph, getWeight) {
+	if (graph.nodes.length === 0) return [];
 	const idx = getIndex(graph);
-	const sourceId = resolveFrom(graph, opts);
-	const { dist, prev } = computeShortestDistances(graph, sourceId, opts?.getWeight);
-	const targets = opts?.to ? [opts.to].filter((id) => dist.has(id)) : [...dist.keys()].filter((id) => id !== sourceId);
-	const sourceNi = idx.nodeById.get(sourceId);
-	const sourceNode = sourceNi !== void 0 ? graph.nodes[sourceNi] : graph.nodes.find((n) => n.id === sourceId);
-	for (const targetId of targets) yield* reconstructPaths(graph, prev, sourceNode, targetId);
+	const inMST = /* @__PURE__ */ new Set();
+	const mstEdges = [];
+	const candidates = new MinPriorityQueue((a, b) => a.weight - b.weight);
+	function addEdgesOf(nodeId) {
+		for (const eid of idx.outEdges.get(nodeId) ?? []) {
+			const ai = idx.edgeById.get(eid);
+			if (ai === void 0) continue;
+			const edge = graph.edges[ai];
+			if (!inMST.has(edge.targetId)) candidates.push({
+				weight: getWeight(edge),
+				edge
+			});
+		}
+		if (graph.type === "undirected") for (const eid of idx.inEdges.get(nodeId) ?? []) {
+			const ai = idx.edgeById.get(eid);
+			if (ai === void 0) continue;
+			const edge = graph.edges[ai];
+			if (!inMST.has(edge.sourceId)) candidates.push({
+				weight: getWeight(edge),
+				edge
+			});
+		}
+	}
+	const startId = graph.nodes[0].id;
+	inMST.add(startId);
+	addEdgesOf(startId);
+	while (candidates.size > 0 && inMST.size < graph.nodes.length) {
+		const { edge } = candidates.pop();
+		const targetId = graph.type === "undirected" && inMST.has(edge.targetId) ? edge.sourceId : edge.targetId;
+		if (inMST.has(targetId)) continue;
+		inMST.add(targetId);
+		mstEdges.push(edge);
+		addEdgesOf(targetId);
+	}
+	return mstEdges;
 }
-/**
-* Returns all shortest paths from a source node as an array.
-* Delegates to `genShortestPaths` internally.
-*
-* **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted).
-*
-* @example
-* ```ts
-* import { createGraph, getShortestPaths } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'bc', sourceId: 'b', targetId: 'c' },
-*   ],
-*   initialNodeId: 'a',
-* });
-*
-* const paths = getShortestPaths(graph);
-* // paths to 'b' and 'c' from 'a'
-* ```
-*/
-function getShortestPaths(graph, opts) {
-	return [...genShortestPaths(graph, opts)];
+function kruskalMST(graph, getWeight) {
+	const sorted = [...graph.edges].sort((a, b) => getWeight(a) - getWeight(b));
+	const parent = /* @__PURE__ */ new Map();
+	const rank = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) {
+		parent.set(node.id, node.id);
+		rank.set(node.id, 0);
+	}
+	function find(id) {
+		if (parent.get(id) !== id) parent.set(id, find(parent.get(id)));
+		return parent.get(id);
+	}
+	function union(a, b) {
+		const rootA = find(a);
+		const rootB = find(b);
+		if (rootA === rootB) return false;
+		if (rank.get(rootA) < rank.get(rootB)) parent.set(rootA, rootB);
+		else if (rank.get(rootA) > rank.get(rootB)) parent.set(rootB, rootA);
+		else {
+			parent.set(rootB, rootA);
+			rank.set(rootA, rank.get(rootA) + 1);
+		}
+		return true;
+	}
+	const mstEdges = [];
+	for (const edge of sorted) if (union(edge.sourceId, edge.targetId)) mstEdges.push(edge);
+	return mstEdges;
 }
-/**
-* Returns a single shortest path from source to target, or `undefined` if unreachable.
-*
-* **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted).
-*
-* @example
-* ```ts
-* import { createGraph, getShortestPath } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'bc', sourceId: 'b', targetId: 'c' },
-*   ],
-*   initialNodeId: 'a',
-* });
-*
-* const path = getShortestPath(graph, { to: 'c' });
-* // path.steps -> [{node: nodeB, edge: ...}, {node: nodeC, edge: ...}]
-* ```
-*/
-function getShortestPath(graph, opts) {
-	for (const path of genShortestPaths(graph, opts)) return path;
+
+//#endregion
+//#region src/algorithms/centrality.ts
+function getNodeIds(graph) {
+	return graph.nodes.map((node) => node.id);
 }
-/**
-* Returns all simple (acyclic) paths from a source node as an array.
-* Delegates to `genSimplePaths` internally.
-*
-* **O(V!)** worst-case (exponential in dense graphs).
-*
-* @example
-* ```ts
-* import { createGraph, getSimplePaths } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'bc', sourceId: 'b', targetId: 'c' },
-*     { id: 'ac', sourceId: 'a', targetId: 'c' },
-*   ],
-*   initialNodeId: 'a',
-* });
-*
-* const paths = getSimplePaths(graph, { to: 'c' });
-* // two paths: a->b->c and a->c
-* ```
-*/
-function getSimplePaths(graph, opts) {
-	return [...genSimplePaths(graph, opts)];
+function getNeighborIds(graph, nodeId) {
+	const idx = getIndex(graph);
+	const neighbors = [];
+	for (const edgeId of idx.outEdges.get(nodeId) ?? []) {
+		const edgeIndex = idx.edgeById.get(edgeId);
+		if (edgeIndex !== void 0) neighbors.push(graph.edges[edgeIndex].targetId);
+	}
+	if (graph.type === "undirected") for (const edgeId of idx.inEdges.get(nodeId) ?? []) {
+		const edgeIndex = idx.edgeById.get(edgeId);
+		if (edgeIndex !== void 0) neighbors.push(graph.edges[edgeIndex].sourceId);
+	}
+	return neighbors;
+}
+function getIncomingIds(graph, nodeId) {
+	const idx = getIndex(graph);
+	const incoming = [];
+	for (const edgeId of idx.inEdges.get(nodeId) ?? []) {
+		const edgeIndex = idx.edgeById.get(edgeId);
+		if (edgeIndex !== void 0) incoming.push(graph.edges[edgeIndex].sourceId);
+	}
+	if (graph.type === "undirected") for (const edgeId of idx.outEdges.get(nodeId) ?? []) {
+		const edgeIndex = idx.edgeById.get(edgeId);
+		if (edgeIndex !== void 0) incoming.push(graph.edges[edgeIndex].targetId);
+	}
+	return incoming;
+}
+function createEmptyScoreMap(graph) {
+	return Object.fromEntries(graph.nodes.map((node) => [node.id, 0]));
+}
+function normalizeVector(scores) {
+	const magnitude = Math.sqrt(Object.values(scores).reduce((sum, value) => sum + value * value, 0));
+	if (magnitude === 0) return scores;
+	for (const key of Object.keys(scores)) scores[key] /= magnitude;
+	return scores;
+}
+function maxDiff(previous, next) {
+	let diff = 0;
+	for (const key of Object.keys(next)) diff = Math.max(diff, Math.abs((previous[key] ?? 0) - next[key]));
+	return diff;
+}
+function getReachableDistances(graph, startId) {
+	const distances = /* @__PURE__ */ new Map();
+	const queue = [startId];
+	distances.set(startId, 0);
+	while (queue.length > 0) {
+		const currentId = queue.shift();
+		const currentDistance = distances.get(currentId);
+		for (const neighborId of getNeighborIds(graph, currentId)) {
+			if (distances.has(neighborId)) continue;
+			distances.set(neighborId, currentDistance + 1);
+			queue.push(neighborId);
+		}
+	}
+	return distances;
 }
 /**
-* Lazily yields all simple (acyclic) paths from a source node via DFS backtracking.
-* Use `getSimplePaths` for the full array.
+* Returns degree centrality scores for all nodes.
 *
-* **O(V!)** worst-case (exponential in dense graphs).
+* Degree centrality is the node degree normalized by `n - 1`.
 *
 * @example
 * ```ts
-* import { createGraph, genSimplePaths } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'bc', sourceId: 'b', targetId: 'c' },
-*     { id: 'ac', sourceId: 'a', targetId: 'c' },
-*   ],
-*   initialNodeId: 'a',
-* });
-*
-* for (const path of genSimplePaths(graph, { to: 'c' })) {
-*   console.log(path.steps.map(s => s.node.id));
-*   // ['b', 'c'] or ['c']
-* }
+* const scores = getDegreeCentrality(graph);
+* console.log(scores.a); // 0.5
 * ```
 */
-function* genSimplePaths(graph, opts) {
+function getDegreeCentrality(graph) {
+	const scale = graph.nodes.length > 1 ? 1 / (graph.nodes.length - 1) : 0;
 	const idx = getIndex(graph);
-	const sourceId = resolveFrom(graph, opts);
-	const sourceNi = idx.nodeById.get(sourceId);
-	const sourceNode = sourceNi !== void 0 ? graph.nodes[sourceNi] : graph.nodes.find((n) => n.id === sourceId);
-	const targetId = opts?.to;
-	const visited = /* @__PURE__ */ new Set();
-	const currentSteps = [];
-	function* dfsCollect(nodeId) {
-		visited.add(nodeId);
-		if (targetId !== void 0) {
-			if (nodeId === targetId) {
-				yield {
-					source: sourceNode,
-					steps: [...currentSteps]
-				};
-				visited.delete(nodeId);
-				return;
-			}
-		} else if (currentSteps.length > 0) yield {
-			source: sourceNode,
-			steps: [...currentSteps]
-		};
-		for (const { neighborId, edge } of getNeighborEdges(graph, nodeId)) if (!visited.has(neighborId)) {
-			const neighborNi = idx.nodeById.get(neighborId);
-			const neighborNode = neighborNi !== void 0 ? graph.nodes[neighborNi] : graph.nodes.find((n) => n.id === neighborId);
-			currentSteps.push({
-				edge,
-				node: neighborNode
-			});
-			yield* dfsCollect(neighborId);
-			currentSteps.pop();
-		}
-		visited.delete(nodeId);
+	const scores = createEmptyScoreMap(graph);
+	for (const node of graph.nodes) {
+		const outDegree = idx.outEdges.get(node.id)?.length ?? 0;
+		const inDegree = idx.inEdges.get(node.id)?.length ?? 0;
+		const degree = graph.type === "undirected" ? new Set([...idx.outEdges.get(node.id) ?? [], ...idx.inEdges.get(node.id) ?? []]).size : outDegree + inDegree;
+		scores[node.id] = degree * scale;
 	}
-	yield* dfsCollect(sourceId);
+	return scores;
 }
 /**
-* Returns a single simple (acyclic) path from source to target, or `undefined` if unreachable.
-*
-* **O(V + E)** typical, **O(V!)** worst-case.
-*
-* @example
-* ```ts
-* import { createGraph, getSimplePath } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'bc', sourceId: 'b', targetId: 'c' },
-*   ],
-*   initialNodeId: 'a',
-* });
+* Returns in-degree centrality scores for all nodes.
 *
-* const path = getSimplePath(graph, { to: 'c' });
-* // path.steps -> [{node: nodeB, edge: ...}, {node: nodeC, edge: ...}]
-* ```
+* In-degree centrality is the incoming degree normalized by `n - 1`.
 */
-function getSimplePath(graph, opts) {
-	for (const path of genSimplePaths(graph, opts)) return path;
+function getInDegreeCentrality(graph) {
+	const scale = graph.nodes.length > 1 ? 1 / (graph.nodes.length - 1) : 0;
+	const idx = getIndex(graph);
+	const scores = createEmptyScoreMap(graph);
+	for (const node of graph.nodes) scores[node.id] = (idx.inEdges.get(node.id)?.length ?? 0) * scale;
+	return scores;
 }
 /**
-* Returns strongly connected components using Tarjan's algorithm.
-* Only meaningful for directed graphs.
-*
-* **O(V + E)** time.
-*
-* @example
-* ```ts
-* import { createGraph, getStronglyConnectedComponents } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'ba', sourceId: 'b', targetId: 'a' },
-*     { id: 'bc', sourceId: 'b', targetId: 'c' },
-*   ],
-* });
+* Returns out-degree centrality scores for all nodes.
 *
-* const sccs = getStronglyConnectedComponents(graph);
-* // [[nodeA, nodeB], [nodeC]]
-* ```
+* Out-degree centrality is the outgoing degree normalized by `n - 1`.
 */
-function getStronglyConnectedComponents(graph) {
+function getOutDegreeCentrality(graph) {
+	const scale = graph.nodes.length > 1 ? 1 / (graph.nodes.length - 1) : 0;
 	const idx = getIndex(graph);
-	let indexCounter = 0;
-	const nodeIndex = /* @__PURE__ */ new Map();
-	const lowlink = /* @__PURE__ */ new Map();
-	const onStack = /* @__PURE__ */ new Set();
-	const stack = [];
-	const result = [];
-	function strongconnect(id) {
-		nodeIndex.set(id, indexCounter);
-		lowlink.set(id, indexCounter);
-		indexCounter++;
-		stack.push(id);
-		onStack.add(id);
-		for (const eid of idx.outEdges.get(id) ?? []) {
-			const ai = idx.edgeById.get(eid);
-			if (ai === void 0) continue;
-			const wId = graph.edges[ai].targetId;
-			if (!nodeIndex.has(wId)) {
-				strongconnect(wId);
-				lowlink.set(id, Math.min(lowlink.get(id), lowlink.get(wId)));
-			} else if (onStack.has(wId)) lowlink.set(id, Math.min(lowlink.get(id), nodeIndex.get(wId)));
-		}
-		if (lowlink.get(id) === nodeIndex.get(id)) {
-			const component = [];
-			let wId;
-			do {
-				wId = stack.pop();
-				onStack.delete(wId);
-				const ni = idx.nodeById.get(wId);
-				if (ni !== void 0) component.push(graph.nodes[ni]);
-			} while (wId !== id);
-			result.push(component);
-		}
-	}
-	for (const n of graph.nodes) if (!nodeIndex.has(n.id)) strongconnect(n.id);
-	return result;
+	const scores = createEmptyScoreMap(graph);
+	for (const node of graph.nodes) scores[node.id] = (idx.outEdges.get(node.id)?.length ?? 0) * scale;
+	return scores;
 }
 /**
-* Returns all elementary cycles as an array of paths.
-* Delegates to `genCycles` internally.
-*
-* **O((V + E) · C)** where C is the number of elementary cycles (can be exponential).
-*
-* @example
-* ```ts
-* import { createGraph, getCycles } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'ba', sourceId: 'b', targetId: 'a' },
-*   ],
-* });
+* Returns closeness centrality scores for all nodes.
 *
-* const cycles = getCycles(graph);
-* // one cycle: a -> b -> a
-* ```
+* Distances are computed over unweighted shortest paths using the graph's
+* existing directed or undirected edge semantics.
 */
-function getCycles(graph) {
-	return [...genCycles(graph)];
+function getClosenessCentrality(graph) {
+	const scores = createEmptyScoreMap(graph);
+	const order = graph.nodes.length;
+	for (const node of graph.nodes) {
+		const distances = getReachableDistances(graph, node.id);
+		distances.delete(node.id);
+		if (distances.size === 0) continue;
+		const totalDistance = [...distances.values()].reduce((sum, distance) => sum + distance, 0);
+		if (totalDistance === 0) continue;
+		const reachable = distances.size;
+		const closeness = reachable / totalDistance;
+		scores[node.id] = order > 1 ? closeness * (reachable / (order - 1)) : closeness;
+	}
+	return scores;
 }
 /**
-* Lazily yields elementary cycles one at a time.
-* Use `getCycles` for the full array.
-*
-* **O((V + E) · C)** where C is the number of elementary cycles (can be exponential).
-*
-* @example
-* ```ts
-* import { createGraph, genCycles } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'ba', sourceId: 'b', targetId: 'a' },
-*   ],
-* });
+* Returns betweenness centrality scores for all nodes.
 *
-* for (const cycle of genCycles(graph)) {
-*   console.log(cycle.steps.map(s => s.node.id)); // ['b', 'a']
-* }
-* ```
+* Uses Brandes' algorithm over unweighted shortest paths and returns
+* normalized scores.
 */
-function* genCycles(graph) {
-	if (graph.type === "undirected") yield* genCyclesUndirected(graph);
-	else yield* genCyclesDirected(graph);
-}
-function* genCyclesDirected(graph) {
-	const idx = getIndex(graph);
-	const sortedIds = graph.nodes.map((n) => n.id).sort();
-	for (let si = 0; si < sortedIds.length; si++) {
-		const startId = sortedIds[si];
-		const allowed = new Set(sortedIds.slice(si));
-		const visited = /* @__PURE__ */ new Set();
-		const steps = [];
-		const startNi = idx.nodeById.get(startId);
-		const startNode = graph.nodes[startNi];
-		const found = [];
-		function dfsFind(currentId) {
-			visited.add(currentId);
-			for (const eid of idx.outEdges.get(currentId) ?? []) {
-				const ai = idx.edgeById.get(eid);
-				if (ai === void 0) continue;
-				const e = graph.edges[ai];
-				const neighborId = e.targetId;
-				if (neighborId === startId && (steps.length > 0 || currentId === startId)) found.push({
-					source: startNode,
-					steps: [...steps, {
-						edge: e,
-						node: startNode
-					}]
-				});
-				else if (allowed.has(neighborId) && !visited.has(neighborId)) {
-					const ni = idx.nodeById.get(neighborId);
-					steps.push({
-						edge: e,
-						node: graph.nodes[ni]
-					});
-					dfsFind(neighborId);
-					steps.pop();
-				}
-			}
-			visited.delete(currentId);
+function getBetweennessCentrality(graph) {
+	const scores = createEmptyScoreMap(graph);
+	for (const source of graph.nodes) {
+		const stack = [];
+		const predecessors = /* @__PURE__ */ new Map();
+		const sigma = /* @__PURE__ */ new Map();
+		const distance = /* @__PURE__ */ new Map();
+		const queue = [source.id];
+		for (const node of graph.nodes) {
+			predecessors.set(node.id, []);
+			sigma.set(node.id, 0);
+			distance.set(node.id, -1);
 		}
-		dfsFind(startId);
-		yield* found;
-	}
-}
-function* genCyclesUndirected(graph) {
-	const idx = getIndex(graph);
-	const sortedIds = graph.nodes.map((n) => n.id).sort();
-	const seen = /* @__PURE__ */ new Set();
-	for (let si = 0; si < sortedIds.length; si++) {
-		const startId = sortedIds[si];
-		const allowed = new Set(sortedIds.slice(si));
-		const visited = /* @__PURE__ */ new Set();
-		const steps = [];
-		const startNi = idx.nodeById.get(startId);
-		const startNode = graph.nodes[startNi];
-		const found = [];
-		function dfsFind(currentId, parentId) {
-			visited.add(currentId);
-			for (const { neighborId, edge } of getNeighborEdgesAll(graph, currentId)) {
-				if (neighborId === parentId) {
-					parentId = null;
-					continue;
+		sigma.set(source.id, 1);
+		distance.set(source.id, 0);
+		while (queue.length > 0) {
+			const currentId = queue.shift();
+			stack.push(currentId);
+			for (const neighborId of getNeighborIds(graph, currentId)) {
+				if (distance.get(neighborId) === -1) {
+					queue.push(neighborId);
+					distance.set(neighborId, distance.get(currentId) + 1);
 				}
-				if (neighborId === startId && steps.length >= 2) {
-					const innerIds = steps.map((s) => s.node.id).sort().join(",");
-					if (!seen.has(innerIds)) {
-						seen.add(innerIds);
-						found.push({
-							source: startNode,
-							steps: [...steps, {
-								edge,
-								node: startNode
-							}]
-						});
-					}
-				} else if (allowed.has(neighborId) && !visited.has(neighborId)) {
-					const ni = idx.nodeById.get(neighborId);
-					steps.push({
-						edge,
-						node: graph.nodes[ni]
-					});
-					dfsFind(neighborId, currentId);
-					steps.pop();
+				if (distance.get(neighborId) === distance.get(currentId) + 1) {
+					sigma.set(neighborId, sigma.get(neighborId) + sigma.get(currentId));
+					predecessors.get(neighborId).push(currentId);
 				}
 			}
-			visited.delete(currentId);
 		}
-		dfsFind(startId, null);
-		yield* found;
-	}
-}
-/** Like getNeighborEdges but always includes both directions (for undirected cycle finding). */
-function getNeighborEdgesAll(graph, nodeId) {
-	const idx = getIndex(graph);
-	const result = [];
-	for (const eid of idx.outEdges.get(nodeId) ?? []) {
-		const ai = idx.edgeById.get(eid);
-		if (ai !== void 0) {
-			const e = graph.edges[ai];
-			result.push({
-				neighborId: e.targetId,
-				edge: e
-			});
+		const delta = /* @__PURE__ */ new Map();
+		for (const node of graph.nodes) delta.set(node.id, 0);
+		while (stack.length > 0) {
+			const nodeId = stack.pop();
+			const sigmaNode = sigma.get(nodeId);
+			if (sigmaNode === 0) continue;
+			for (const predecessorId of predecessors.get(nodeId)) {
+				const contribution = sigma.get(predecessorId) / sigmaNode * (1 + delta.get(nodeId));
+				delta.set(predecessorId, delta.get(predecessorId) + contribution);
+			}
+			if (nodeId !== source.id) scores[nodeId] += delta.get(nodeId);
 		}
 	}
-	for (const eid of idx.inEdges.get(nodeId) ?? []) {
-		const ai = idx.edgeById.get(eid);
-		if (ai !== void 0) {
-			const e = graph.edges[ai];
-			result.push({
-				neighborId: e.sourceId,
-				edge: e
-			});
-		}
+	const order = graph.nodes.length;
+	if (order <= 2) return scores;
+	const scale = graph.type === "undirected" ? 1 / ((order - 1) * (order - 2) / 2) : 1 / ((order - 1) * (order - 2));
+	for (const nodeId of Object.keys(scores)) {
+		if (graph.type === "undirected") scores[nodeId] /= 2;
+		scores[nodeId] *= scale;
 	}
-	return result;
+	return scores;
 }
 /**
-* Returns a single canonical preorder (DFS visit-order) sequence.
-* Visits neighbors in the order they appear in the adjacency list.
-*
-* **O(V + E)** time.
-*
-* @example
-* ```ts
-* import { createGraph, getPreorder } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'bc', sourceId: 'b', targetId: 'c' },
-*   ],
-*   initialNodeId: 'a',
-* });
+* Returns PageRank scores for all nodes.
 *
-* const order = getPreorder(graph);
-* // [nodeA, nodeB, nodeC]
-* ```
+* Uses power iteration with damping factor `alpha`.
 */
-function getPreorder(graph, opts) {
-	const idx = getIndex(graph);
-	const startId = resolveFrom(graph, opts);
-	const startNi = idx.nodeById.get(startId);
-	if (startNi === void 0) return [];
-	const visited = new Set([startId]);
-	const result = [graph.nodes[startNi]];
-	const stack = [startId];
-	while (stack.length > 0) {
-		const top = stack[stack.length - 1];
-		const next = getNeighborIds(graph, top).find((id) => !visited.has(id));
-		if (next === void 0) {
-			stack.pop();
-			continue;
+function getPageRank(graph, options) {
+	const nodeIds = getNodeIds(graph);
+	if (nodeIds.length === 0) return {};
+	const alpha = options?.alpha ?? .85;
+	const maxIterations = options?.maxIterations ?? 100;
+	const tolerance = options?.tolerance ?? 1e-6;
+	let scores = Object.fromEntries(nodeIds.map((nodeId) => [nodeId, 1 / nodeIds.length]));
+	for (let iteration = 0; iteration < maxIterations; iteration++) {
+		const nextScores = Object.fromEntries(nodeIds.map((nodeId) => [nodeId, (1 - alpha) / nodeIds.length]));
+		let danglingMass = 0;
+		for (const nodeId of nodeIds) {
+			const neighbors = getNeighborIds(graph, nodeId);
+			if (neighbors.length === 0) {
+				danglingMass += scores[nodeId];
+				continue;
+			}
+			const share = scores[nodeId] / neighbors.length;
+			for (const neighborId of neighbors) nextScores[neighborId] += alpha * share;
 		}
-		visited.add(next);
-		stack.push(next);
-		const ni = idx.nodeById.get(next);
-		if (ni !== void 0) result.push(graph.nodes[ni]);
+		if (danglingMass > 0) {
+			const share = alpha * danglingMass / nodeIds.length;
+			for (const nodeId of nodeIds) nextScores[nodeId] += share;
+		}
+		if (maxDiff(scores, nextScores) <= tolerance) {
+			scores = nextScores;
+			break;
+		}
+		scores = nextScores;
 	}
-	return result;
+	const total = Object.values(scores).reduce((sum, value) => sum + value, 0);
+	if (total !== 0) for (const nodeId of nodeIds) scores[nodeId] /= total;
+	return scores;
 }
 /**
-* Returns a single canonical postorder (DFS finish-order) sequence.
-* Visits neighbors in the order they appear in the adjacency list.
-*
-* **O(V + E)** time.
-*
-* @example
-* ```ts
-* import { createGraph, getPostorder } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'bc', sourceId: 'b', targetId: 'c' },
-*   ],
-*   initialNodeId: 'a',
-* });
+* Returns HITS hub and authority scores for all nodes.
 *
-* const order = getPostorder(graph);
-* // [nodeC, nodeB, nodeA]
-* ```
+* Uses power iteration and L2 normalization per iteration.
 */
-function getPostorder(graph, opts) {
-	const idx = getIndex(graph);
-	const startId = resolveFrom(graph, opts);
-	if (idx.nodeById.get(startId) === void 0) return [];
-	const visited = new Set([startId]);
-	const result = [];
-	const stack = [startId];
-	while (stack.length > 0) {
-		const top = stack[stack.length - 1];
-		const next = getNeighborIds(graph, top).find((id) => !visited.has(id));
-		if (next === void 0) {
-			stack.pop();
-			const ni = idx.nodeById.get(top);
-			if (ni !== void 0) result.push(graph.nodes[ni]);
-			continue;
-		}
-		visited.add(next);
-		stack.push(next);
+function getHITS(graph, options) {
+	const nodeIds = getNodeIds(graph);
+	if (nodeIds.length === 0) return {
+		hubs: {},
+		authorities: {}
+	};
+	const maxIterations = options?.maxIterations ?? 100;
+	const tolerance = options?.tolerance ?? 1e-6;
+	let hubs = Object.fromEntries(nodeIds.map((nodeId) => [nodeId, 1]));
+	let authorities = createEmptyScoreMap(graph);
+	for (let iteration = 0; iteration < maxIterations; iteration++) {
+		const nextAuthorities = createEmptyScoreMap(graph);
+		for (const nodeId of nodeIds) for (const predecessorId of getIncomingIds(graph, nodeId)) nextAuthorities[nodeId] += hubs[predecessorId];
+		normalizeVector(nextAuthorities);
+		const nextHubs = createEmptyScoreMap(graph);
+		for (const nodeId of nodeIds) for (const neighborId of getNeighborIds(graph, nodeId)) nextHubs[nodeId] += nextAuthorities[neighborId];
+		normalizeVector(nextHubs);
+		const hubDiff = maxDiff(hubs, nextHubs);
+		const authorityDiff = maxDiff(authorities, nextAuthorities);
+		hubs = nextHubs;
+		authorities = nextAuthorities;
+		if (Math.max(hubDiff, authorityDiff) <= tolerance) break;
 	}
-	return result;
+	return {
+		hubs,
+		authorities
+	};
 }
 /**
-* Returns all possible preorder sequences as an array. Can be exponential -- prefer `genPreorders`.
-*
-* **O(V! · V)** worst-case (exponential).
-*
-* @example
-* ```ts
-* import { createGraph, getPreorders } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'ac', sourceId: 'a', targetId: 'c' },
-*   ],
-*   initialNodeId: 'a',
-* });
+* Returns eigenvector centrality scores for all nodes.
 *
-* const allOrders = getPreorders(graph);
-* // [[nodeA, nodeB, nodeC], [nodeA, nodeC, nodeB]]
-* ```
+* Uses power iteration over incoming neighbors for directed graphs and
+* undirected adjacency for undirected graphs.
 */
-function getPreorders(graph, opts) {
-	return [...genPreorders(graph, opts)];
+function getEigenvectorCentrality(graph, options) {
+	const nodeIds = getNodeIds(graph);
+	if (nodeIds.length === 0) return {};
+	const maxIterations = options?.maxIterations ?? 100;
+	const tolerance = options?.tolerance ?? 1e-6;
+	let scores = Object.fromEntries(nodeIds.map((nodeId) => [nodeId, 1]));
+	normalizeVector(scores);
+	for (let iteration = 0; iteration < maxIterations; iteration++) {
+		const nextScores = createEmptyScoreMap(graph);
+		for (const nodeId of nodeIds) for (const predecessorId of getIncomingIds(graph, nodeId)) nextScores[nodeId] += scores[predecessorId];
+		normalizeVector(nextScores);
+		const diff = maxDiff(scores, nextScores);
+		scores = nextScores;
+		if (diff <= tolerance) break;
+	}
+	return scores;
 }
-/**
-* Returns all possible postorder sequences as an array. Can be exponential -- prefer `genPostorders`.
-*
-* **O(V! · V)** worst-case (exponential).
-*
-* @example
-* ```ts
-* import { createGraph, getPostorders } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'ac', sourceId: 'a', targetId: 'c' },
-*   ],
-*   initialNodeId: 'a',
-* });
-*
-* const allOrders = getPostorders(graph);
-* // [[nodeB, nodeC, nodeA], [nodeC, nodeB, nodeA]]
-* ```
-*/
-function getPostorders(graph, opts) {
-	return [...genPostorders(graph, opts)];
+
+//#endregion
+//#region src/algorithms/community.ts
+function getUndirectedNeighbors$1(graph, nodeId) {
+	const idx = getIndex(graph);
+	const neighbors = [];
+	for (const edgeId of idx.outEdges.get(nodeId) ?? []) {
+		const edgeIndex = idx.edgeById.get(edgeId);
+		if (edgeIndex !== void 0) neighbors.push({
+			nodeId: graph.edges[edgeIndex].targetId,
+			edgeId
+		});
+	}
+	for (const edgeId of idx.inEdges.get(nodeId) ?? []) {
+		const edgeIndex = idx.edgeById.get(edgeId);
+		if (edgeIndex !== void 0) neighbors.push({
+			nodeId: graph.edges[edgeIndex].sourceId,
+			edgeId
+		});
+	}
+	return neighbors;
 }
-/**
-* Lazily yields all possible preorder (DFS visit-order) sequences.
-* Different neighbor exploration orders yield different sequences.
-* Use `getPreorder()` for a single canonical ordering.
-*
-* **O(V! · V)** worst-case (exponential).
-*
-* @example
-* ```ts
-* import { createGraph, genPreorders } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'ac', sourceId: 'a', targetId: 'c' },
-*   ],
-*   initialNodeId: 'a',
-* });
-*
-* for (const order of genPreorders(graph)) {
-*   console.log(order.map(n => n.id));
-*   // ['a', 'b', 'c'] or ['a', 'c', 'b']
-* }
-* ```
-*/
-function* genPreorders(graph, opts) {
+function getUndirectedConnectedComponents(graph) {
 	const idx = getIndex(graph);
-	const startId = resolveFrom(graph, opts);
-	const startNi = idx.nodeById.get(startId);
-	const startNode = startNi !== void 0 ? graph.nodes[startNi] : void 0;
-	if (!startNode) return;
-	const queue = [{
-		visited: new Set([startId]),
-		preorder: [startNode],
-		dfsStack: [startId]
-	}];
-	while (queue.length > 0) {
-		const frame = queue.pop();
-		const { visited, dfsStack } = frame;
-		let { preorder } = frame;
-		let branched = false;
-		while (dfsStack.length > 0) {
-			const top = dfsStack[dfsStack.length - 1];
-			const unvisited = getNeighborIds(graph, top).filter((id) => !visited.has(id));
-			if (unvisited.length === 0) {
-				dfsStack.pop();
-				continue;
+	const visited = /* @__PURE__ */ new Set();
+	const communities = [];
+	for (const node of graph.nodes) {
+		if (visited.has(node.id)) continue;
+		const community = [];
+		const queue = [node.id];
+		visited.add(node.id);
+		while (queue.length > 0) {
+			const currentId = queue.shift();
+			const nodeIndex = idx.nodeById.get(currentId);
+			if (nodeIndex !== void 0) community.push(graph.nodes[nodeIndex]);
+			for (const neighbor of getUndirectedNeighbors$1(graph, currentId)) {
+				if (visited.has(neighbor.nodeId)) continue;
+				visited.add(neighbor.nodeId);
+				queue.push(neighbor.nodeId);
 			}
-			for (const nextId of unvisited) {
-				const ni = idx.nodeById.get(nextId);
-				if (ni === void 0) continue;
-				const newVisited = new Set(visited);
-				newVisited.add(nextId);
-				queue.push({
-					visited: newVisited,
-					preorder: [...preorder, graph.nodes[ni]],
-					dfsStack: [...dfsStack, nextId]
-				});
+		}
+		communities.push(community.sort((a, b) => a.id.localeCompare(b.id)));
+	}
+	return communities.sort((a, b) => a[0].id.localeCompare(b[0].id));
+}
+function getNodeMap(graph) {
+	return new Map(graph.nodes.map((node) => [node.id, node]));
+}
+function normalizeCommunities(graph, labels) {
+	const nodeMap = getNodeMap(graph);
+	const grouped = /* @__PURE__ */ new Map();
+	for (const [nodeId, label] of Object.entries(labels)) {
+		if (!grouped.has(label)) grouped.set(label, []);
+		const node = nodeMap.get(nodeId);
+		if (node) grouped.get(label).push(node);
+	}
+	return [...grouped.values()].map((community) => community.sort((a, b) => a.id.localeCompare(b.id))).sort((a, b) => a[0].id.localeCompare(b[0].id));
+}
+function getEdgeBetweenness(graph) {
+	const scores = Object.fromEntries(graph.edges.map((edge) => [edge.id, 0]));
+	for (const source of graph.nodes) {
+		const stack = [];
+		const predecessors = /* @__PURE__ */ new Map();
+		const sigma = /* @__PURE__ */ new Map();
+		const distance = /* @__PURE__ */ new Map();
+		const queue = [source.id];
+		for (const node of graph.nodes) {
+			predecessors.set(node.id, []);
+			sigma.set(node.id, 0);
+			distance.set(node.id, -1);
+		}
+		sigma.set(source.id, 1);
+		distance.set(source.id, 0);
+		while (queue.length > 0) {
+			const currentId = queue.shift();
+			stack.push(currentId);
+			for (const neighbor of getUndirectedNeighbors$1(graph, currentId)) {
+				if (distance.get(neighbor.nodeId) === -1) {
+					queue.push(neighbor.nodeId);
+					distance.set(neighbor.nodeId, distance.get(currentId) + 1);
+				}
+				if (distance.get(neighbor.nodeId) === distance.get(currentId) + 1) {
+					sigma.set(neighbor.nodeId, sigma.get(neighbor.nodeId) + sigma.get(currentId));
+					predecessors.get(neighbor.nodeId).push({
+						nodeId: currentId,
+						edgeId: neighbor.edgeId
+					});
+				}
+			}
+		}
+		const delta = /* @__PURE__ */ new Map();
+		for (const node of graph.nodes) delta.set(node.id, 0);
+		while (stack.length > 0) {
+			const nodeId = stack.pop();
+			const sigmaNode = sigma.get(nodeId);
+			if (sigmaNode === 0) continue;
+			for (const predecessor of predecessors.get(nodeId)) {
+				const contribution = sigma.get(predecessor.nodeId) / sigmaNode * (1 + delta.get(nodeId));
+				scores[predecessor.edgeId] += contribution;
+				delta.set(predecessor.nodeId, delta.get(predecessor.nodeId) + contribution);
 			}
-			branched = true;
-			break;
 		}
-		if (!branched) yield preorder;
 	}
+	for (const edgeId of Object.keys(scores)) scores[edgeId] /= 2;
+	return scores;
+}
+function cloneWithEdges(graph, edges) {
+	return {
+		...graph,
+		nodes: [...graph.nodes],
+		edges
+	};
+}
+function toCommunityIds(communities) {
+	return communities.map((community) => new Set(community.map((node) => node.id)));
 }
 /**
-* Lazily yields all possible postorder (DFS finish-order) sequences.
-* Different neighbor exploration orders yield different sequences.
-* Use `getPostorder()` for a single canonical ordering.
-*
-* **O(V! · V)** worst-case (exponential).
-*
-* @example
-* ```ts
-* import { createGraph, genPostorders } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'ac', sourceId: 'a', targetId: 'c' },
-*   ],
-*   initialNodeId: 'a',
-* });
+* Returns label-propagation communities for the graph.
 *
-* for (const order of genPostorders(graph)) {
-*   console.log(order.map(n => n.id));
-*   // ['b', 'c', 'a'] or ['c', 'b', 'a']
-* }
-* ```
+* The implementation is deterministic: ties are broken by lexicographic label
+* order so test results remain stable.
 */
-function* genPostorders(graph, opts) {
-	const idx = getIndex(graph);
-	const startId = resolveFrom(graph, opts);
-	if (idx.nodeById.get(startId) === void 0) return;
-	const queue = [{
-		visited: new Set([startId]),
-		postorder: [],
-		dfsStack: [startId]
-	}];
-	while (queue.length > 0) {
-		const frame = queue.pop();
-		const { visited, dfsStack } = frame;
-		let { postorder } = frame;
-		let branched = false;
-		while (dfsStack.length > 0) {
-			const top = dfsStack[dfsStack.length - 1];
-			const unvisited = getNeighborIds(graph, top).filter((id) => !visited.has(id));
-			if (unvisited.length === 0) {
-				dfsStack.pop();
-				const ni = idx.nodeById.get(top);
-				if (ni !== void 0) postorder = [...postorder, graph.nodes[ni]];
-				continue;
+function getLabelPropagationCommunities(graph, options) {
+	if (graph.nodes.length === 0) return [];
+	const maxIterations = options?.maxIterations ?? 50;
+	let labels = Object.fromEntries(graph.nodes.map((node) => [node.id, node.id]));
+	const nodeIds = graph.nodes.map((node) => node.id).sort();
+	for (let iteration = 0; iteration < maxIterations; iteration++) {
+		const nextLabels = { ...labels };
+		let changed = false;
+		for (const nodeId of nodeIds) {
+			const counts = /* @__PURE__ */ new Map();
+			for (const neighbor of getUndirectedNeighbors$1(graph, nodeId)) {
+				const label = labels[neighbor.nodeId];
+				counts.set(label, (counts.get(label) ?? 0) + 1);
 			}
-			for (const nextId of unvisited) {
-				if (idx.nodeById.get(nextId) === void 0) continue;
-				const newVisited = new Set(visited);
-				newVisited.add(nextId);
-				queue.push({
-					visited: newVisited,
-					postorder: [...postorder],
-					dfsStack: [...dfsStack, nextId]
-				});
+			if (counts.size === 0) continue;
+			const bestLabel = [...counts.entries()].sort((a, b) => {
+				if (b[1] !== a[1]) return b[1] - a[1];
+				return a[0].localeCompare(b[0]);
+			})[0][0];
+			if (bestLabel !== labels[nodeId]) {
+				nextLabels[nodeId] = bestLabel;
+				changed = true;
 			}
-			branched = true;
-			break;
 		}
-		if (!branched) yield postorder;
+		labels = nextLabels;
+		if (!changed) break;
 	}
+	return normalizeCommunities(graph, labels);
 }
 /**
-* Returns a minimum spanning tree of the graph.
-* Only meaningful for connected undirected graphs (or the component reachable
-* from an arbitrary start node in directed graphs).
-*
-* **O(E log E)** using either edge sorting (Kruskal) or a min-heap (Prim).
-*
-* @example
-* ```ts
-* import { createGraph, getMinimumSpanningTree } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   type: 'undirected',
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b', data: { weight: 1 } },
-*     { id: 'bc', sourceId: 'b', targetId: 'c', data: { weight: 2 } },
-*     { id: 'ac', sourceId: 'a', targetId: 'c', data: { weight: 3 } },
-*   ],
-* });
-*
-* const mst = getMinimumSpanningTree(graph, {
-*   getWeight: (e) => e.data.weight,
-* });
-* // mst has edges 'ab' and 'bc' (total weight 3)
-* ```
+* Lazily yields Girvan-Newman community splits as edge betweenness removes
+* bridge-like edges from the graph.
 */
-function getMinimumSpanningTree(graph, opts) {
-	const algorithm = opts?.algorithm ?? "prim";
-	const getWeight = opts?.getWeight ?? ((e) => e.weight ?? 1);
-	const mstEdges = algorithm === "kruskal" ? kruskalMST(graph, getWeight) : primMST(graph, getWeight);
-	return createGraph({
-		id: graph.id,
-		type: graph.type,
-		initialNodeId: graph.initialNodeId ?? void 0,
-		nodes: graph.nodes.map((n) => ({
-			id: n.id,
-			parentId: n.parentId ?? void 0,
-			initialNodeId: n.initialNodeId ?? void 0,
-			label: n.label,
-			data: n.data
-		})),
-		edges: mstEdges.map((e) => ({
-			id: e.id,
-			sourceId: e.sourceId,
-			targetId: e.targetId,
-			label: e.label,
-			data: e.data,
-			...e.weight !== void 0 && { weight: e.weight }
-		}))
-	});
-}
-function primMST(graph, getWeight) {
-	if (graph.nodes.length === 0) return [];
-	const idx = getIndex(graph);
-	const inMST = /* @__PURE__ */ new Set();
-	const mstEdges = [];
-	const candidates = new MinPriorityQueue((a, b) => a.weight - b.weight);
-	function addEdgesOf(nodeId) {
-		for (const eid of idx.outEdges.get(nodeId) ?? []) {
-			const ai = idx.edgeById.get(eid);
-			if (ai === void 0) continue;
-			const e = graph.edges[ai];
-			if (!inMST.has(e.targetId)) candidates.push({
-				weight: getWeight(e),
-				edge: e
-			});
-		}
-		if (graph.type === "undirected") for (const eid of idx.inEdges.get(nodeId) ?? []) {
-			const ai = idx.edgeById.get(eid);
-			if (ai === void 0) continue;
-			const e = graph.edges[ai];
-			if (!inMST.has(e.sourceId)) candidates.push({
-				weight: getWeight(e),
-				edge: e
-			});
+function* genGirvanNewmanCommunities(graph, options) {
+	if (graph.nodes.length === 0 || graph.edges.length === 0) return;
+	const maxLevels = options?.maxLevels ?? Number.POSITIVE_INFINITY;
+	let yielded = 0;
+	let edges = [...graph.edges];
+	let previousCount = getUndirectedConnectedComponents(graph).length;
+	while (edges.length > 0 && yielded < maxLevels) {
+		const betweenness = getEdgeBetweenness(cloneWithEdges(graph, edges));
+		const maxScore = Math.max(...Object.values(betweenness));
+		edges = edges.filter((edge) => betweenness[edge.id] < maxScore - 1e-12);
+		const components = getUndirectedConnectedComponents(cloneWithEdges(graph, edges));
+		if (components.length > previousCount) {
+			yield components;
+			yielded++;
+			previousCount = components.length;
 		}
 	}
-	const startId = graph.nodes[0].id;
-	inMST.add(startId);
-	addEdgesOf(startId);
-	while (candidates.size > 0 && inMST.size < graph.nodes.length) {
-		const { edge } = candidates.pop();
-		const targetId = graph.type === "undirected" && inMST.has(edge.targetId) ? edge.sourceId : edge.targetId;
-		if (inMST.has(targetId)) continue;
-		inMST.add(targetId);
-		mstEdges.push(edge);
-		addEdgesOf(targetId);
+}
+/**
+* Returns the requested Girvan-Newman split level eagerly.
+*
+* `level: 1` returns the first split yielded by `genGirvanNewmanCommunities`.
+*/
+function getGirvanNewmanCommunities(graph, options) {
+	if (graph.nodes.length === 0) return [];
+	const targetLevel = options?.level ?? 1;
+	if (targetLevel <= 0) return getUndirectedConnectedComponents(graph);
+	let last = getUndirectedConnectedComponents(graph);
+	let level = 0;
+	for (const partition of genGirvanNewmanCommunities(graph, { maxLevels: targetLevel })) {
+		last = partition;
+		level++;
+		if (level >= targetLevel) break;
 	}
-	return mstEdges;
+	return last;
 }
-function kruskalMST(graph, getWeight) {
-	const sorted = [...graph.edges].sort((a, b) => getWeight(a) - getWeight(b));
-	const parent = /* @__PURE__ */ new Map();
-	const rank = /* @__PURE__ */ new Map();
-	for (const n of graph.nodes) {
-		parent.set(n.id, n.id);
-		rank.set(n.id, 0);
-	}
-	function find(x) {
-		if (parent.get(x) !== x) parent.set(x, find(parent.get(x)));
-		return parent.get(x);
-	}
-	function union(x, y) {
-		const rx = find(x), ry = find(y);
-		if (rx === ry) return false;
-		if (rank.get(rx) < rank.get(ry)) parent.set(rx, ry);
-		else if (rank.get(rx) > rank.get(ry)) parent.set(ry, rx);
-		else {
-			parent.set(ry, rx);
-			rank.set(rx, rank.get(rx) + 1);
+/**
+* Returns the modularity score for a partition of communities.
+*
+* Community algorithms in this module treat the graph as undirected.
+*/
+function getModularity(graph, communities) {
+	if (graph.edges.length === 0 || communities.length === 0) return 0;
+	const nodeIds = graph.nodes.map((node) => node.id);
+	const adjacency = /* @__PURE__ */ new Map();
+	const degree = Object.fromEntries(nodeIds.map((nodeId) => [nodeId, 0]));
+	for (const nodeId of nodeIds) adjacency.set(nodeId, /* @__PURE__ */ new Map());
+	for (const edge of graph.edges) {
+		adjacency.get(edge.sourceId).set(edge.targetId, (adjacency.get(edge.sourceId).get(edge.targetId) ?? 0) + 1);
+		adjacency.get(edge.targetId).set(edge.sourceId, (adjacency.get(edge.targetId).get(edge.sourceId) ?? 0) + 1);
+		degree[edge.sourceId]++;
+		degree[edge.targetId]++;
+	}
+	const m2 = graph.edges.length * 2;
+	let modularity = 0;
+	for (const community of toCommunityIds(communities)) {
+		const ids = [...community];
+		for (const i of ids) for (const j of ids) {
+			const aij = adjacency.get(i).get(j) ?? 0;
+			modularity += aij - degree[i] * degree[j] / m2;
 		}
-		return true;
 	}
-	const mstEdges = [];
-	for (const e of sorted) if (union(e.sourceId, e.targetId)) mstEdges.push(e);
-	return mstEdges;
+	return modularity / m2;
 }
 /**
-* Returns shortest paths between all pairs of nodes.
-* Algorithm 'dijkstra' (default): runs getShortestPaths per source node.
-* Algorithm 'floyd-warshall': classic dynamic programming.
-*
-* **O(V · (V + E) log V)** (Dijkstra) or **O(V³)** (Floyd-Warshall).
-*
-* @example
-* ```ts
-* import { createGraph, getAllPairsShortestPaths } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'bc', sourceId: 'b', targetId: 'c' },
-*   ],
-* });
-*
-* const allPaths = getAllPairsShortestPaths(graph);
-* // paths for every reachable (source, target) pair
-* ```
+* Returns communities found by greedily merging partitions that improve
+* modularity the most at each step.
 */
-function getAllPairsShortestPaths(graph, opts) {
-	if ((opts?.algorithm ?? "dijkstra") === "floyd-warshall") return floydWarshallAllPaths(graph, opts?.getWeight);
-	return dijkstraAllPaths(graph, opts?.getWeight);
+function getGreedyModularityCommunities(graph) {
+	if (graph.nodes.length === 0) return [];
+	let communities = graph.nodes.map((node) => [node]);
+	let currentScore = getModularity(graph, communities);
+	while (communities.length > 1) {
+		let bestScore = currentScore;
+		let bestMerge;
+		for (let i = 0; i < communities.length; i++) for (let j = i + 1; j < communities.length; j++) {
+			const merged = communities.filter((_, index) => index !== i && index !== j);
+			merged.push([...communities[i], ...communities[j]].sort((a, b) => a.id.localeCompare(b.id)));
+			const score = getModularity(graph, merged);
+			if (score > bestScore + 1e-12) {
+				bestScore = score;
+				bestMerge = merged;
+			}
+		}
+		if (!bestMerge) break;
+		communities = bestMerge.sort((a, b) => a[0].id.localeCompare(b[0].id));
+		currentScore = bestScore;
+	}
+	return communities;
 }
-function dijkstraAllPaths(graph, getWeight) {
-	const results = [];
-	for (const node of graph.nodes) {
-		const paths = getShortestPaths(graph, {
-			from: node.id,
-			getWeight
+
+//#endregion
+//#region src/algorithms/connectivity.ts
+function getUndirectedNeighbors(graph, nodeId) {
+	const idx = getIndex(graph);
+	const neighbors = [];
+	for (const edgeId of idx.outEdges.get(nodeId) ?? []) {
+		const edgeIndex = idx.edgeById.get(edgeId);
+		if (edgeIndex !== void 0) neighbors.push({
+			nodeId: graph.edges[edgeIndex].targetId,
+			edgeId
+		});
+	}
+	for (const edgeId of idx.inEdges.get(nodeId) ?? []) {
+		const edgeIndex = idx.edgeById.get(edgeId);
+		if (edgeIndex !== void 0) neighbors.push({
+			nodeId: graph.edges[edgeIndex].sourceId,
+			edgeId
 		});
-		results.push(...paths);
 	}
-	return results;
+	return neighbors;
 }
-function floydWarshallAllPaths(graph, getWeight) {
-	const idx = getIndex(graph);
-	const w = getWeight ?? ((e) => e.weight ?? 1);
-	const nodeIds = graph.nodes.map((n$1) => n$1.id);
-	const n = nodeIds.length;
-	const idxOf = /* @__PURE__ */ new Map();
-	for (let i = 0; i < n; i++) idxOf.set(nodeIds[i], i);
-	const INF = Infinity;
-	const dist = Array.from({ length: n }, () => Array(n).fill(INF));
-	const prev = Array.from({ length: n }, () => Array.from({ length: n }, () => []));
-	for (let i = 0; i < n; i++) dist[i][i] = 0;
-	for (const e of graph.edges) {
-		const u = idxOf.get(e.sourceId);
-		const v = idxOf.get(e.targetId);
-		const weight = w(e);
-		if (weight < dist[u][v]) {
-			dist[u][v] = weight;
-			prev[u][v] = [{
-				from: u,
-				edge: e
-			}];
-		} else if (weight === dist[u][v] && weight < INF) prev[u][v].push({
-			from: u,
-			edge: e
-		});
-		if (graph.type === "undirected") {
-			if (weight < dist[v][u]) {
-				dist[v][u] = weight;
-				prev[v][u] = [{
-					from: v,
-					edge: e
-				}];
-			} else if (weight === dist[v][u] && weight < INF) prev[v][u].push({
-				from: v,
-				edge: e
-			});
+function popComponentUntil(state, stopEdgeId) {
+	const nodeIds = /* @__PURE__ */ new Set();
+	while (state.edgeStack.length > 0) {
+		const edgeId = state.edgeStack.pop();
+		const edge = state.edgeById.get(edgeId);
+		if (edge) {
+			nodeIds.add(edge.sourceId);
+			nodeIds.add(edge.targetId);
 		}
+		if (edgeId === stopEdgeId) break;
 	}
-	for (let k = 0; k < n; k++) for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) {
-		if (dist[i][k] === INF || dist[k][j] === INF) continue;
-		const newDist = dist[i][k] + dist[k][j];
-		if (newDist < dist[i][j]) {
-			dist[i][j] = newDist;
-			prev[i][j] = prev[k][j].map((p) => ({ ...p }));
-		} else if (newDist === dist[i][j] && newDist < INF) {
-			for (const p of prev[k][j]) if (!prev[i][j].some((x) => x.edge.id === p.edge.id)) prev[i][j].push({ ...p });
+	if (nodeIds.size > 0) state.components.push(nodeIds);
+}
+function finalizeRemainingComponent(state) {
+	if (state.edgeStack.length === 0) return;
+	const nodeIds = /* @__PURE__ */ new Set();
+	while (state.edgeStack.length > 0) {
+		const edge = state.edgeById.get(state.edgeStack.pop());
+		if (edge) {
+			nodeIds.add(edge.sourceId);
+			nodeIds.add(edge.targetId);
 		}
 	}
-	const results = [];
-	for (let i = 0; i < n; i++) {
-		const sourceNi = idx.nodeById.get(nodeIds[i]);
-		if (sourceNi === void 0) continue;
-		const sourceNode = graph.nodes[sourceNi];
-		for (let j = 0; j < n; j++) {
-			if (i === j || dist[i][j] === INF) continue;
-			const paths = fwReconstruct(graph, prev, idxOf, nodeIds, sourceNode, i, j);
-			results.push(...paths);
+	if (nodeIds.size > 0) state.components.push(nodeIds);
+}
+function traverseConnectivity(graph, nodeId, parentEdgeId, state) {
+	state.time += 1;
+	state.disc.set(nodeId, state.time);
+	state.low.set(nodeId, state.time);
+	let childCount = 0;
+	for (const neighbor of getUndirectedNeighbors(graph, nodeId)) {
+		if (neighbor.edgeId === parentEdgeId) continue;
+		if (!state.disc.has(neighbor.nodeId)) {
+			childCount += 1;
+			state.edgeStack.push(neighbor.edgeId);
+			traverseConnectivity(graph, neighbor.nodeId, neighbor.edgeId, state);
+			state.low.set(nodeId, Math.min(state.low.get(nodeId), state.low.get(neighbor.nodeId)));
+			if (state.low.get(neighbor.nodeId) > state.disc.get(nodeId)) state.bridges.add(neighbor.edgeId);
+			if (parentEdgeId !== null && state.low.get(neighbor.nodeId) >= state.disc.get(nodeId)) {
+				state.articulationPoints.add(nodeId);
+				popComponentUntil(state, neighbor.edgeId);
+			}
+		} else if (state.disc.get(neighbor.nodeId) < state.disc.get(nodeId)) {
+			state.edgeStack.push(neighbor.edgeId);
+			state.low.set(nodeId, Math.min(state.low.get(nodeId), state.disc.get(neighbor.nodeId)));
 		}
 	}
-	return results;
+	if (parentEdgeId === null && childCount > 1) state.articulationPoints.add(nodeId);
 }
-function fwReconstruct(graph, prev, idxOf, nodeIds, sourceNode, sourceIdx, targetIdx) {
-	if (sourceIdx === targetIdx) return [{
-		source: sourceNode,
-		steps: []
-	}];
-	const preds = prev[sourceIdx][targetIdx];
-	if (preds.length === 0) return [];
-	const targetNi = getIndex(graph).nodeById.get(nodeIds[targetIdx]);
-	if (targetNi === void 0) return [];
-	const targetNode = graph.nodes[targetNi];
-	const results = [];
-	for (const { from, edge } of preds) {
-		const prefixPaths = fwReconstruct(graph, prev, idxOf, nodeIds, sourceNode, sourceIdx, from);
-		for (const prefix of prefixPaths) results.push({
-			source: sourceNode,
-			steps: [...prefix.steps, {
-				edge,
-				node: targetNode
-			}]
-		});
+function analyzeConnectivity(graph) {
+	const state = {
+		time: 0,
+		disc: /* @__PURE__ */ new Map(),
+		low: /* @__PURE__ */ new Map(),
+		edgeStack: [],
+		bridges: /* @__PURE__ */ new Set(),
+		articulationPoints: /* @__PURE__ */ new Set(),
+		components: [],
+		nodeById: new Map(graph.nodes.map((node) => [node.id, node])),
+		edgeById: new Map(graph.edges.map((edge) => [edge.id, edge]))
+	};
+	for (const node of graph.nodes) {
+		if (state.disc.has(node.id)) continue;
+		traverseConnectivity(graph, node.id, null, state);
+		finalizeRemainingComponent(state);
 	}
-	return results;
+	return state;
 }
 /**
-* Returns a shortest path using A* search with an admissible heuristic.
-* More efficient than Dijkstra when a good heuristic is available.
-*
-* **O((V + E) log V)** time with a good heuristic; degrades to Dijkstra
-* with `heuristic: () => 0`.
+* Returns bridge edges whose removal disconnects the graph.
 *
-* @example
-* ```ts
-* import { createGraph, getAStarPath } from '@statelyai/graph';
+* Connectivity algorithms in this module treat the graph as undirected.
+*/
+function getBridges(graph) {
+	if (graph.edges.length === 0) return [];
+	const state = analyzeConnectivity(graph);
+	return [...state.bridges].map((edgeId) => state.edgeById.get(edgeId)).sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+* Returns articulation points (cut vertices) for the graph.
 *
-* const graph = createGraph({
-*   nodes: [
-*     { id: 'a', x: 0, y: 0 },
-*     { id: 'b', x: 1, y: 0 },
-*     { id: 'c', x: 1, y: 1 },
-*   ],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b', weight: 1 },
-*     { id: 'bc', sourceId: 'b', targetId: 'c', weight: 1 },
-*     { id: 'ac', sourceId: 'a', targetId: 'c', weight: 3 },
-*   ],
-* });
+* Connectivity algorithms in this module treat the graph as undirected.
+*/
+function getArticulationPoints(graph) {
+	if (graph.nodes.length === 0) return [];
+	const state = analyzeConnectivity(graph);
+	return [...state.articulationPoints].map((nodeId) => state.nodeById.get(nodeId)).sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+* Returns biconnected components as arrays of nodes.
 *
-* const path = getAStarPath(graph, {
-*   from: 'a',
-*   to: 'c',
-*   heuristic: (nodeId) => {
-*     const node = graph.nodes.find(n => n.id === nodeId)!;
-*     const target = graph.nodes.find(n => n.id === 'c')!;
-*     return Math.abs(node.x! - target.x!) + Math.abs(node.y! - target.y!);
-*   },
-* });
-* // path: a -> b -> c (weight 2, cheaper than direct a -> c)
-* ```
+* Articulation points may appear in multiple returned components.
 */
-function getAStarPath(graph, opts) {
+function getBiconnectedComponents(graph) {
+	if (graph.edges.length === 0) return [];
+	const state = analyzeConnectivity(graph);
+	return state.components.map((component) => [...component].map((nodeId) => state.nodeById.get(nodeId)).sort((a, b) => a.id.localeCompare(b.id))).sort((a, b) => a[0].id.localeCompare(b[0].id));
+}
+
+//#endregion
+//#region src/algorithms/isomorphism.ts
+function getDegreeSignature(graph, nodeId) {
 	const idx = getIndex(graph);
-	const { from: sourceId, to: targetId, heuristic } = opts;
-	const getWeight = opts.getWeight ?? ((e) => e.weight ?? 1);
-	const sourceNi = idx.nodeById.get(sourceId);
-	if (sourceNi === void 0) return void 0;
-	if (!idx.nodeById.has(targetId)) return void 0;
-	if (sourceId === targetId) return {
-		source: graph.nodes[sourceNi],
-		steps: []
-	};
-	const gScore = /* @__PURE__ */ new Map();
-	const cameFrom = /* @__PURE__ */ new Map();
-	const closedSet = /* @__PURE__ */ new Set();
-	const openSet = new MinPriorityQueue((a, b) => a.f - b.f);
-	gScore.set(sourceId, 0);
-	openSet.push({
-		id: sourceId,
-		f: heuristic(sourceId)
-	});
-	while (openSet.size > 0) {
-		const { id: currentId } = openSet.pop();
-		if (closedSet.has(currentId)) continue;
-		if (currentId === targetId) {
-			const steps = [];
-			let cur = targetId;
-			while (cur !== sourceId) {
-				const prev = cameFrom.get(cur);
-				const ni = idx.nodeById.get(cur);
-				steps.unshift({
-					edge: prev.edge,
-					node: graph.nodes[ni]
-				});
-				cur = prev.from;
-			}
-			return {
-				source: graph.nodes[sourceNi],
-				steps
-			};
-		}
-		closedSet.add(currentId);
-		for (const { neighborId, edge } of getNeighborEdges(graph, currentId)) {
-			if (closedSet.has(neighborId)) continue;
-			const tentativeG = (gScore.get(currentId) ?? Infinity) + getWeight(edge);
-			if (tentativeG < (gScore.get(neighborId) ?? Infinity)) {
-				cameFrom.set(neighborId, {
-					from: currentId,
-					edge
-				});
-				gScore.set(neighborId, tentativeG);
-				openSet.push({
-					id: neighborId,
-					f: tentativeG + heuristic(neighborId)
-				});
-			}
-		}
+	const outDegree = idx.outEdges.get(nodeId)?.length ?? 0;
+	const inDegree = idx.inEdges.get(nodeId)?.length ?? 0;
+	if (graph.type === "undirected") return `u:${new Set([...idx.outEdges.get(nodeId) ?? [], ...idx.inEdges.get(nodeId) ?? []]).size}`;
+	return `d:${inDegree}:${outDegree}`;
+}
+function getEdgesBetween(graph, sourceId, targetId) {
+	if (graph.type === "undirected") return graph.edges.filter((edge) => edge.sourceId === sourceId && edge.targetId === targetId || edge.sourceId === targetId && edge.targetId === sourceId);
+	return graph.edges.filter((edge) => edge.sourceId === sourceId && edge.targetId === targetId);
+}
+function edgesAreCompatible(edgesA, edgesB, edgeMatch) {
+	if (edgesA.length !== edgesB.length) return false;
+	if (!edgeMatch || edgesA.length === 0) return true;
+	const remaining = [...edgesB];
+	for (const edgeA of edgesA) {
+		const matchIndex = remaining.findIndex((edgeB) => edgeMatch(edgeA, edgeB));
+		if (matchIndex === -1) return false;
+		remaining.splice(matchIndex, 1);
 	}
+	return true;
 }
 /**
-* Joins two paths end-to-end. The last node of the head path must equal
-* the source of the tail path (the overlap node).
-*
-* Steps are concatenated: head.steps ++ tail.steps (tail already starts
-* from the overlap node, so no slicing is needed).
-*
-* @example
-* ```ts
-* import { createGraph, getShortestPath, joinPaths } from '@statelyai/graph';
-*
-* const graph = createGraph({
-*   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
-*   edges: [
-*     { id: 'ab', sourceId: 'a', targetId: 'b' },
-*     { id: 'bc', sourceId: 'b', targetId: 'c' },
-*   ],
-*   initialNodeId: 'a',
-* });
+* Returns whether two graphs are structurally isomorphic.
 *
-* const ab = getShortestPath(graph, { to: 'b' })!;
-* const bc = getShortestPath(graph, { from: 'b', to: 'c' })!;
-* const ac = joinPaths(ab, bc);
-* // ac: a -> b -> c
-* ```
+* Optional `nodeMatch` and `edgeMatch` predicates can refine the match using
+* node and edge payloads.
 */
-function joinPaths(headPath, tailPath) {
-	const headEnd = headPath.steps.length > 0 ? headPath.steps[headPath.steps.length - 1].node : headPath.source;
-	if (headEnd.id !== tailPath.source.id) throw new Error(`Paths cannot be joined: head path ends at "${headEnd.id}" but tail path starts at "${tailPath.source.id}"`);
-	return {
-		source: headPath.source,
-		steps: [...headPath.steps, ...tailPath.steps]
+function isIsomorphic(graphA, graphB, options) {
+	if (graphA.type !== graphB.type) return false;
+	if (graphA.nodes.length !== graphB.nodes.length) return false;
+	if (graphA.edges.length !== graphB.edges.length) return false;
+	const nodeMatch = options?.nodeMatch;
+	const edgeMatch = options?.edgeMatch;
+	const nodesA = [...graphA.nodes].sort((a, b) => {
+		const sigDiff = getDegreeSignature(graphA, b.id).localeCompare(getDegreeSignature(graphA, a.id));
+		if (sigDiff !== 0) return sigDiff;
+		return a.id.localeCompare(b.id);
+	});
+	const nodesB = [...graphB.nodes];
+	const signaturesA = nodesA.map((node) => getDegreeSignature(graphA, node.id)).sort();
+	const signaturesB = nodesB.map((node) => getDegreeSignature(graphB, node.id)).sort();
+	if (signaturesA.join("|") !== signaturesB.join("|")) return false;
+	const mapping = /* @__PURE__ */ new Map();
+	const usedB = /* @__PURE__ */ new Set();
+	const backtrack = (index) => {
+		if (index >= nodesA.length) return true;
+		const nodeA = nodesA[index];
+		const signatureA = getDegreeSignature(graphA, nodeA.id);
+		for (const nodeB of nodesB) {
+			if (usedB.has(nodeB.id)) continue;
+			if (getDegreeSignature(graphB, nodeB.id) !== signatureA) continue;
+			if (nodeMatch && !nodeMatch(nodeA, nodeB)) continue;
+			let compatible = true;
+			for (const [mappedAId, mappedBId] of mapping.entries()) {
+				if (!edgesAreCompatible(getEdgesBetween(graphA, nodeA.id, mappedAId), getEdgesBetween(graphB, nodeB.id, mappedBId), edgeMatch)) {
+					compatible = false;
+					break;
+				}
+				if (!edgesAreCompatible(getEdgesBetween(graphA, mappedAId, nodeA.id), getEdgesBetween(graphB, mappedBId, nodeB.id), edgeMatch)) {
+					compatible = false;
+					break;
+				}
+			}
+			if (!compatible) continue;
+			mapping.set(nodeA.id, nodeB.id);
+			usedB.add(nodeB.id);
+			if (backtrack(index + 1)) return true;
+			mapping.delete(nodeA.id);
+			usedB.delete(nodeB.id);
+		}
+		return false;
 	};
+	return backtrack(0);
 }
 
 //#endregion
-export { createGraphPort as $, getBiconnectedComponents as A, getEigenvectorCentrality as B, hasPath as C, joinPaths as D, isTree as E, getLabelPropagationCommunities as F, GraphInstance as G, getInDegreeCentrality as H, getModularity as I, addNode as J, addEdge as K, getBetweennessCentrality as L, genGirvanNewmanCommunities as M, getGirvanNewmanCommunities as N, isIsomorphic as O, getGreedyModularityCommunities as P, createGraphNode as Q, getClosenessCentrality as R, getTopologicalSort as S, isConnected as T, getOutDegreeCentrality as U, getHITS as V, getPageRank as W, createGraphEdge as X, createGraph as Y, createGraphFromTransition as Z, getShortestPath as _, genPreorders as a, getNode as at, getSimplePaths as b, getAStarPath as c, updateEdge as ct, getCycles as d, createVisualGraph as et, getMinimumSpanningTree as f, getPreorders as g, getPreorder as h, genPostorders as i, getEdge as it, getBridges as j, getArticulationPoints as k, getAllPairsShortestPaths as l, updateEntities as lt, getPostorders as m, dfs as n, deleteEntities as nt, genShortestPaths as o, hasEdge as ot, getPostorder as p, addEntities as q, genCycles as r, deleteNode as rt, genSimplePaths as s, hasNode as st, bfs as t, deleteEdge as tt, getConnectedComponents as u, updateNode as ut, getShortestPaths as v, isAcyclic as w, getStronglyConnectedComponents as x, getSimplePath as y, getDegreeCentrality as z };
+export { createGraphPort as $, isAcyclic as A, getShortestPaths as B, getPreorder as C, getConnectedComponents as D, dfs as E, genSimplePaths as F, GraphInstance as G, getSimplePaths as H, getAStarPath as I, addNode as J, addEdge as K, getAllPairsShortestPaths as L, isTree as M, genCycles as N, getTopologicalSort as O, genShortestPaths as P, createGraphNode as Q, getCycles as R, getPostorders as S, bfs as T, getStronglyConnectedComponents as U, getSimplePath as V, joinPaths as W, createGraphEdge as X, createGraph as Y, createGraphFromTransition as Z, getPageRank as _, genGirvanNewmanCommunities as a, getNode as at, genPreorders as b, getLabelPropagationCommunities as c, updateEdge as ct, getClosenessCentrality as d, createVisualGraph as et, getDegreeCentrality as f, getOutDegreeCentrality as g, getInDegreeCentrality as h, getBridges as i, getEdge as it, isConnected as j, hasPath as k, getModularity as l, updateEntities as lt, getHITS as m, getArticulationPoints as n, deleteEntities as nt, getGirvanNewmanCommunities as o, hasEdge as ot, getEigenvectorCentrality as p, addEntities as q, getBiconnectedComponents as r, deleteNode as rt, getGreedyModularityCommunities as s, hasNode as st, isIsomorphic as t, deleteEdge as tt, getBetweennessCentrality as u, updateNode as ut, getMinimumSpanningTree as v, getPreorders as w, getPostorder as x, genPostorders as y, getShortestPath as z };