@statelyai/graph 0.10.0 → 0.11.0

package/dist/{algorithms-C-S7u40k.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
 /**
@@ -650,2364 +650,1741 @@ 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));
+	yield* dfsCollect(sourceId);
 }
-function getNodeMap(graph) {
-	return new Map(graph.nodes.map((node) => [node.id, node]));
+function getSimplePath(graph, opts) {
+	for (const path of genSimplePaths(graph, opts)) return path;
 }
-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);
+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)));
+		}
+		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);
+		}
 	}
-	return [...grouped.values()].map((community) => community.sort((a, b) => a.id.localeCompare(b.id))).sort((a, b) => a[0].id.localeCompare(b[0].id));
+	for (const node of graph.nodes) if (!nodeIndex.has(node.id)) strongconnect(node.id);
+	return result;
 }
-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 getCycles(graph) {
+	return [...genCycles(graph)];
+}
+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((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);
 		}
-		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);
+		dfsFind(startId);
+		yield* found;
+	}
+}
+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;
 	}
-	for (const edgeId of Object.keys(scores)) scores[edgeId] /= 2;
-	return scores;
 }
-function cloneWithEdges(graph, edges) {
-	return {
-		...graph,
-		nodes: [...graph.nodes],
-		edges
-	};
+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);
 }
-function toCommunityIds(communities) {
-	return communities.map((community) => new Set(community.map((node) => node.id)));
+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;
 }
-/**
-* 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 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 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) {
+		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
+			});
 		}
-		labels = nextLabels;
-		if (!changed) break;
 	}
-	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;
+	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 });
+		}
+	}
+	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));
 		}
 	}
+	return results;
 }
-/**
-* 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;
+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 last;
+	return results;
 }
-/**
-* 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;
+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
+			};
 		}
-	}
-	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;
+		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)
+				});
 			}
 		}
-		if (!bestMerge) break;
-		communities = bestMerge.sort((a, b) => a[0].id.localeCompare(b[0].id));
-		currentScore = bestScore;
 	}
-	return communities;
+}
+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]
+	};
 }
 
 //#endregion
-//#region src/algorithms/connectivity.ts
-function getUndirectedNeighbors(graph, nodeId) {
+//#region src/algorithms/traversal.ts
+function* bfs(graph, startId) {
 	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;
-}
-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);
+	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);
 		}
-		if (edgeId === stopEdgeId) break;
 	}
-	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);
-		}
+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);
 	}
-	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)));
+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;
 		}
-	}
-	if (parentEdgeId === null && childCount > 1) state.articulationPoints.add(nodeId);
+		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 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 isAcyclicUndirected(graph) {
+	const idx = getIndex(graph);
+	const visited = /* @__PURE__ */ new Set();
+	const hasCycle = (id, parentId) => {
+		visited.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 (!visited.has(neighborId)) {
+				if (hasCycle(neighborId, id)) return true;
+			} else if (neighborId !== parentId) return true;
+		}
+		for (const eid of idx.inEdges.get(id) ?? []) {
+			const ai = idx.edgeById.get(eid);
+			if (ai === void 0) continue;
+			const neighborId = graph.edges[ai].sourceId;
+			if (!visited.has(neighborId)) {
+				if (hasCycle(neighborId, id)) return true;
+			} else if (neighborId !== parentId) return true;
+		}
+		return false;
 	};
-	for (const node of graph.nodes) {
-		if (state.disc.has(node.id)) continue;
-		traverseConnectivity(graph, node.id, null, state);
-		finalizeRemainingComponent(state);
-	}
-	return state;
+	for (const node of graph.nodes) if (!visited.has(node.id) && hasCycle(node.id, null)) return false;
+	return true;
 }
-/**
-* 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) {
+function getConnectedComponents(graph) {
 	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);
-}
-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;
-}
-/**
-* 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;
+	const visited = /* @__PURE__ */ new Set();
+	const components = [];
+	for (const node of graph.nodes) {
+		if (visited.has(node.id)) continue;
+		const component = [];
+		const queue = [node.id];
+		visited.add(node.id);
+		while (queue.length > 0) {
+			const id = queue.shift();
+			const ni = idx.nodeById.get(id);
+			if (ni !== void 0) component.push(graph.nodes[ni]);
+			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 (!visited.has(neighborId)) {
+					visited.add(neighborId);
+					queue.push(neighborId);
 				}
-				if (!edgesAreCompatible(getEdgesBetween(graphA, mappedAId, nodeA.id), getEdgesBetween(graphB, mappedBId, nodeB.id), edgeMatch)) {
-					compatible = false;
-					break;
+			}
+			for (const eid of idx.inEdges.get(id) ?? []) {
+				const ai = idx.edgeById.get(eid);
+				if (ai === void 0) continue;
+				const neighborId = graph.edges[ai].sourceId;
+				if (!visited.has(neighborId)) {
+					visited.add(neighborId);
+					queue.push(neighborId);
 				}
 			}
-			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);
+		components.push(component);
+	}
+	return components;
 }
-
-//#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) {
+function getTopologicalSort(graph) {
 	const idx = getIndex(graph);
-	const visited = /* @__PURE__ */ new Set();
-	const queue = [startId];
-	visited.add(startId);
+	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, degree] of inDegree) if (degree === 0) queue.push(id);
+	const result = [];
 	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);
+		if (ni !== void 0) result.push(graph.nodes[ni]);
+		for (const eid of idx.outEdges.get(id) ?? []) {
+			const ai = idx.edgeById.get(eid);
+			if (ai === void 0) continue;
+			const targetId = graph.edges[ai].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;
 }
-/**
-* 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) {
+function hasPath(graph, sourceId, targetId) {
+	return getShortestPaths(graph, {
+		from: sourceId,
+		to: targetId
+	}).length > 0;
+}
+function isConnected(graph) {
+	if (graph.nodes.length === 0) return true;
+	return getConnectedComponents(graph).length <= 1;
+}
+function isTree(graph) {
+	return isConnected(graph) && isAcyclic(graph);
+}
+
+//#endregion
+//#region src/algorithms/ordering.ts
+function getPreorder(graph, opts) {
 	const idx = getIndex(graph);
-	const visited = /* @__PURE__ */ new Set();
+	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 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);
+		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]);
 	}
+	return result;
 }
-function getNeighborIds(graph, nodeId) {
+function getPostorder(graph, opts) {
 	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);
+	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 ids;
+	return result;
 }
-function getSuccessorIds(graph, nodeId) {
-	const idx = getIndex(graph);
-	return (idx.outEdges.get(nodeId) ?? []).map((eid) => graph.edges[idx.edgeById.get(eid)].targetId);
+function getPreorders(graph, opts) {
+	return [...genPreorders(graph, opts)];
 }
-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;
+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;
 		}
+		if (!branched) yield preorder;
 	}
-	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* 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;
 	}
-};
-/**
-* 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;
-	return true;
 }
-function isAcyclicUndirected(graph) {
+
+//#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 }
+		}))
+	});
+}
+function primMST(graph, getWeight) {
+	if (graph.nodes.length === 0) return [];
 	const idx = getIndex(graph);
-	const visited = /* @__PURE__ */ new Set();
-	const hasCycle = (id, parentId) => {
-		visited.add(id);
-		for (const eid of idx.outEdges.get(id) ?? []) {
+	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 neighborId = graph.edges[ai].targetId;
-			if (!visited.has(neighborId)) {
-				if (hasCycle(neighborId, id)) return true;
-			} else if (neighborId !== parentId) return true;
+			const edge = graph.edges[ai];
+			if (!inMST.has(edge.targetId)) candidates.push({
+				weight: getWeight(edge),
+				edge
+			});
 		}
-		for (const eid of idx.inEdges.get(id) ?? []) {
+		if (graph.type === "undirected") for (const eid of idx.inEdges.get(nodeId) ?? []) {
 			const ai = idx.edgeById.get(eid);
 			if (ai === void 0) continue;
-			const neighborId = graph.edges[ai].sourceId;
-			if (!visited.has(neighborId)) {
-				if (hasCycle(neighborId, id)) return true;
-			} else if (neighborId !== parentId) return true;
+			const edge = graph.edges[ai];
+			if (!inMST.has(edge.sourceId)) candidates.push({
+				weight: getWeight(edge),
+				edge
+			});
 		}
-		return false;
-	};
-	for (const n of graph.nodes) if (!visited.has(n.id) && hasCycle(n.id, null)) return false;
-	return true;
+	}
+	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;
+}
+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;
+}
+
+//#endregion
+//#region src/algorithms/centrality.ts
+function getNodeIds(graph) {
+	return graph.nodes.map((node) => node.id);
+}
+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;
 }
 /**
-* Returns connected components as arrays of nodes.
-* Treats all edges as undirected for connectivity.
+* Returns degree centrality scores for all nodes.
 *
-* **O(V + E)** time.
+* Degree centrality is the node degree normalized by `n - 1`.
 *
 * @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]]
+* const scores = getDegreeCentrality(graph);
+* console.log(scores.a); // 0.5
 * ```
 */
-function getConnectedComponents(graph) {
+function getDegreeCentrality(graph) {
+	const scale = graph.nodes.length > 1 ? 1 / (graph.nodes.length - 1) : 0;
 	const idx = getIndex(graph);
-	const visited = /* @__PURE__ */ new Set();
-	const components = [];
-	for (const n of graph.nodes) {
-		if (visited.has(n.id)) continue;
-		const component = [];
-		const queue = [n.id];
-		visited.add(n.id);
-		while (queue.length > 0) {
-			const id = queue.shift();
-			const ni = idx.nodeById.get(id);
-			if (ni !== void 0) component.push(graph.nodes[ni]);
-			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 (!visited.has(neighborId)) {
-					visited.add(neighborId);
-					queue.push(neighborId);
-				}
-			}
-			for (const eid of idx.inEdges.get(id) ?? []) {
-				const ai = idx.edgeById.get(eid);
-				if (ai === void 0) continue;
-				const neighborId = graph.edges[ai].sourceId;
-				if (!visited.has(neighborId)) {
-					visited.add(neighborId);
-					queue.push(neighborId);
-				}
-			}
-		}
-		components.push(component);
+	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;
 	}
-	return components;
+	return scores;
 }
 /**
-* 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' },
-*   ],
-* });
+* Returns in-degree centrality scores for all nodes.
 *
-* const sorted = getTopologicalSort(graph);
-* // [nodeA, nodeB, nodeC]
-* ```
+* In-degree centrality is the incoming degree normalized by `n - 1`.
 */
-function getTopologicalSort(graph) {
+function getInDegreeCentrality(graph) {
+	const scale = graph.nodes.length > 1 ? 1 / (graph.nodes.length - 1) : 0;
 	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 queue = [];
-	for (const [id, deg] of inDeg) if (deg === 0) queue.push(id);
-	const result = [];
-	while (queue.length > 0) {
-		const id = queue.shift();
-		const ni = idx.nodeById.get(id);
-		if (ni !== void 0) result.push(graph.nodes[ni]);
-		for (const eid of idx.outEdges.get(id) ?? []) {
-			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);
-		}
-	}
-	if (result.length !== graph.nodes.length) return null;
-	return result;
+	const scores = createEmptyScoreMap(graph);
+	for (const node of graph.nodes) scores[node.id] = (idx.inEdges.get(node.id)?.length ?? 0) * scale;
+	return scores;
 }
 /**
-* 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' }],
-* });
+* Returns out-degree centrality scores for all nodes.
 *
-* hasPath(graph, 'a', 'b'); // true
-* hasPath(graph, 'a', 'c'); // false
-* ```
+* Out-degree centrality is the outgoing degree normalized by `n - 1`.
 */
-function hasPath(graph, sourceId, targetId) {
-	return getShortestPaths(graph, {
-		from: sourceId,
-		to: targetId
-	}).length > 0;
+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;
 }
 /**
-* 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' }],
-* });
+* Returns closeness centrality scores for all nodes.
 *
-* isConnected(graph); // true
-* ```
+* Distances are computed over unweighted shortest paths using the graph's
+* existing directed or undirected edge semantics.
 */
-function isConnected(graph) {
-	if (graph.nodes.length === 0) return true;
-	return getConnectedComponents(graph).length <= 1;
+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;
 }
 /**
-* 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' },
-*   ],
-* });
+* Returns betweenness centrality scores for all nodes.
 *
-* isTree(tree); // true
-* ```
+* Uses Brandes' algorithm over unweighted shortest paths and returns
+* normalized scores.
 */
-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) {
-	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
-			});
-		}
-	}
-	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
-			});
+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);
 		}
-	}
-	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, Dijkstra, or Bellman-Ford. */
-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((e) => e.weight !== void 0)) {
-		const queue = [sourceId];
+		sigma.set(source.id, 1);
+		distance.set(source.id, 0);
 		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
-					}]);
+			const currentId = queue.shift();
+			stack.push(currentId);
+			for (const neighborId of getNeighborIds(graph, currentId)) {
+				if (distance.get(neighborId) === -1) {
 					queue.push(neighborId);
-				} else if (existing === newDist) prev.get(neighborId).push({
-					from: id,
-					edge
-				});
+					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 {
-		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
-				});
+		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);
 		}
 	}
-	return {
-		dist,
-		prev
-	};
+	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;
 }
 /**
-* Bellman-Ford single-source shortest paths.
-* **O(VE)** time. Handles negative edge weights.
-* Throws if a negative-weight cycle is reachable from the source.
+* Returns PageRank scores for all nodes.
+*
+* Uses power iteration with damping factor `alpha`.
 */
-function bellmanFord(graph, sourceId, getWeight) {
-	const dist = /* @__PURE__ */ new Map();
-	const prev = /* @__PURE__ */ new Map();
-	const effectiveWeight = getWeight ?? ((e) => e.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 V = graph.nodes.length;
-	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 < V - 1; i++) {
-		let changed = false;
-		for (const { fromId, toId, edge } of directedEdges) {
-			const d = dist.get(fromId);
-			if (d === Infinity) continue;
-			const newDist = d + effectiveWeight(edge);
-			const existing = dist.get(toId);
-			if (newDist < existing) {
-				dist.set(toId, newDist);
-				prev.set(toId, [{
-					from: fromId,
-					edge
-				}]);
-				changed = true;
-			} else if (newDist === existing && existing !== Infinity) {
-				const preds = prev.get(toId);
-				if (!preds.some((p) => p.from === fromId && p.edge === edge)) preds.push({
-					from: fromId,
-					edge
-				});
+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;
 		}
-		if (!changed) break;
-	}
-	for (const { fromId, toId, edge } of directedEdges) {
-		const d = dist.get(fromId);
-		if (d === Infinity) continue;
-		if (d + effectiveWeight(edge) < dist.get(toId)) throw new Error("Graph contains a negative-weight cycle reachable from the source node");
-	}
-	for (const [id, d] of dist) if (d === Infinity) {
-		dist.delete(id);
-		prev.delete(id);
-	}
-	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;
+		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;
 	}
-	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
-		}]
-	};
-}
-/**
-* 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) {
-	const idx = getIndex(graph);
-	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((n) => n.id === sourceId);
-	for (const targetId of targets) yield* reconstructPaths(graph, prev, sourceNode, targetId);
+	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 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',
-* });
+* Returns HITS hub and authority scores for all nodes.
 *
-* const paths = getShortestPaths(graph);
-* // paths to 'b' and 'c' from 'a'
-* ```
+* Uses power iteration and L2 normalization per iteration.
 */
-function getShortestPaths(graph, opts) {
-	return [...genShortestPaths(graph, opts)];
+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 {
+		hubs,
+		authorities
+	};
 }
 /**
-* 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',
-* });
+* Returns eigenvector centrality scores for all nodes.
 *
-* const path = getShortestPath(graph, { to: 'c' });
-* // path.steps -> [{node: nodeB, edge: ...}, {node: nodeC, edge: ...}]
-* ```
+* Uses power iteration over incoming neighbors for directed graphs and
+* undirected adjacency for undirected graphs.
 */
-function getShortestPath(graph, opts) {
-	for (const path of genShortestPaths(graph, opts)) return path;
+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 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)];
+
+//#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 simple (acyclic) paths from a source node via DFS backtracking.
-* Use `getSimplePaths` for the full array.
-*
-* **O(V!)** worst-case (exponential in dense graphs).
-*
-* @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']
-* }
-* ```
-*/
-function* genSimplePaths(graph, opts) {
+function getUndirectedConnectedComponents(graph) {
 	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;
+	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);
 			}
-		} 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);
+		communities.push(community.sort((a, b) => a.id.localeCompare(b.id)));
 	}
-	yield* dfsCollect(sourceId);
+	return communities.sort((a, b) => a[0].id.localeCompare(b[0].id));
 }
-/**
-* 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',
-* });
-*
-* const path = getSimplePath(graph, { to: 'c' });
-* // path.steps -> [{node: nodeB, edge: ...}, {node: nodeC, edge: ...}]
-* ```
-*/
-function getSimplePath(graph, opts) {
-	for (const path of genSimplePaths(graph, opts)) return path;
+function getNodeMap(graph) {
+	return new Map(graph.nodes.map((node) => [node.id, node]));
 }
-/**
-* 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' },
-*   ],
-* });
-*
-* const sccs = getStronglyConnectedComponents(graph);
-* // [[nodeA, nodeB], [nodeC]]
-* ```
-*/
-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 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);
-		}
+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);
 	}
-	for (const n of graph.nodes) if (!nodeIndex.has(n.id)) strongconnect(n.id);
-	return result;
-}
-/**
-* 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' },
-*   ],
-* });
-*
-* const cycles = getCycles(graph);
-* // one cycle: a -> b -> a
-* ```
-*/
-function getCycles(graph) {
-	return [...genCycles(graph)];
-}
-/**
-* 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' },
-*   ],
-* });
-*
-* for (const cycle of genCycles(graph)) {
-*   console.log(cycle.steps.map(s => s.node.id)); // ['b', 'a']
-* }
-* ```
-*/
-function* genCycles(graph) {
-	if (graph.type === "undirected") yield* genCyclesUndirected(graph);
-	else yield* genCyclesDirected(graph);
+	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* 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 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);
 		}
-		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 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 (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]
+				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
 					});
-					dfsFind(neighborId, currentId);
-					steps.pop();
 				}
 			}
-			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
-			});
-		}
-	}
-	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;
-}
-/**
-* 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',
-* });
-*
-* const order = getPreorder(graph);
-* // [nodeA, nodeB, nodeC]
-* ```
-*/
-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;
-		}
-		visited.add(next);
-		stack.push(next);
-		const ni = idx.nodeById.get(next);
-		if (ni !== void 0) result.push(graph.nodes[ni]);
-	}
-	return result;
-}
-/**
-* 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',
-* });
-*
-* const order = getPostorder(graph);
-* // [nodeC, nodeB, nodeA]
-* ```
-*/
-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);
-	}
-	return result;
-}
-/**
-* 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',
-* });
-*
-* const allOrders = getPreorders(graph);
-* // [[nodeA, nodeB, nodeC], [nodeA, nodeC, nodeB]]
-* ```
-*/
-function getPreorders(graph, opts) {
-	return [...genPreorders(graph, opts)];
-}
-/**
-* 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)];
-}
-/**
-* 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) {
-	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;
-			}
-			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]
-				});
+		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 'bellman-ford': handles negative weights, throws on negative cycles.
-* Algorithm 'floyd-warshall': classic dynamic programming.
-*
-* **O(V · (V + E) log V)** (Dijkstra), **O(V²E)** (Bellman-Ford), 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) {
-	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);
+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 bellmanFordAllPaths(graph, getWeight) {
-	const results = [];
-	for (const node of graph.nodes) {
-		const paths = getShortestPaths(graph, {
-			from: node.id,
-			getWeight,
-			algorithm: "bellman-ford"
+
+//#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
 		});
-		results.push(...paths);
 	}
-	return results;
-}
-function dijkstraAllPaths(graph, getWeight) {
-	const results = [];
-	for (const node of graph.nodes) {
-		const paths = getShortestPaths(graph, {
-			from: node.id,
-			getWeight
+	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 };