@statelyai/graph 1.0.0 → 2.1.0

package/dist/algorithms-DBpH74hR.mjs

@@ -0,0 +1,3309 @@
+import { O as getIndex, l as getInDegree, p as getOutDegree, r as getDegree } from "./queries-BMM0XAv_.mjs";
+import { n as toNodeConfig, s as createGraph, t as toEdgeConfig } from "./config-Dt5u1gSf.mjs";
+import { t as getEdgeMode } from "./mode-gu_mhKKs.mjs";
+
+//#region src/algorithms/shared.ts
+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);
+	}
+	peek() {
+		return this.items[0];
+	}
+	pop() {
+		if (this.items.length === 0) return void 0;
+		const first = this.items[0];
+		const last = this.items.pop();
+		if (this.items.length > 0) {
+			this.items[0] = last;
+			this.bubbleDown(0);
+		}
+		return first;
+	}
+	bubbleUp(index) {
+		let current = index;
+		while (current > 0) {
+			const parent = Math.floor((current - 1) / 2);
+			if (this.compare(this.items[current], this.items[parent]) >= 0) break;
+			[this.items[current], this.items[parent]] = [this.items[parent], this.items[current]];
+			current = parent;
+		}
+	}
+	bubbleDown(index) {
+		let current = index;
+		while (true) {
+			const left = current * 2 + 1;
+			const right = left + 1;
+			let smallest = current;
+			if (left < this.items.length && this.compare(this.items[left], this.items[smallest]) < 0) smallest = left;
+			if (right < this.items.length && this.compare(this.items[right], this.items[smallest]) < 0) smallest = right;
+			if (smallest === current) break;
+			[this.items[current], this.items[smallest]] = [this.items[smallest], this.items[current]];
+			current = smallest;
+		}
+	}
+};
+/**
+* Seeded PRNG (mulberry32). Same generator as src/walks.ts — kept here so
+* algorithm modules and generators can share it without importing walks.
+*/
+function mulberry32(seed) {
+	let s = seed | 0;
+	return () => {
+		s = s + 1831565813 | 0;
+		let t = Math.imul(s ^ s >>> 15, 1 | s);
+		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/**
+* Classify a graph by the *effective* mode of its edges (per-edge `mode`
+* overrides included): all-directed, all-non-directed, or genuinely mixed.
+* Edge-less graphs fall back to `graph.mode`.
+*/
+function getEffectiveModeKind(graph) {
+	let sawDirected = false;
+	let sawNonDirected = false;
+	for (const edge of graph.edges) {
+		if (getEdgeMode(graph, edge) === "directed") sawDirected = true;
+		else sawNonDirected = true;
+		if (sawDirected && sawNonDirected) return "mixed";
+	}
+	if (sawDirected) return "directed";
+	if (sawNonDirected) return "non-directed";
+	return graph.mode === "directed" ? "directed" : "non-directed";
+}
+function getNeighborIds(graph, nodeId) {
+	const idx = getIndex(graph);
+	const ids = [];
+	for (const eid of idx.outEdges.get(nodeId) ?? []) {
+		const ai = idx.edgeById.get(eid);
+		if (ai !== void 0) ids.push(graph.edges[ai].targetId);
+	}
+	for (const eid of idx.inEdges.get(nodeId) ?? []) {
+		const ai = idx.edgeById.get(eid);
+		if (ai === void 0) continue;
+		const edge = graph.edges[ai];
+		if (getEdgeMode(graph, edge) !== "directed") ids.push(edge.sourceId);
+	}
+	return ids;
+}
+function getSuccessorIds(graph, nodeId) {
+	const idx = getIndex(graph);
+	return (idx.outEdges.get(nodeId) ?? []).map((eid) => graph.edges[idx.edgeById.get(eid)].targetId);
+}
+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");
+}
+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
+			});
+		}
+	}
+	for (const eid of idx.inEdges.get(nodeId) ?? []) {
+		const ai = idx.edgeById.get(eid);
+		if (ai !== void 0) {
+			const edge = graph.edges[ai];
+			if (getEdgeMode(graph, edge) !== "directed") result.push({
+				neighborId: edge.sourceId,
+				edge
+			});
+		}
+	}
+	return result;
+}
+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
+			});
+		}
+	}
+	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/csr.ts
+const csrCache = /* @__PURE__ */ new WeakMap();
+/** Get or lazily (re)build the CSR snapshot for a graph. */
+function getCSR(graph) {
+	const idx = getIndex(graph);
+	const cached = csrCache.get(idx);
+	if (cached && cached.version === idx.version && cached.mode === graph.mode) return cached.csr;
+	const csr = buildCSR(graph);
+	csrCache.set(idx, {
+		version: idx.version,
+		mode: graph.mode,
+		csr
+	});
+	return csr;
+}
+function buildCSR(graph) {
+	const n = graph.nodes.length;
+	const m = graph.edges.length;
+	const ids = new Array(n);
+	const indexOf = /* @__PURE__ */ new Map();
+	for (let i = 0; i < n; i++) {
+		ids[i] = graph.nodes[i].id;
+		indexOf.set(ids[i], i);
+	}
+	const srcPos = new Int32Array(m);
+	const tgtPos = new Int32Array(m);
+	const nonDirected = new Uint8Array(m);
+	const outCounts = new Int32Array(n);
+	const inCounts = new Int32Array(n);
+	let firstNegativeEdge = -1;
+	for (let e = 0; e < m; e++) {
+		const edge = graph.edges[e];
+		if (firstNegativeEdge === -1 && (edge.weight ?? 1) < 0) firstNegativeEdge = e;
+		const s = indexOf.get(edge.sourceId);
+		const t = indexOf.get(edge.targetId);
+		if (s === void 0 || t === void 0) {
+			srcPos[e] = -1;
+			tgtPos[e] = -1;
+			continue;
+		}
+		srcPos[e] = s;
+		tgtPos[e] = t;
+		const nd = getEdgeMode(graph, edge) !== "directed" ? 1 : 0;
+		nonDirected[e] = nd;
+		outCounts[s]++;
+		inCounts[t]++;
+		if (nd) {
+			outCounts[t]++;
+			inCounts[s]++;
+		}
+	}
+	const outOffsets = new Int32Array(n + 1);
+	const inOffsets = new Int32Array(n + 1);
+	for (let i = 0; i < n; i++) {
+		outOffsets[i + 1] = outOffsets[i] + outCounts[i];
+		inOffsets[i + 1] = inOffsets[i] + inCounts[i];
+	}
+	const outTargets = new Int32Array(outOffsets[n]);
+	const outEdgeIndex = new Int32Array(outOffsets[n]);
+	const inOrigins = new Int32Array(inOffsets[n]);
+	const inEdgeIndex = new Int32Array(inOffsets[n]);
+	const outCursor = outOffsets.slice(0, n);
+	const inCursor = inOffsets.slice(0, n);
+	for (let e = 0; e < m; e++) {
+		const s = srcPos[e];
+		const t = tgtPos[e];
+		if (s < 0) continue;
+		outTargets[outCursor[s]] = t;
+		outEdgeIndex[outCursor[s]++] = e;
+		inOrigins[inCursor[t]] = s;
+		inEdgeIndex[inCursor[t]++] = e;
+		if (nonDirected[e]) {
+			outTargets[outCursor[t]] = s;
+			outEdgeIndex[outCursor[t]++] = e;
+			inOrigins[inCursor[s]] = t;
+			inEdgeIndex[inCursor[s]++] = e;
+		}
+	}
+	return {
+		ids,
+		indexOf,
+		outOffsets,
+		outTargets,
+		outEdgeIndex,
+		inOffsets,
+		inOrigins,
+		inEdgeIndex,
+		firstNegativeEdge
+	};
+}
+
+//#endregion
+//#region src/algorithms/paths.ts
+/**
+* Flat binary min-heap of `(distance, node position)` entries in parallel
+* typed arrays. The Dijkstra/A* hot loops push one entry per relaxation, so
+* avoiding a `{ pos, dist }` wrapper object per push (allocation + property
+* loads in the sift comparisons) is a measurable win on 10k+ node graphs.
+* Sifts move "holes" instead of swapping, halving array writes.
+*/
+var TypedMinHeap = class {
+	keys;
+	vals;
+	size = 0;
+	constructor(capacity) {
+		const cap = Math.max(capacity, 16);
+		this.keys = new Float64Array(cap);
+		this.vals = new Int32Array(cap);
+	}
+	push(key, val) {
+		if (this.size === this.keys.length) {
+			const keys$1 = new Float64Array(this.keys.length * 2);
+			const vals$1 = new Int32Array(this.vals.length * 2);
+			keys$1.set(this.keys);
+			vals$1.set(this.vals);
+			this.keys = keys$1;
+			this.vals = vals$1;
+		}
+		const { keys, vals } = this;
+		let hole = this.size++;
+		while (hole > 0) {
+			const parent = hole - 1 >> 1;
+			if (keys[parent] <= key) break;
+			keys[hole] = keys[parent];
+			vals[hole] = vals[parent];
+			hole = parent;
+		}
+		keys[hole] = key;
+		vals[hole] = val;
+	}
+	/** Key of the minimum entry; garbage when empty (check `size` first). */
+	peekKey() {
+		return this.keys[0];
+	}
+	/** Value of the minimum entry; garbage when empty (check `size` first). */
+	peekVal() {
+		return this.vals[0];
+	}
+	/** Remove the minimum entry (no-op shape: read via peek* first). */
+	pop() {
+		const { keys, vals } = this;
+		const last = --this.size;
+		if (last === 0) return;
+		const key = keys[last];
+		const val = vals[last];
+		let hole = 0;
+		for (;;) {
+			let child = hole * 2 + 1;
+			if (child >= last) break;
+			const right = child + 1;
+			if (right < last && keys[right] < keys[child]) child = right;
+			if (keys[child] >= key) break;
+			keys[hole] = keys[child];
+			vals[hole] = vals[child];
+			hole = child;
+		}
+		keys[hole] = key;
+		vals[hole] = val;
+	}
+};
+function computeShortestDistances(graph, sourceId, getWeight, algorithm, stopAtId) {
+	if (algorithm === "bellman-ford") return bellmanFordTyped(graph, sourceId, getWeight);
+	const csr = getCSR(graph);
+	const n = csr.ids.length;
+	const source = csr.indexOf.get(sourceId);
+	if (source === void 0) return {
+		source: -1,
+		distArr: new Float64Array(0),
+		prevArr: [],
+		stopDistance: Infinity
+	};
+	const distArr = new Float64Array(n).fill(Infinity);
+	const prevArr = new Array(n);
+	distArr[source] = 0;
+	prevArr[source] = [];
+	const stopAt = stopAtId !== void 0 ? csr.indexOf.get(stopAtId) : void 0;
+	let stopDistance = Infinity;
+	if (stopAt !== void 0) assertNoNegativeWeights(graph, csr, getWeight, "Dijkstra", "Use { algorithm: 'bellman-ford' } instead.");
+	if (!getWeight && !graph.edges.some((edge) => edge.weight !== void 0)) {
+		const queue = new Int32Array(n);
+		queue[0] = source;
+		let head = 0;
+		let tail = 1;
+		while (head < tail) {
+			const u = queue[head++];
+			if (distArr[u] > stopDistance) break;
+			if (u === stopAt) stopDistance = distArr[u];
+			const nextDistance = distArr[u] + 1;
+			for (let a = csr.outOffsets[u]; a < csr.outOffsets[u + 1]; a++) {
+				const v = csr.outTargets[a];
+				if (distArr[v] === Infinity) {
+					distArr[v] = nextDistance;
+					prevArr[v] = [u, csr.outEdgeIndex[a]];
+					queue[tail++] = v;
+				} else if (distArr[v] === nextDistance) prevArr[v].push(u, csr.outEdgeIndex[a]);
+			}
+		}
+	} else {
+		const effectiveWeight = getWeight ?? ((edge) => edge.weight ?? 1);
+		const visited = new Uint8Array(n);
+		const pq = new TypedMinHeap(n);
+		pq.push(0, source);
+		while (pq.size > 0) {
+			const distance = pq.peekKey();
+			const u = pq.peekVal();
+			pq.pop();
+			if (visited[u] || distance !== distArr[u]) continue;
+			if (distance > stopDistance) break;
+			if (u === stopAt) stopDistance = distance;
+			visited[u] = 1;
+			for (let a = csr.outOffsets[u]; a < csr.outOffsets[u + 1]; a++) {
+				const edge = graph.edges[csr.outEdgeIndex[a]];
+				const weight = effectiveWeight(edge);
+				if (weight < 0) throw new Error(`Negative edge weight ${weight} on edge "${edge.sourceId}->${edge.targetId}" (id "${edge.id}"): Dijkstra requires non-negative weights. Use { algorithm: 'bellman-ford' } instead.`);
+				const v = csr.outTargets[a];
+				const nextDistance = distance + weight;
+				if (nextDistance < distArr[v]) {
+					distArr[v] = nextDistance;
+					prevArr[v] = [u, csr.outEdgeIndex[a]];
+					pq.push(nextDistance, v);
+				} else if (nextDistance === distArr[v] && distArr[v] !== Infinity) prevArr[v].push(u, csr.outEdgeIndex[a]);
+			}
+		}
+	}
+	return {
+		source,
+		distArr,
+		prevArr,
+		stopDistance
+	};
+}
+/**
+* Bellman-Ford adapted to the typed-array result shape. The O(VE) relaxation
+* dominates, so the id→position conversion here is noise — and it keeps a
+* single reconstruction path for both algorithms.
+*/
+function bellmanFordTyped(graph, sourceId, getWeight) {
+	const { dist, prev } = bellmanFord(graph, sourceId, getWeight);
+	const csr = getCSR(graph);
+	const idx = getIndex(graph);
+	const n = csr.ids.length;
+	const distArr = new Float64Array(n).fill(Infinity);
+	const prevArr = new Array(n);
+	for (const [id, distance] of dist) {
+		const pos = csr.indexOf.get(id);
+		if (pos === void 0) continue;
+		distArr[pos] = distance;
+		const pairs = [];
+		for (const { from, edge } of prev.get(id) ?? []) {
+			const fromPos = csr.indexOf.get(from);
+			const edgeIndex = idx.edgeById.get(edge.id);
+			if (fromPos === void 0 || edgeIndex === void 0) continue;
+			pairs.push(fromPos, edgeIndex);
+		}
+		prevArr[pos] = pairs;
+	}
+	return {
+		source: csr.indexOf.get(sourceId) ?? -1,
+		distArr,
+		prevArr,
+		stopDistance: Infinity
+	};
+}
+function bellmanFord(graph, sourceId, getWeight) {
+	const dist = /* @__PURE__ */ new Map();
+	const prev = /* @__PURE__ */ new Map();
+	const effectiveWeight = getWeight ?? ((edge) => edge.weight ?? 1);
+	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 (getEdgeMode(graph, edge) !== "directed") 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
+				});
+			}
+		}
+		if (!changed) 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 {
+		dist,
+		prev
+	};
+}
+function* reconstructPathsAt(graph, prevArr, sourceNode, sourcePos, targetPos, onPath = /* @__PURE__ */ new Set()) {
+	if (targetPos === sourcePos) {
+		yield {
+			source: sourceNode,
+			steps: []
+		};
+		return;
+	}
+	const pairs = prevArr[targetPos];
+	if (!pairs || pairs.length === 0) return;
+	const targetNode = graph.nodes[targetPos];
+	onPath.add(targetPos);
+	for (let k = 0; k < pairs.length; k += 2) {
+		const fromPos = pairs[k];
+		if (onPath.has(fromPos)) continue;
+		const edge = graph.edges[pairs[k + 1]];
+		for (const prefix of reconstructPathsAt(graph, prevArr, sourceNode, sourcePos, fromPos, onPath)) yield {
+			source: sourceNode,
+			steps: [...prefix.steps, {
+				edge,
+				node: targetNode
+			}]
+		};
+	}
+	onPath.delete(targetPos);
+}
+function* genShortestPaths(graph, opts) {
+	const sourceId = resolveFrom(graph, opts);
+	const { source, distArr, prevArr, stopDistance } = computeShortestDistances(graph, sourceId, opts?.getWeight, opts?.algorithm, opts?.to);
+	const sourceNode = source !== -1 ? graph.nodes[source] : graph.nodes.find((node) => node.id === sourceId);
+	if (source === -1) {
+		if (opts?.to === sourceId) yield {
+			source: sourceNode,
+			steps: []
+		};
+		return;
+	}
+	const csr = getCSR(graph);
+	if (opts?.to) {
+		const target = csr.indexOf.get(opts.to);
+		if (target === void 0 || distArr[target] === Infinity || distArr[target] > stopDistance) return;
+		yield* reconstructPathsAt(graph, prevArr, sourceNode, source, target);
+		return;
+	}
+	for (let target = 0; target < distArr.length; target++) {
+		if (target === source || distArr[target] === Infinity || distArr[target] > stopDistance) continue;
+		yield* reconstructPathsAt(graph, prevArr, sourceNode, source, target);
+	}
+}
+function getShortestPaths(graph, opts) {
+	return [...genShortestPaths(graph, opts)];
+}
+function getShortestPath(graph, opts) {
+	if (opts.algorithm !== "bellman-ford") return bidirectionalShortestPath(graph, resolveFrom(graph, opts), opts.to, opts.getWeight);
+	for (const path of genShortestPaths(graph, opts)) return path;
+}
+/**
+* Sublinear searches (early-exit, bidirectional) may legitimately terminate
+* without ever scanning a negative edge, so the throw-on-negative contract
+* must be enforced up front: O(1) via the CSR's cached flag for the default
+* weight, or one O(edges) sweep for a custom `getWeight`.
+*/
+function assertNoNegativeWeights(graph, csr, getWeight, algorithmName, remedy) {
+	let offending;
+	let weight = 0;
+	if (getWeight === void 0) {
+		if (csr.firstNegativeEdge !== -1) {
+			offending = graph.edges[csr.firstNegativeEdge];
+			weight = offending.weight ?? 1;
+		}
+	} else for (const edge of graph.edges) {
+		const w = getWeight(edge);
+		if (w < 0) {
+			offending = edge;
+			weight = w;
+			break;
+		}
+	}
+	if (offending) throw new Error(`Negative edge weight ${weight} on edge "${offending.sourceId}->${offending.targetId}" (id "${offending.id}"): ${algorithmName} requires non-negative weights. ${remedy}`);
+}
+/**
+* Bidirectional Dijkstra for a single source→target query. Forward search
+* runs on the traversable arcs, backward search on the reverse arcs; `mu`
+* tracks the best meeting cost and the search stops when the two frontiers
+* prove no better meeting exists (Pohl's `topF + topB >= mu` condition).
+* Returns one shortest path (ties broken arbitrarily, as before).
+*/
+function bidirectionalShortestPath(graph, sourceId, targetId, getWeight) {
+	const csr = getCSR(graph);
+	const source = csr.indexOf.get(sourceId);
+	const target = csr.indexOf.get(targetId);
+	if (source === void 0 || target === void 0) return void 0;
+	const sourceNode = graph.nodes[source];
+	if (source === target) return {
+		source: sourceNode,
+		steps: []
+	};
+	assertNoNegativeWeights(graph, csr, getWeight, "Dijkstra", "Use { algorithm: 'bellman-ford' } instead.");
+	const effectiveWeight = getWeight ?? ((edge) => edge.weight ?? 1);
+	const n = csr.ids.length;
+	const distF = new Float64Array(n).fill(Infinity);
+	const distB = new Float64Array(n).fill(Infinity);
+	const predF = new Int32Array(n).fill(-1);
+	const predFEdge = new Int32Array(n).fill(-1);
+	const predB = new Int32Array(n).fill(-1);
+	const predBEdge = new Int32Array(n).fill(-1);
+	const settledF = new Uint8Array(n);
+	const settledB = new Uint8Array(n);
+	const pqF = new TypedMinHeap(n);
+	const pqB = new TypedMinHeap(n);
+	distF[source] = 0;
+	distB[target] = 0;
+	pqF.push(0, source);
+	pqB.push(0, target);
+	let mu = Infinity;
+	let meet = -1;
+	/** Discard stale/settled heap entries; return the next valid key. */
+	const validTop = (pq, dist, settled) => {
+		while (pq.size > 0) {
+			const key = pq.peekKey();
+			const pos = pq.peekVal();
+			if (settled[pos] || key !== dist[pos]) {
+				pq.pop();
+				continue;
+			}
+			return key;
+		}
+	};
+	const scanForward = () => {
+		const d = pqF.peekKey();
+		const u = pqF.peekVal();
+		pqF.pop();
+		settledF[u] = 1;
+		for (let a = csr.outOffsets[u]; a < csr.outOffsets[u + 1]; a++) {
+			const edge = graph.edges[csr.outEdgeIndex[a]];
+			const weight = effectiveWeight(edge);
+			const v = csr.outTargets[a];
+			const next = d + weight;
+			if (next < distF[v]) {
+				distF[v] = next;
+				predF[v] = u;
+				predFEdge[v] = csr.outEdgeIndex[a];
+				pqF.push(next, v);
+			}
+			if (distB[v] !== Infinity && next + distB[v] < mu) {
+				mu = next + distB[v];
+				meet = v;
+			}
+		}
+	};
+	const scanBackward = () => {
+		const d = pqB.peekKey();
+		const u = pqB.peekVal();
+		pqB.pop();
+		settledB[u] = 1;
+		for (let a = csr.inOffsets[u]; a < csr.inOffsets[u + 1]; a++) {
+			const edge = graph.edges[csr.inEdgeIndex[a]];
+			const weight = effectiveWeight(edge);
+			const v = csr.inOrigins[a];
+			const next = d + weight;
+			if (next < distB[v]) {
+				distB[v] = next;
+				predB[v] = u;
+				predBEdge[v] = csr.inEdgeIndex[a];
+				pqB.push(next, v);
+			}
+			if (distF[v] !== Infinity && next + distF[v] < mu) {
+				mu = next + distF[v];
+				meet = v;
+			}
+		}
+	};
+	for (;;) {
+		const topF = validTop(pqF, distF, settledF);
+		const topB = validTop(pqB, distB, settledB);
+		if (topF === void 0 || topB === void 0) break;
+		if (topF + topB >= mu) break;
+		if (topF <= topB) scanForward();
+		else scanBackward();
+	}
+	if (meet === -1) return void 0;
+	const steps = [];
+	for (let v = meet; v !== source; v = predF[v]) steps.unshift({
+		edge: graph.edges[predFEdge[v]],
+		node: graph.nodes[v]
+	});
+	for (let v = meet; v !== target;) {
+		const nextNode = predB[v];
+		steps.push({
+			edge: graph.edges[predBEdge[v]],
+			node: graph.nodes[nextNode]
+		});
+		v = nextNode;
+	}
+	return {
+		source: sourceNode,
+		steps
+	};
+}
+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 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();
+		}
+		visited.delete(nodeId);
+	}
+	yield* dfsCollect(sourceId);
+}
+function getSimplePath(graph, opts) {
+	for (const path of genSimplePaths(graph, opts)) return path;
+}
+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 neighborId of getNeighborIds(graph, id)) 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);
+		}
+	}
+	for (const node of graph.nodes) if (!nodeIndex.has(node.id)) strongconnect(node.id);
+	return result;
+}
+function getCycles(graph) {
+	return [...genCycles(graph)];
+}
+function* genCycles(graph) {
+	const kind = getEffectiveModeKind(graph);
+	if (kind === "mixed") yield* genCyclesMixed(graph);
+	else if (kind === "non-directed") 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);
+		}
+		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, arrivalEdgeId) {
+			visited.add(currentId);
+			for (const { neighborId, edge } of getNeighborEdgesAll(graph, currentId)) {
+				if (edge.id === arrivalEdgeId) continue;
+				if (neighborId === startId && (steps.length >= 1 || edge.sourceId === edge.targetId)) {
+					const cycleEdgeIds = [...steps.map((step) => step.edge.id), edge.id].sort().join(",");
+					if (!seen.has(cycleEdgeIds)) {
+						seen.add(cycleEdgeIds);
+						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, edge.id);
+					steps.pop();
+				}
+			}
+			visited.delete(currentId);
+		}
+		dfsFind(startId, null);
+		yield* found;
+	}
+}
+/**
+* Exact simple-cycle enumeration for graphs mixing directed and non-directed
+* edges. Traverses directed edges source→target only and non-directed edges
+* both ways; a cycle may use each edge at most once, visits distinct nodes,
+* and is identified by its set of traversed edge ids.
+*/
+function* genCyclesMixed(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 pathEdgeIds = /* @__PURE__ */ new Set();
+		const startNi = idx.nodeById.get(startId);
+		const startNode = graph.nodes[startNi];
+		const found = [];
+		function dfsFind(currentId) {
+			visited.add(currentId);
+			for (const { neighborId, edge } of getNeighborEdges(graph, currentId)) {
+				if (pathEdgeIds.has(edge.id)) continue;
+				if (neighborId === startId && (steps.length >= 1 || edge.sourceId === edge.targetId)) {
+					const cycleEdgeIds = [...steps.map((step) => step.edge.id), edge.id].sort().join(",");
+					if (!seen.has(cycleEdgeIds)) {
+						seen.add(cycleEdgeIds);
+						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]
+					});
+					pathEdgeIds.add(edge.id);
+					dfsFind(neighborId);
+					pathEdgeIds.delete(edge.id);
+					steps.pop();
+				}
+			}
+			visited.delete(currentId);
+		}
+		dfsFind(startId);
+		yield* found;
+	}
+}
+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 bellmanFordAllPaths(graph, getWeight) {
+	const results = [];
+	for (const node of graph.nodes) results.push(...getShortestPaths(graph, {
+		from: node.id,
+		getWeight,
+		algorithm: "bellman-ford"
+	}));
+	return results;
+}
+function dijkstraAllPaths(graph, getWeight) {
+	const results = [];
+	for (const node of graph.nodes) results.push(...getShortestPaths(graph, {
+		from: node.id,
+		getWeight
+	}));
+	return results;
+}
+function floydWarshallAllPaths(graph, getWeight) {
+	const idx = getIndex(graph);
+	const weight = getWeight ?? ((edge) => edge.weight ?? 1);
+	const nodeIds = graph.nodes.map((node) => node.id);
+	const 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 (getEdgeMode(graph, edge) !== "directed") {
+			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
+			});
+		}
+	}
+	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 });
+		}
+	}
+	for (let i = 0; i < nodeCount; i++) if (dist[i][i] < 0) throw new Error(`Negative cycle detected through node "${nodeIds[i]}": all-pairs shortest paths are undefined. Remove the negative cycle, or use getShortestPaths with { algorithm: 'bellman-ford' } per source to locate it.`);
+	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;
+}
+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 results;
+}
+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 csr = getCSR(graph);
+	const n = csr.ids.length;
+	const source = csr.indexOf.get(sourceId);
+	const target = csr.indexOf.get(targetId);
+	const gScore = new Float64Array(n).fill(Infinity);
+	const cameFromPos = new Int32Array(n).fill(-1);
+	const cameFromEdge = new Int32Array(n).fill(-1);
+	const closed = new Uint8Array(n);
+	const openSet = new TypedMinHeap(n);
+	assertNoNegativeWeights(graph, csr, opts.getWeight, "A*", "Use getShortestPath with { algorithm: 'bellman-ford' } instead.");
+	gScore[source] = 0;
+	openSet.push(heuristic(sourceId), source);
+	while (openSet.size > 0) {
+		const current = openSet.peekVal();
+		openSet.pop();
+		if (closed[current]) continue;
+		if (current === target) {
+			const steps = [];
+			let cursor = target;
+			while (cursor !== source) {
+				steps.unshift({
+					edge: graph.edges[cameFromEdge[cursor]],
+					node: graph.nodes[cursor]
+				});
+				cursor = cameFromPos[cursor];
+			}
+			return {
+				source: graph.nodes[sourceNi],
+				steps
+			};
+		}
+		closed[current] = 1;
+		for (let a = csr.outOffsets[current]; a < csr.outOffsets[current + 1]; a++) {
+			const edge = graph.edges[csr.outEdgeIndex[a]];
+			const weight = getWeight(edge);
+			const neighbor = csr.outTargets[a];
+			if (closed[neighbor]) continue;
+			const tentativeScore = gScore[current] + weight;
+			if (tentativeScore < gScore[neighbor]) {
+				cameFromPos[neighbor] = current;
+				cameFromEdge[neighbor] = csr.outEdgeIndex[a];
+				gScore[neighbor] = tentativeScore;
+				openSet.push(tentativeScore + heuristic(csr.ids[neighbor]), neighbor);
+			}
+		}
+	}
+}
+function getJoinedPath(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]
+	};
+}
+/**
+* @deprecated Use {@link getJoinedPath}.
+*/
+function joinPaths(headPath, tailPath) {
+	return getJoinedPath(headPath, tailPath);
+}
+
+//#endregion
+//#region src/transforms.ts
+/**
+* Flattens a hierarchical graph into a flat graph with only leaf nodes.
+*
+* - Edges targeting a compound node resolve to its initial child (recursively).
+* - Edges originating from a compound node expand to all leaf descendants.
+* - Only leaf nodes (nodes with no children) appear in the result.
+* - Duplicate edges (same source + target) are deduplicated.
+*
+* @example
+* ```ts
+* import { createGraph, getFlattenedGraph } from '@statelyai/graph';
+*
+* const graph = createGraph({
+*   nodes: [
+*     { id: 'parent', initialNodeId: 'child1' },
+*     { id: 'child1', parentId: 'parent' },
+*     { id: 'child2', parentId: 'parent' },
+*     { id: 'other' },
+*   ],
+*   edges: [{ id: 'e1', sourceId: 'other', targetId: 'parent' }],
+* });
+*
+* const flat = getFlattenedGraph(graph);
+* // flat.nodes → [child1, child2, other] (leaf nodes only)
+* // flat.edges → edge from 'other' → 'child1' (resolved via initialNodeId)
+* ```
+*/
+function getFlattenedGraph(graph) {
+	const idx = getIndex(graph);
+	const leaves = /* @__PURE__ */ new Set();
+	for (const node of graph.nodes) if ((idx.childNodes.get(node.id) ?? []).length === 0) leaves.add(node.id);
+	function resolveInitial(nodeId, seen = /* @__PURE__ */ new Set()) {
+		if (leaves.has(nodeId)) return nodeId;
+		if (seen.has(nodeId)) return null;
+		seen.add(nodeId);
+		const ni = idx.nodeById.get(nodeId);
+		if (ni === void 0) return null;
+		const node = graph.nodes[ni];
+		if (node.initialNodeId) return resolveInitial(node.initialNodeId, seen);
+		const childIds = idx.childNodes.get(nodeId) ?? [];
+		if (childIds.length > 0) return resolveInitial(childIds[0], seen);
+		return nodeId;
+	}
+	function getLeafDescendants(nodeId) {
+		if (leaves.has(nodeId)) return [nodeId];
+		const result = [];
+		const collect = (id) => {
+			const childIds = idx.childNodes.get(id) ?? [];
+			for (const childId of childIds) if (leaves.has(childId)) result.push(childId);
+			else collect(childId);
+		};
+		collect(nodeId);
+		return result;
+	}
+	const edgeSeen = /* @__PURE__ */ new Set();
+	const flatEdges = [];
+	for (const edge of graph.edges) {
+		const sources = leaves.has(edge.sourceId) ? [edge.sourceId] : getLeafDescendants(edge.sourceId);
+		const target = leaves.has(edge.targetId) ? edge.targetId : resolveInitial(edge.targetId);
+		if (target === null) continue;
+		for (const source of sources) {
+			const isAuthoredLeafSelfLoop = edge.sourceId === edge.targetId && leaves.has(edge.sourceId);
+			if (source === target && !isAuthoredLeafSelfLoop) continue;
+			const key = `${source}->${target}`;
+			if (edgeSeen.has(key)) continue;
+			edgeSeen.add(key);
+			flatEdges.push({
+				type: "edge",
+				id: `${edge.id}:${source}->${target}`,
+				sourceId: source,
+				targetId: target,
+				label: edge.label,
+				data: edge.data,
+				...edge.weight !== void 0 && { weight: edge.weight },
+				...edge.mode !== void 0 && { mode: edge.mode },
+				...source === edge.sourceId && edge.sourcePort !== void 0 && { sourcePort: edge.sourcePort },
+				...target === edge.targetId && edge.targetPort !== void 0 && { targetPort: edge.targetPort }
+			});
+		}
+	}
+	const leafNodes = graph.nodes.filter((n) => leaves.has(n.id)).map((n) => {
+		const { type, parentId, initialNodeId, ...rest } = n;
+		return rest;
+	});
+	return createGraph({
+		id: graph.id,
+		mode: graph.mode,
+		initialNodeId: graph.initialNodeId ? resolveInitial(graph.initialNodeId) ?? void 0 : void 0,
+		nodes: leafNodes,
+		edges: flatEdges,
+		data: graph.data
+	});
+}
+/**
+* @deprecated Use {@link getFlattenedGraph}.
+*/
+function flatten(graph) {
+	return getFlattenedGraph(graph);
+}
+/**
+* Convert a node to a config, stripping parentId/initialNodeId references
+* to nodes outside the given set.
+*/
+function toScopedNodeConfig(node, nodeIdSet) {
+	const config = toNodeConfig(node);
+	if (nodeIdSet) {
+		if (config.parentId != null && !nodeIdSet.has(config.parentId)) delete config.parentId;
+		if (config.initialNodeId != null && !nodeIdSet.has(config.initialNodeId)) delete config.initialNodeId;
+	}
+	return config;
+}
+/**
+* Returns the induced subgraph containing only the given node IDs
+* and edges whose endpoints are both in the set.
+*
+* Parent references to nodes outside the set are removed.
+*
+* @example
+* ```ts
+* import { createGraph, getSubgraph } 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 sub = getSubgraph(graph, ['a', 'b']);
+* // sub.nodes: [a, b], sub.edges: [ab]
+* ```
+*/
+function getSubgraph(graph, nodeIds) {
+	const nodeIdSet = new Set(nodeIds);
+	return createGraph({
+		id: graph.id,
+		mode: graph.mode,
+		initialNodeId: graph.initialNodeId && nodeIdSet.has(graph.initialNodeId) ? graph.initialNodeId : void 0,
+		nodes: graph.nodes.filter((n) => nodeIdSet.has(n.id)).map((n) => toScopedNodeConfig(n, nodeIdSet)),
+		edges: graph.edges.filter((e) => nodeIdSet.has(e.sourceId) && nodeIdSet.has(e.targetId)).map(toEdgeConfig),
+		data: graph.data
+	});
+}
+/**
+* Returns a new graph with all edge directions flipped (source ↔ target).
+* Optionally filters which edges to include.
+*
+* @example
+* ```ts
+* import { createGraph, getReversedGraph } 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 rev = getReversedGraph(graph);
+* // rev edges: b→a, c→b
+*
+* const filtered = getReversedGraph(graph, (e) => e.id !== 'bc');
+* // filtered edges: b→a (only ab reversed, bc excluded)
+* ```
+*/
+function getReversedGraph(graph, filterEdge) {
+	const edges = filterEdge ? graph.edges.filter(filterEdge) : graph.edges;
+	return createGraph({
+		id: graph.id,
+		mode: graph.mode,
+		initialNodeId: graph.initialNodeId ?? void 0,
+		nodes: graph.nodes.map((n) => toNodeConfig(n)),
+		edges: edges.map((e) => {
+			const config = toEdgeConfig(e);
+			config.sourceId = e.targetId;
+			config.targetId = e.sourceId;
+			delete config.sourcePort;
+			delete config.targetPort;
+			if (e.targetPort !== void 0) config.sourcePort = e.targetPort;
+			if (e.sourcePort !== void 0) config.targetPort = e.sourcePort;
+			return config;
+		}),
+		data: graph.data
+	});
+}
+/**
+* @deprecated Use {@link getReversedGraph}.
+*/
+function reverseGraph(graph, filterEdge) {
+	return getReversedGraph(graph, filterEdge);
+}
+
+//#endregion
+//#region src/algorithms/traversal.ts
+function* genBFS(graph, startId) {
+	const csr = getCSR(graph);
+	const start = csr.indexOf.get(startId);
+	if (start === void 0) return;
+	const n = csr.ids.length;
+	const visited = new Uint8Array(n);
+	const queue = new Int32Array(n);
+	visited[start] = 1;
+	queue[0] = start;
+	let head = 0;
+	let tail = 1;
+	while (head < tail) {
+		const u = queue[head++];
+		yield graph.nodes[u];
+		for (let a = csr.outOffsets[u]; a < csr.outOffsets[u + 1]; a++) {
+			const v = csr.outTargets[a];
+			if (!visited[v]) {
+				visited[v] = 1;
+				queue[tail++] = v;
+			}
+		}
+	}
+}
+/**
+* @deprecated Use {@link genBFS}.
+*/
+function* bfs(graph, startId) {
+	yield* genBFS(graph, startId);
+}
+function* genDFS(graph, startId) {
+	const csr = getCSR(graph);
+	const start = csr.indexOf.get(startId);
+	if (start === void 0) return;
+	const n = csr.ids.length;
+	const visited = new Uint8Array(n);
+	const stack = [start];
+	while (stack.length > 0) {
+		const u = stack.pop();
+		if (visited[u]) continue;
+		visited[u] = 1;
+		yield graph.nodes[u];
+		for (let a = csr.outOffsets[u]; a < csr.outOffsets[u + 1]; a++) {
+			const v = csr.outTargets[a];
+			if (!visited[v]) stack.push(v);
+		}
+	}
+}
+/**
+* @deprecated Use {@link genDFS}.
+*/
+function* dfs(graph, startId) {
+	yield* genDFS(graph, startId);
+}
+function isAcyclic(graph) {
+	const kind = getEffectiveModeKind(graph);
+	if (kind === "mixed") return isAcyclicMixed(graph);
+	if (kind === "non-directed") return isAcyclicUndirected(graph);
+	const WHITE = 0;
+	const GRAY = 1;
+	const BLACK = 2;
+	const color = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) color.set(node.id, WHITE);
+	const hasCycle = (id) => {
+		color.set(id, GRAY);
+		for (const neighborId of getSuccessorIds(graph, id)) {
+			const current = color.get(neighborId);
+			if (current === GRAY) return true;
+			if (current === WHITE && hasCycle(neighborId)) return true;
+		}
+		color.set(id, BLACK);
+		return false;
+	};
+	for (const node of graph.nodes) if (color.get(node.id) === WHITE && hasCycle(node.id)) return false;
+	return true;
+}
+/**
+* Acyclicity for graphs mixing directed and non-directed edges.
+*
+* Polynomial fast paths first: a cycle among directed edges alone, a cycle
+* among non-directed edges alone (union-find), or all-singleton reachability
+* SCCs (then no mixed cycle can exist either). Only ambiguous multi-node
+* SCCs fall back to exact simple-cycle enumeration, restricted to that SCC.
+*/
+function isAcyclicMixed(graph) {
+	const idx = getIndex(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 hasDirectedCycle = (id) => {
+		color.set(id, GRAY);
+		for (const eid of idx.outEdges.get(id) ?? []) {
+			const edge = graph.edges[idx.edgeById.get(eid)];
+			if (getEdgeMode(graph, edge) !== "directed") continue;
+			const current = color.get(edge.targetId);
+			if (current === GRAY) return true;
+			if (current === WHITE && hasDirectedCycle(edge.targetId)) return true;
+		}
+		color.set(id, BLACK);
+		return false;
+	};
+	for (const node of graph.nodes) if (color.get(node.id) === WHITE && hasDirectedCycle(node.id)) return false;
+	const parent = /* @__PURE__ */ new Map();
+	const find = (id) => {
+		let root = id;
+		while (parent.get(root) !== root) root = parent.get(root);
+		let cursor = id;
+		while (parent.get(cursor) !== root) {
+			const next = parent.get(cursor);
+			parent.set(cursor, root);
+			cursor = next;
+		}
+		return root;
+	};
+	for (const node of graph.nodes) parent.set(node.id, node.id);
+	for (const edge of graph.edges) {
+		if (getEdgeMode(graph, edge) === "directed") continue;
+		if (edge.sourceId === edge.targetId) return false;
+		const rootA = find(edge.sourceId);
+		const rootB = find(edge.targetId);
+		if (rootA === rootB) return false;
+		parent.set(rootA, rootB);
+	}
+	const multiNodeSccs = getStronglyConnectedComponents(graph).filter((component) => component.length > 1);
+	if (multiNodeSccs.length === 0) return true;
+	for (const component of multiNodeSccs) {
+		const subgraph = getSubgraph(graph, component.map((node) => node.id));
+		for (const _cycle of genCycles(subgraph)) return false;
+	}
+	return true;
+}
+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 (!visited.has(node.id) && hasCycle(node.id, null)) return false;
+	return true;
+}
+function getConnectedComponents(graph) {
+	const csr = getCSR(graph);
+	const n = csr.ids.length;
+	const visited = new Uint8Array(n);
+	const queue = new Int32Array(n);
+	const components = [];
+	for (let s = 0; s < n; s++) {
+		if (visited[s]) continue;
+		const component = [];
+		visited[s] = 1;
+		queue[0] = s;
+		let head = 0;
+		let tail = 1;
+		while (head < tail) {
+			const u = queue[head++];
+			component.push(graph.nodes[u]);
+			for (let a = csr.outOffsets[u]; a < csr.outOffsets[u + 1]; a++) {
+				const v = csr.outTargets[a];
+				if (!visited[v]) {
+					visited[v] = 1;
+					queue[tail++] = v;
+				}
+			}
+			for (let a = csr.inOffsets[u]; a < csr.inOffsets[u + 1]; a++) {
+				const v = csr.inOrigins[a];
+				if (!visited[v]) {
+					visited[v] = 1;
+					queue[tail++] = v;
+				}
+			}
+		}
+		components.push(component);
+	}
+	return components;
+}
+/**
+* Returns a topological ordering of the graph's nodes, or `null` if no such
+* ordering exists.
+*
+* Any edge whose effective mode (per {@link getEdgeMode}) is not `'directed'`
+* makes ordering impossible — an undirected/bidirectional edge is mutual
+* precedence, i.e. a 2-cycle — so the function returns `null`.
+*/
+function getTopologicalSort(graph) {
+	for (const edge of graph.edges) if (getEdgeMode(graph, edge) !== "directed") return null;
+	const idx = getIndex(graph);
+	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) 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;
+}
+function hasPath(graph, sourceId, targetId) {
+	if (sourceId === targetId) return true;
+	const visited = new Set([sourceId]);
+	const queue = [sourceId];
+	while (queue.length > 0) {
+		const id = queue.shift();
+		for (const neighborId of getNeighborIds(graph, id)) {
+			if (neighborId === targetId) return true;
+			if (!visited.has(neighborId)) {
+				visited.add(neighborId);
+				queue.push(neighborId);
+			}
+		}
+	}
+	return false;
+}
+function isConnected(graph) {
+	if (graph.nodes.length === 0) return true;
+	return getConnectedComponents(graph).length <= 1;
+}
+/**
+* Returns whether the graph is a tree: connected, acyclic, and with exactly
+* `nodes.length - 1` edges (so directed diamonds and parallel edges are not
+* trees). Empty and single-node graphs are considered trees.
+*/
+function isTree(graph) {
+	if (graph.nodes.length === 0) return true;
+	return graph.edges.length === graph.nodes.length - 1 && isConnected(graph) && isAcyclic(graph);
+}
+
+//#endregion
+//#region src/algorithms/ordering.ts
+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;
+}
+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;
+}
+function getPreorders(graph, opts) {
+	return [...genPreorders(graph, opts)];
+}
+function getPostorders(graph, opts) {
+	return [...genPostorders(graph, opts)];
+}
+function* genPreorders(graph, opts) {
+	const idx = getIndex(graph);
+	const startId = resolveFrom(graph, opts);
+	const startNi = idx.nodeById.get(startId);
+	const startNode = startNi !== void 0 ? graph.nodes[startNi] : void 0;
+	if (!startNode) return;
+	const queue = [{
+		visited: new Set([startId]),
+		preorder: [startNode],
+		dfsStack: [startId]
+	}];
+	while (queue.length > 0) {
+		const frame = queue.pop();
+		const { visited, dfsStack } = frame;
+		let { preorder } = frame;
+		let branched = false;
+		while (dfsStack.length > 0) {
+			const top = dfsStack[dfsStack.length - 1];
+			const unvisited = getNeighborIds(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;
+	}
+}
+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;
+			}
+			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;
+	}
+}
+
+//#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,
+		mode: graph.mode,
+		initialNodeId: graph.initialNodeId ?? void 0,
+		nodes: graph.nodes.map((node) => toNodeConfig(node)),
+		edges: mstEdges.map((edge) => toEdgeConfig(edge))
+	});
+}
+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 edge = graph.edges[ai];
+			if (!inMST.has(edge.targetId)) candidates.push({
+				weight: getWeight(edge),
+				edge
+			});
+		}
+		for (const eid of idx.inEdges.get(nodeId) ?? []) {
+			const ai = idx.edgeById.get(eid);
+			if (ai === void 0) continue;
+			const edge = graph.edges[ai];
+			if (getEdgeMode(graph, edge) !== "directed" && !inMST.has(edge.sourceId)) candidates.push({
+				weight: getWeight(edge),
+				edge
+			});
+		}
+	}
+	for (const node of graph.nodes) {
+		if (inMST.has(node.id)) continue;
+		inMST.add(node.id);
+		addEdgesOf(node.id);
+		while (candidates.size > 0 && inMST.size < graph.nodes.length) {
+			const { edge } = candidates.pop();
+			const targetId = getEdgeMode(graph, edge) !== "directed" && 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 createEmptyScoreMap(graph) {
+	return Object.fromEntries(graph.nodes.map((node) => [node.id, 0]));
+}
+function normalizeTypedVector(values) {
+	let sumOfSquares = 0;
+	for (let i = 0; i < values.length; i++) sumOfSquares += values[i] * values[i];
+	const magnitude = Math.sqrt(sumOfSquares);
+	if (magnitude === 0) return;
+	for (let i = 0; i < values.length; i++) values[i] /= magnitude;
+}
+/**
+* BFS hop distances from a start position over the CSR arc snapshot.
+* `dist[i] === -1` means unreachable. Returns the visit count.
+*/
+function bfsDistances(csr, start, dist, queue) {
+	dist.fill(-1);
+	dist[start] = 0;
+	queue[0] = start;
+	let head = 0;
+	let tail = 1;
+	while (head < tail) {
+		const u = queue[head++];
+		const du = dist[u];
+		for (let a = csr.outOffsets[u]; a < csr.outOffsets[u + 1]; a++) {
+			const v = csr.outTargets[a];
+			if (dist[v] === -1) {
+				dist[v] = du + 1;
+				queue[tail++] = v;
+			}
+		}
+	}
+	return tail;
+}
+/**
+* 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;
+	const scores = createEmptyScoreMap(graph);
+	for (const node of graph.nodes) scores[node.id] = getDegree(graph, node.id) * scale;
+	return scores;
+}
+/**
+* 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;
+	const scores = createEmptyScoreMap(graph);
+	for (const node of graph.nodes) scores[node.id] = getInDegree(graph, node.id) * scale;
+	return scores;
+}
+/**
+* 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 scores = createEmptyScoreMap(graph);
+	for (const node of graph.nodes) scores[node.id] = getOutDegree(graph, node.id) * scale;
+	return scores;
+}
+/**
+* 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 csr = getCSR(graph);
+	const order = csr.ids.length;
+	const dist = new Int32Array(order);
+	const queue = new Int32Array(order);
+	for (let s = 0; s < order; s++) {
+		const visited = bfsDistances(csr, s, dist, queue);
+		const reachable = visited - 1;
+		if (reachable === 0) continue;
+		let totalDistance = 0;
+		for (let k = 0; k < visited; k++) totalDistance += dist[queue[k]];
+		if (totalDistance === 0) continue;
+		const closeness = reachable / totalDistance;
+		scores[csr.ids[s]] = order > 1 ? closeness * (reachable / (order - 1)) : closeness;
+	}
+	return scores;
+}
+/**
+* Returns betweenness centrality scores for all nodes.
+*
+* Uses Brandes' algorithm over unweighted shortest paths and returns
+* normalized scores.
+*/
+function getBetweennessCentrality(graph) {
+	const csr = getCSR(graph);
+	const n = csr.ids.length;
+	const totals = new Float64Array(n);
+	const sigma = new Float64Array(n);
+	const dist = new Int32Array(n);
+	const delta = new Float64Array(n);
+	const order_ = new Int32Array(n);
+	for (let s = 0; s < n; s++) {
+		sigma.fill(0);
+		dist.fill(-1);
+		delta.fill(0);
+		sigma[s] = 1;
+		dist[s] = 0;
+		order_[0] = s;
+		let head = 0;
+		let tail = 1;
+		while (head < tail) {
+			const u = order_[head++];
+			const du = dist[u];
+			for (let a = csr.outOffsets[u]; a < csr.outOffsets[u + 1]; a++) {
+				const v = csr.outTargets[a];
+				if (dist[v] === -1) {
+					dist[v] = du + 1;
+					order_[tail++] = v;
+				}
+				if (dist[v] === du + 1) sigma[v] += sigma[u];
+			}
+		}
+		for (let k = tail - 1; k >= 0; k--) {
+			const w = order_[k];
+			const sigmaW = sigma[w];
+			if (sigmaW === 0) continue;
+			const coefficient = (1 + delta[w]) / sigmaW;
+			for (let a = csr.inOffsets[w]; a < csr.inOffsets[w + 1]; a++) {
+				const v = csr.inOrigins[a];
+				if (dist[v] === dist[w] - 1) delta[v] += sigma[v] * coefficient;
+			}
+			if (w !== s) totals[w] += delta[w];
+		}
+	}
+	const scores = createEmptyScoreMap(graph);
+	for (let i = 0; i < n; i++) scores[csr.ids[i]] = totals[i];
+	const order = graph.nodes.length;
+	if (order <= 2) return scores;
+	const scale = graph.mode !== "directed" ? 1 / ((order - 1) * (order - 2) / 2) : 1 / ((order - 1) * (order - 2));
+	for (const nodeId of Object.keys(scores)) {
+		if (graph.mode !== "directed") scores[nodeId] /= 2;
+		scores[nodeId] *= scale;
+	}
+	return scores;
+}
+/**
+* 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]));
+	const csr = getCSR(graph);
+	const n = csr.ids.length;
+	let current = new Float64Array(n).fill(1 / n);
+	for (let i = 0; i < n; i++) current[i] = scores[csr.ids[i]];
+	for (let iteration = 0; iteration < maxIterations; iteration++) {
+		const next = new Float64Array(n).fill((1 - alpha) / n);
+		let danglingMass = 0;
+		for (let u = 0; u < n; u++) {
+			const arcCount = csr.outOffsets[u + 1] - csr.outOffsets[u];
+			if (arcCount === 0) {
+				danglingMass += current[u];
+				continue;
+			}
+			const share = alpha * current[u] / arcCount;
+			for (let a = csr.outOffsets[u]; a < csr.outOffsets[u + 1]; a++) next[csr.outTargets[a]] += share;
+		}
+		if (danglingMass > 0) {
+			const share = alpha * danglingMass / n;
+			for (let i = 0; i < n; i++) next[i] += share;
+		}
+		let diff = 0;
+		for (let i = 0; i < n; i++) diff = Math.max(diff, Math.abs(current[i] - next[i]));
+		current = next;
+		if (diff <= tolerance) break;
+	}
+	for (let i = 0; i < n; i++) scores[csr.ids[i]] = current[i];
+	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) {
+	if (getNodeIds(graph).length === 0) return {
+		hubs: {},
+		authorities: {}
+	};
+	const maxIterations = options?.maxIterations ?? 100;
+	const tolerance = options?.tolerance ?? 1e-6;
+	const csr = getCSR(graph);
+	const n = csr.ids.length;
+	let hubs = new Float64Array(n).fill(1);
+	let authorities = new Float64Array(n);
+	for (let iteration = 0; iteration < maxIterations; iteration++) {
+		const nextAuthorities = new Float64Array(n);
+		for (let w = 0; w < n; w++) for (let a = csr.inOffsets[w]; a < csr.inOffsets[w + 1]; a++) nextAuthorities[w] += hubs[csr.inOrigins[a]];
+		normalizeTypedVector(nextAuthorities);
+		const nextHubs = new Float64Array(n);
+		for (let u = 0; u < n; u++) for (let a = csr.outOffsets[u]; a < csr.outOffsets[u + 1]; a++) nextHubs[u] += nextAuthorities[csr.outTargets[a]];
+		normalizeTypedVector(nextHubs);
+		let diff = 0;
+		for (let i = 0; i < n; i++) diff = Math.max(diff, Math.abs(hubs[i] - nextHubs[i]), Math.abs(authorities[i] - nextAuthorities[i]));
+		hubs = nextHubs;
+		authorities = nextAuthorities;
+		if (diff <= tolerance) break;
+	}
+	const hubScores = createEmptyScoreMap(graph);
+	const authorityScores = createEmptyScoreMap(graph);
+	for (let i = 0; i < n; i++) {
+		hubScores[csr.ids[i]] = hubs[i];
+		authorityScores[csr.ids[i]] = authorities[i];
+	}
+	return {
+		hubs: hubScores,
+		authorities: authorityScores
+	};
+}
+/**
+* Returns eigenvector centrality scores for all nodes.
+*
+* Power iteration with the `A + I` shift (same scheme as graphology and
+* networkx, so bipartite structures converge instead of oscillating).
+* Scores flow along edge direction: a node's score is fed by its incoming
+* neighbors; undirected edges feed both endpoints. The result vector is
+* Euclidean (L2) normalized.
+*
+* Throws when the iteration has not converged (L1 error < `n × tolerance`)
+* within `maxIterations`.
+*/
+function getEigenvectorCentrality(graph, options) {
+	if (getNodeIds(graph).length === 0) return {};
+	const maxIterations = options?.maxIterations ?? 100;
+	const tolerance = options?.tolerance ?? 1e-6;
+	const getWeight = options?.getWeight;
+	const csr = getCSR(graph);
+	const n = csr.ids.length;
+	let current = new Float64Array(n).fill(1 / n);
+	let converged = false;
+	for (let iteration = 0; iteration < maxIterations; iteration++) {
+		const next = Float64Array.from(current);
+		for (let w = 0; w < n; w++) for (let a = csr.inOffsets[w]; a < csr.inOffsets[w + 1]; a++) {
+			const weight = getWeight ? getWeight(graph.edges[csr.inEdgeIndex[a]]) : 1;
+			next[w] += current[csr.inOrigins[a]] * weight;
+		}
+		normalizeTypedVector(next);
+		let error = 0;
+		for (let i = 0; i < n; i++) error += Math.abs(next[i] - current[i]);
+		current = next;
+		if (error < n * tolerance) {
+			converged = true;
+			break;
+		}
+	}
+	if (!converged) throw new Error(`getEigenvectorCentrality: power iteration failed to converge within ${maxIterations} iterations (tolerance ${tolerance}) — increase options.maxIterations or loosen options.tolerance`);
+	const scores = createEmptyScoreMap(graph);
+	for (let i = 0; i < n; i++) scores[csr.ids[i]] = current[i];
+	return scores;
+}
+/**
+* Returns Katz centrality scores for all nodes.
+*
+* Iterates `x' = alpha · Aᵀx + beta` to its fixed point (networkx-style),
+* then Euclidean (L2) normalizes the result. Scores flow along edge
+* direction: a node's score is fed by its incoming neighbors; undirected
+* edges feed both endpoints.
+*
+* Converges only when `alpha` is below the reciprocal of the largest
+* eigenvalue of the adjacency matrix; throws when the iteration has not
+* converged (L1 error < `n × tolerance`) within `maxIterations`.
+*/
+function getKatzCentrality(graph, options) {
+	if (getNodeIds(graph).length === 0) return {};
+	const alpha = options?.alpha ?? .1;
+	const beta = options?.beta ?? 1;
+	const maxIterations = options?.maxIterations ?? 100;
+	const tolerance = options?.tolerance ?? 1e-6;
+	const getWeight = options?.getWeight;
+	const csr = getCSR(graph);
+	const n = csr.ids.length;
+	let current = new Float64Array(n);
+	let converged = false;
+	for (let iteration = 0; iteration < maxIterations; iteration++) {
+		const next = new Float64Array(n).fill(beta);
+		for (let w = 0; w < n; w++) for (let a = csr.inOffsets[w]; a < csr.inOffsets[w + 1]; a++) {
+			const weight = getWeight ? getWeight(graph.edges[csr.inEdgeIndex[a]]) : 1;
+			next[w] += alpha * current[csr.inOrigins[a]] * weight;
+		}
+		let error = 0;
+		for (let i = 0; i < n; i++) error += Math.abs(next[i] - current[i]);
+		current = next;
+		if (error < n * tolerance) {
+			converged = true;
+			break;
+		}
+	}
+	if (!converged) throw new Error(`getKatzCentrality: iteration failed to converge within ${maxIterations} iterations — alpha ${alpha} may be >= 1/λ_max of the adjacency matrix; decrease options.alpha or increase options.maxIterations`);
+	normalizeTypedVector(current);
+	const scores = createEmptyScoreMap(graph);
+	for (let i = 0; i < n; i++) scores[csr.ids[i]] = current[i];
+	return scores;
+}
+
+//#endregion
+//#region src/algorithms/cores.ts
+/**
+* Undirected adjacency over node positions: every edge (regardless of mode
+* or direction) contributes both arcs, matching the standard k-core
+* definition. Self-loops are ignored. Positions come from the CSR snapshot
+* so `ids` order matches `graph.nodes`.
+*/
+function buildUndirectedAdjacency(graph) {
+	const csr = getCSR(graph);
+	const n = csr.ids.length;
+	const m = graph.edges.length;
+	const sourcePos = new Int32Array(m);
+	const targetPos = new Int32Array(m);
+	const degree = new Int32Array(n);
+	let arcCount = 0;
+	for (let e = 0; e < m; e++) {
+		const edge = graph.edges[e];
+		const s = csr.indexOf.get(edge.sourceId);
+		const t = csr.indexOf.get(edge.targetId);
+		if (s === t) {
+			sourcePos[e] = -1;
+			continue;
+		}
+		sourcePos[e] = s;
+		targetPos[e] = t;
+		degree[s]++;
+		degree[t]++;
+		arcCount += 2;
+	}
+	const offsets = new Int32Array(n + 1);
+	for (let i = 0; i < n; i++) offsets[i + 1] = offsets[i] + degree[i];
+	const targets = new Int32Array(arcCount);
+	const cursor = Int32Array.from(offsets.subarray(0, n));
+	for (let e = 0; e < m; e++) {
+		if (sourcePos[e] === -1) continue;
+		targets[cursor[sourcePos[e]]++] = targetPos[e];
+		targets[cursor[targetPos[e]]++] = sourcePos[e];
+	}
+	return {
+		ids: csr.ids,
+		offsets,
+		targets
+	};
+}
+/**
+* Returns the core number of every node (largest `k` such that the node
+* belongs to the k-core).
+*
+* Uses Batagelj–Zaveršnik bucket peeling — O(m). Edges are treated as
+* undirected (the standard k-core definition); self-loops are ignored.
+*
+* @example
+* ```ts
+* const cores = getCoreNumbers(graph);
+* console.log(cores.a); // 3
+* ```
+*/
+function getCoreNumbers(graph) {
+	const { ids, offsets, targets } = buildUndirectedAdjacency(graph);
+	const n = ids.length;
+	const core = new Int32Array(n);
+	let maxDegree = 0;
+	for (let i = 0; i < n; i++) {
+		core[i] = offsets[i + 1] - offsets[i];
+		if (core[i] > maxDegree) maxDegree = core[i];
+	}
+	const bin = new Int32Array(maxDegree + 1);
+	for (let i = 0; i < n; i++) bin[core[i]]++;
+	let start = 0;
+	for (let d = 0; d <= maxDegree; d++) {
+		const count = bin[d];
+		bin[d] = start;
+		start += count;
+	}
+	const vert = new Int32Array(n);
+	const pos = new Int32Array(n);
+	for (let i = 0; i < n; i++) {
+		pos[i] = bin[core[i]];
+		vert[pos[i]] = i;
+		bin[core[i]]++;
+	}
+	for (let d = maxDegree; d > 0; d--) bin[d] = bin[d - 1];
+	bin[0] = 0;
+	for (let k = 0; k < n; k++) {
+		const v = vert[k];
+		for (let a = offsets[v]; a < offsets[v + 1]; a++) {
+			const u = targets[a];
+			if (core[u] > core[v]) {
+				const du = core[u];
+				const pu = pos[u];
+				const pw = bin[du];
+				const w = vert[pw];
+				if (u !== w) {
+					vert[pu] = w;
+					pos[w] = pu;
+					vert[pw] = u;
+					pos[u] = pw;
+				}
+				bin[du]++;
+				core[u]--;
+			}
+		}
+	}
+	const result = {};
+	for (let i = 0; i < n; i++) result[ids[i]] = core[i];
+	return result;
+}
+/**
+* Returns the ids of all nodes in the k-core: the maximal subgraph in which
+* every node has at least `k` neighbors (edges treated as undirected).
+*
+* Node order follows `graph.nodes`. `k <= 0` returns every node id.
+*/
+function getKCore(graph, k) {
+	const cores = getCoreNumbers(graph);
+	return graph.nodes.filter((node) => cores[node.id] >= k).map((node) => node.id);
+}
+
+//#endregion
+//#region src/algorithms/bipartite.ts
+/**
+* BFS 2-coloring over undirected adjacency. Edges are treated as undirected
+* regardless of mode/direction. Returns either the coloring or the edge that
+* proves the graph is not bipartite.
+*/
+function getTwoColoring(graph) {
+	const csr = getCSR(graph);
+	const n = csr.ids.length;
+	const m = graph.edges.length;
+	const degree = new Int32Array(n);
+	for (let e = 0; e < m; e++) {
+		const edge = graph.edges[e];
+		if (edge.sourceId === edge.targetId) return { conflictEdgeId: edge.id };
+		degree[csr.indexOf.get(edge.sourceId)]++;
+		degree[csr.indexOf.get(edge.targetId)]++;
+	}
+	const offsets = new Int32Array(n + 1);
+	for (let i = 0; i < n; i++) offsets[i + 1] = offsets[i] + degree[i];
+	const targets = new Int32Array(offsets[n]);
+	const arcEdge = new Int32Array(offsets[n]);
+	const cursor = Int32Array.from(offsets.subarray(0, n));
+	for (let e = 0; e < m; e++) {
+		const edge = graph.edges[e];
+		const s = csr.indexOf.get(edge.sourceId);
+		const t = csr.indexOf.get(edge.targetId);
+		targets[cursor[s]] = t;
+		arcEdge[cursor[s]++] = e;
+		targets[cursor[t]] = s;
+		arcEdge[cursor[t]++] = e;
+	}
+	const colors = new Int8Array(n).fill(-1);
+	const queue = new Int32Array(n);
+	for (let root = 0; root < n; root++) {
+		if (colors[root] !== -1) continue;
+		colors[root] = 0;
+		queue[0] = root;
+		let head = 0;
+		let tail = 1;
+		while (head < tail) {
+			const u = queue[head++];
+			for (let a = offsets[u]; a < offsets[u + 1]; a++) {
+				const v = targets[a];
+				if (colors[v] === -1) {
+					colors[v] = 1 - colors[u];
+					queue[tail++] = v;
+				} else if (colors[v] === colors[u]) return { conflictEdgeId: graph.edges[arcEdge[a]].id };
+			}
+		}
+	}
+	return { colors };
+}
+/**
+* Returns whether the graph is bipartite (2-colorable).
+*
+* Edges are treated as undirected; self-loops make a graph non-bipartite.
+* Runs a BFS 2-coloring per connected component — O(n + m).
+*/
+function isBipartite(graph) {
+	return "colors" in getTwoColoring(graph);
+}
+/**
+* Returns a maximum-cardinality matching of a bipartite graph using
+* Hopcroft–Karp — O(m·√n).
+*
+* The bipartition is derived by 2-coloring (edges treated as undirected).
+* Each match reports the realizing edge with its stored `sourceId`/
+* `targetId` orientation; for parallel edges between a matched pair, the
+* first edge used by the algorithm is reported.
+*
+* Throws if the graph is not bipartite, naming the offending edge.
+*/
+function getMaximumBipartiteMatching(graph) {
+	const coloring = getTwoColoring(graph);
+	if (!("colors" in coloring)) throw new Error(`getMaximumBipartiteMatching: graph is not bipartite — edge "${coloring.conflictEdgeId}" closes an odd cycle (or is a self-loop); a maximum bipartite matching requires a bipartite graph, check with isBipartite() first`);
+	const { colors } = coloring;
+	const csr = getCSR(graph);
+	const n = csr.ids.length;
+	const m = graph.edges.length;
+	const degree = new Int32Array(n);
+	for (let e = 0; e < m; e++) {
+		const edge = graph.edges[e];
+		const s = csr.indexOf.get(edge.sourceId);
+		const t = csr.indexOf.get(edge.targetId);
+		degree[colors[s] === 0 ? s : t]++;
+	}
+	const offsets = new Int32Array(n + 1);
+	for (let i = 0; i < n; i++) offsets[i + 1] = offsets[i] + degree[i];
+	const targets = new Int32Array(offsets[n]);
+	const arcEdge = new Int32Array(offsets[n]);
+	const cursor = Int32Array.from(offsets.subarray(0, n));
+	for (let e = 0; e < m; e++) {
+		const edge = graph.edges[e];
+		const s = csr.indexOf.get(edge.sourceId);
+		const t = csr.indexOf.get(edge.targetId);
+		const left = colors[s] === 0 ? s : t;
+		const right = colors[s] === 0 ? t : s;
+		targets[cursor[left]] = right;
+		arcEdge[cursor[left]++] = e;
+	}
+	const INF = 2147483647;
+	const matchLeft = new Int32Array(n).fill(-1);
+	const matchRight = new Int32Array(n).fill(-1);
+	const matchEdge = new Int32Array(n).fill(-1);
+	const dist = new Int32Array(n);
+	const queue = new Int32Array(n);
+	function hasAugmentingLayer() {
+		let head = 0;
+		let tail = 0;
+		for (let u = 0; u < n; u++) {
+			if (colors[u] !== 0) continue;
+			if (matchLeft[u] === -1) {
+				dist[u] = 0;
+				queue[tail++] = u;
+			} else dist[u] = INF;
+		}
+		let foundAugmenting = false;
+		while (head < tail) {
+			const u = queue[head++];
+			for (let a = offsets[u]; a < offsets[u + 1]; a++) {
+				const w = matchRight[targets[a]];
+				if (w === -1) foundAugmenting = true;
+				else if (dist[w] === INF) {
+					dist[w] = dist[u] + 1;
+					queue[tail++] = w;
+				}
+			}
+		}
+		return foundAugmenting;
+	}
+	function hasAugmentedMatchFrom(u) {
+		for (let a = offsets[u]; a < offsets[u + 1]; a++) {
+			const v = targets[a];
+			const w = matchRight[v];
+			if (w === -1 || dist[w] === dist[u] + 1 && hasAugmentedMatchFrom(w)) {
+				matchLeft[u] = v;
+				matchRight[v] = u;
+				matchEdge[u] = arcEdge[a];
+				return true;
+			}
+		}
+		dist[u] = INF;
+		return false;
+	}
+	while (hasAugmentingLayer()) for (let u = 0; u < n; u++) if (colors[u] === 0 && matchLeft[u] === -1) hasAugmentedMatchFrom(u);
+	const matches = [];
+	for (let u = 0; u < n; u++) {
+		if (matchEdge[u] === -1) continue;
+		const edge = graph.edges[matchEdge[u]];
+		matches.push({
+			sourceId: edge.sourceId,
+			targetId: edge.targetId,
+			edgeId: edge.id
+		});
+	}
+	return matches;
+}
+
+//#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;
+}
+function getUndirectedConnectedComponents(graph) {
+	const idx = getIndex(graph);
+	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);
+			}
+		}
+		communities.push(community.sort((a, b) => a.id.localeCompare(b.id)));
+	}
+	return communities.sort((a, b) => a[0].id.localeCompare(b[0].id));
+}
+function getNodeMap(graph) {
+	return new Map(graph.nodes.map((node) => [node.id, node]));
+}
+function normalizeCommunities(graph, labels) {
+	const nodeMap = getNodeMap(graph);
+	const grouped = /* @__PURE__ */ new Map();
+	for (const [nodeId, label] of Object.entries(labels)) {
+		if (!grouped.has(label)) grouped.set(label, []);
+		const node = nodeMap.get(nodeId);
+		if (node) grouped.get(label).push(node);
+	}
+	return [...grouped.values()].map((community) => community.sort((a, b) => a.id.localeCompare(b.id))).sort((a, b) => a[0].id.localeCompare(b[0].id));
+}
+function getEdgeBetweenness(graph) {
+	const scores = Object.fromEntries(graph.edges.map((edge) => [edge.id, 0]));
+	for (const source of graph.nodes) {
+		const stack = [];
+		const predecessors = /* @__PURE__ */ new Map();
+		const sigma = /* @__PURE__ */ new Map();
+		const distance = /* @__PURE__ */ new Map();
+		const queue = [source.id];
+		for (const node of graph.nodes) {
+			predecessors.set(node.id, []);
+			sigma.set(node.id, 0);
+			distance.set(node.id, -1);
+		}
+		sigma.set(source.id, 1);
+		distance.set(source.id, 0);
+		while (queue.length > 0) {
+			const currentId = queue.shift();
+			stack.push(currentId);
+			for (const neighbor of getUndirectedNeighbors$1(graph, currentId)) {
+				if (distance.get(neighbor.nodeId) === -1) {
+					queue.push(neighbor.nodeId);
+					distance.set(neighbor.nodeId, distance.get(currentId) + 1);
+				}
+				if (distance.get(neighbor.nodeId) === distance.get(currentId) + 1) {
+					sigma.set(neighbor.nodeId, sigma.get(neighbor.nodeId) + sigma.get(currentId));
+					predecessors.get(neighbor.nodeId).push({
+						nodeId: currentId,
+						edgeId: neighbor.edgeId
+					});
+				}
+			}
+		}
+		const delta = /* @__PURE__ */ new Map();
+		for (const node of graph.nodes) delta.set(node.id, 0);
+		while (stack.length > 0) {
+			const nodeId = stack.pop();
+			const sigmaNode = sigma.get(nodeId);
+			if (sigmaNode === 0) continue;
+			for (const predecessor of predecessors.get(nodeId)) {
+				const contribution = sigma.get(predecessor.nodeId) / sigmaNode * (1 + delta.get(nodeId));
+				scores[predecessor.edgeId] += contribution;
+				delta.set(predecessor.nodeId, delta.get(predecessor.nodeId) + contribution);
+			}
+		}
+	}
+	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)));
+}
+/**
+* Asynchronous LPA: labels update in place as the (seeded-shuffled) round
+* proceeds; ties among maximal neighbor labels break uniformly at random,
+* keeping the current label when it is already maximal so rounds terminate.
+* Deterministic per seed.
+*/
+function getSeededLabelPropagation(graph, seed, maxIterations) {
+	const rng = mulberry32(seed);
+	const labels = Object.fromEntries(graph.nodes.map((node) => [node.id, node.id]));
+	const order = graph.nodes.map((node) => node.id);
+	for (let iteration = 0; iteration < maxIterations; iteration++) {
+		for (let i = order.length - 1; i > 0; i--) {
+			const j = Math.floor(rng() * (i + 1));
+			[order[i], order[j]] = [order[j], order[i]];
+		}
+		let changed = false;
+		for (const nodeId of order) {
+			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;
+			let maxCount = 0;
+			for (const count of counts.values()) if (count > maxCount) maxCount = count;
+			const best = [];
+			for (const [label, count] of counts) if (count === maxCount) best.push(label);
+			if (best.includes(labels[nodeId])) continue;
+			labels[nodeId] = best[Math.floor(rng() * best.length)];
+			changed = true;
+		}
+		if (!changed) break;
+	}
+	return normalizeCommunities(graph, labels);
+}
+/**
+* Returns label-propagation communities for the graph.
+*
+* The implementation is deterministic: ties are broken by lexicographic label
+* order so test results remain stable. Pass `options.seed` for the classic
+* asynchronous variant (shuffled node order per round, random tie-breaking)
+* — still deterministic per seed.
+*/
+function getLabelPropagationCommunities(graph, options) {
+	if (graph.nodes.length === 0) return [];
+	const maxIterations = options?.maxIterations ?? 50;
+	if (options?.seed !== void 0) return getSeededLabelPropagation(graph, options.seed, maxIterations);
+	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;
+			}
+		}
+		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;
+		}
+	}
+}
+/**
+* Returns the requested Girvan-Newman split level eagerly.
+*
+* `level: 1` returns the first split yielded by `genGirvanNewmanCommunities`.
+*/
+function getGirvanNewmanCommunities(graph, options) {
+	if (graph.nodes.length === 0) return [];
+	const targetLevel = options?.level ?? 1;
+	if (targetLevel <= 0) return getUndirectedConnectedComponents(graph);
+	let last = getUndirectedConnectedComponents(graph);
+	let level = 0;
+	for (const partition of genGirvanNewmanCommunities(graph, { maxLevels: targetLevel })) {
+		last = partition;
+		level++;
+		if (level >= targetLevel) break;
+	}
+	return last;
+}
+/**
+* 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 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;
+			}
+		}
+		if (!bestMerge) break;
+		communities = bestMerge.sort((a, b) => a[0].id.localeCompare(b[0].id));
+		currentScore = bestScore;
+	}
+	return communities;
+}
+
+//#endregion
+//#region src/algorithms/connectivity.ts
+function getUndirectedNeighbors(graph, nodeId) {
+	const idx = getIndex(graph);
+	const neighbors = [];
+	for (const edgeId of idx.outEdges.get(nodeId) ?? []) {
+		const edgeIndex = idx.edgeById.get(edgeId);
+		if (edgeIndex !== void 0) neighbors.push({
+			nodeId: graph.edges[edgeIndex].targetId,
+			edgeId
+		});
+	}
+	for (const edgeId of idx.inEdges.get(nodeId) ?? []) {
+		const edgeIndex = idx.edgeById.get(edgeId);
+		if (edgeIndex !== void 0) neighbors.push({
+			nodeId: graph.edges[edgeIndex].sourceId,
+			edgeId
+		});
+	}
+	return neighbors;
+}
+function popComponentUntil(state, stopEdgeId) {
+	const nodeIds = /* @__PURE__ */ new Set();
+	while (state.edgeStack.length > 0) {
+		const edgeId = state.edgeStack.pop();
+		const edge = state.edgeById.get(edgeId);
+		if (edge) {
+			nodeIds.add(edge.sourceId);
+			nodeIds.add(edge.targetId);
+		}
+		if (edgeId === stopEdgeId) break;
+	}
+	if (nodeIds.size > 0) state.components.push(nodeIds);
+}
+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);
+		}
+	}
+	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 (state.low.get(neighbor.nodeId) >= state.disc.get(nodeId)) {
+				if (parentEdgeId !== null) 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)));
+		}
+	}
+	if (parentEdgeId === null && childCount > 1) state.articulationPoints.add(nodeId);
+}
+function analyzeConnectivity(graph) {
+	const state = {
+		time: 0,
+		disc: /* @__PURE__ */ new Map(),
+		low: /* @__PURE__ */ new Map(),
+		edgeStack: [],
+		bridges: /* @__PURE__ */ new Set(),
+		articulationPoints: /* @__PURE__ */ new Set(),
+		components: [],
+		nodeById: new Map(graph.nodes.map((node) => [node.id, node])),
+		edgeById: new Map(graph.edges.map((edge) => [edge.id, edge]))
+	};
+	for (const node of graph.nodes) {
+		if (state.disc.has(node.id)) continue;
+		traverseConnectivity(graph, node.id, null, state);
+		finalizeRemainingComponent(state);
+	}
+	return state;
+}
+/**
+* Returns bridge edges whose removal disconnects the graph.
+*
+* Connectivity algorithms in this module treat the graph as undirected.
+*/
+function getBridges(graph) {
+	if (graph.edges.length === 0) return [];
+	const state = analyzeConnectivity(graph);
+	return [...state.bridges].map((edgeId) => state.edgeById.get(edgeId)).sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+* Returns articulation points (cut vertices) for the graph.
+*
+* Connectivity algorithms in this module treat the graph as undirected.
+*/
+function getArticulationPoints(graph) {
+	if (graph.nodes.length === 0) return [];
+	const state = analyzeConnectivity(graph);
+	return [...state.articulationPoints].map((nodeId) => state.nodeById.get(nodeId)).sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+* Returns biconnected components as arrays of nodes.
+*
+* Articulation points may appear in multiple returned components.
+*/
+function getBiconnectedComponents(graph) {
+	if (graph.edges.length === 0) return [];
+	const state = analyzeConnectivity(graph);
+	return state.components.map((component) => [...component].map((nodeId) => state.nodeById.get(nodeId)).sort((a, b) => a.id.localeCompare(b.id))).sort((a, b) => a[0].id.localeCompare(b[0].id));
+}
+
+//#endregion
+//#region src/algorithms/isomorphism.ts
+function getDegreeSignature(graph, nodeId) {
+	const idx = getIndex(graph);
+	let inDegree = 0;
+	let outDegree = 0;
+	let undirected = 0;
+	const countedNonDirected = /* @__PURE__ */ new Set();
+	for (const eid of idx.outEdges.get(nodeId) ?? []) {
+		const edge = graph.edges[idx.edgeById.get(eid)];
+		if (getEdgeMode(graph, edge) === "directed") outDegree++;
+		else if (!countedNonDirected.has(eid)) {
+			countedNonDirected.add(eid);
+			undirected++;
+		}
+	}
+	for (const eid of idx.inEdges.get(nodeId) ?? []) {
+		const edge = graph.edges[idx.edgeById.get(eid)];
+		if (getEdgeMode(graph, edge) === "directed") inDegree++;
+		else if (!countedNonDirected.has(eid)) {
+			countedNonDirected.add(eid);
+			undirected++;
+		}
+	}
+	return `d:${inDegree}:${outDegree}:u:${undirected}`;
+}
+function getEdgesBetween(graph, sourceId, targetId) {
+	return graph.edges.filter((edge) => {
+		if (edge.sourceId === sourceId && edge.targetId === targetId) return true;
+		return edge.sourceId === targetId && edge.targetId === sourceId && getEdgeMode(graph, edge) !== "directed";
+	});
+}
+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.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;
+			if (!edgesAreCompatible(getEdgesBetween(graphA, nodeA.id, nodeA.id), getEdgesBetween(graphB, nodeB.id, nodeB.id), edgeMatch)) continue;
+			let compatible = true;
+			for (const [mappedAId, mappedBId] of mapping.entries()) {
+				if (!edgesAreCompatible(getEdgesBetween(graphA, nodeA.id, mappedAId), getEdgesBetween(graphB, nodeB.id, mappedBId), edgeMatch)) {
+					compatible = false;
+					break;
+				}
+				if (!edgesAreCompatible(getEdgesBetween(graphA, mappedAId, nodeA.id), getEdgesBetween(graphB, mappedBId, nodeB.id), edgeMatch)) {
+					compatible = false;
+					break;
+				}
+			}
+			if (!compatible) continue;
+			mapping.set(nodeA.id, nodeB.id);
+			usedB.add(nodeB.id);
+			if (backtrack(index + 1)) return true;
+			mapping.delete(nodeA.id);
+			usedB.delete(nodeB.id);
+		}
+		return false;
+	};
+	return backtrack(0);
+}
+
+//#endregion
+//#region src/algorithms/louvain.ts
+/**
+* Returns communities found by the classic two-phase Louvain modularity
+* optimization (local moving + community aggregation).
+*
+* Like the other community algorithms in this library, the graph is treated
+* as undirected regardless of `graph.mode` or per-edge modes. Parallel edges
+* have their weights summed; self-loops contribute to a community's internal
+* weight.
+*
+* The implementation is deterministic: nodes are visited in `graph.nodes`
+* array order and there is no random shuffling, so tie-breaking is
+* order-dependent but stable across runs.
+*
+* Returns communities of node ids, each community sorted lexicographically
+* and communities sorted by their first id.
+*
+* @example
+* ```ts
+* const communities = getLouvainCommunities(graph);
+* // [['a', 'b', 'c'], ['d', 'e', 'f']]
+* ```
+*/
+function getLouvainCommunities(graph, options) {
+	if (graph.nodes.length === 0) return [];
+	const getWeight = options?.getWeight ?? ((edge) => edge.weight ?? 1);
+	const resolution = options?.resolution ?? 1;
+	const maxPasses = options?.maxPasses ?? 10;
+	const nodeIds = graph.nodes.map((node) => node.id);
+	const indexOf = new Map(nodeIds.map((id, i) => [id, i]));
+	let count = nodeIds.length;
+	let links = Array.from({ length: count }, () => /* @__PURE__ */ new Map());
+	let selfLoops = new Array(count).fill(0);
+	for (const edge of graph.edges) {
+		const u = indexOf.get(edge.sourceId);
+		const v = indexOf.get(edge.targetId);
+		if (u === void 0 || v === void 0) continue;
+		const w = getWeight(edge);
+		if (u === v) selfLoops[u] += w;
+		else {
+			links[u].set(v, (links[u].get(v) ?? 0) + w);
+			links[v].set(u, (links[v].get(u) ?? 0) + w);
+		}
+	}
+	let membership = nodeIds.map((_, i) => i);
+	for (let pass = 0; pass < maxPasses; pass++) {
+		const degree = links.map((neighbors, i) => 2 * selfLoops[i] + [...neighbors.values()].reduce((sum, w) => sum + w, 0));
+		const m2 = degree.reduce((sum, k) => sum + k, 0);
+		if (m2 === 0) break;
+		const communityOf = Array.from({ length: count }, (_, i) => i);
+		const communityTotal = [...degree];
+		let movedAny = false;
+		let movedThisSweep = true;
+		while (movedThisSweep) {
+			movedThisSweep = false;
+			for (let i = 0; i < count; i++) {
+				const current = communityOf[i];
+				const weightTo = /* @__PURE__ */ new Map();
+				for (const [j, w] of links[i]) {
+					const c = communityOf[j];
+					weightTo.set(c, (weightTo.get(c) ?? 0) + w);
+				}
+				communityTotal[current] -= degree[i];
+				const gainOf = (c) => (weightTo.get(c) ?? 0) - resolution * communityTotal[c] * degree[i] / m2;
+				let best = current;
+				let bestGain = gainOf(current);
+				for (const c of weightTo.keys()) {
+					if (c === current) continue;
+					const gain = gainOf(c);
+					if (gain > bestGain + 1e-12) {
+						best = c;
+						bestGain = gain;
+					}
+				}
+				communityTotal[best] += degree[i];
+				if (best !== current) {
+					communityOf[i] = best;
+					movedThisSweep = true;
+					movedAny = true;
+				}
+			}
+		}
+		if (!movedAny) break;
+		const renumber = /* @__PURE__ */ new Map();
+		for (let i = 0; i < count; i++) {
+			const c = communityOf[i];
+			if (!renumber.has(c)) renumber.set(c, renumber.size);
+		}
+		const nextCount = renumber.size;
+		const nextLinks = Array.from({ length: nextCount }, () => /* @__PURE__ */ new Map());
+		const nextSelfLoops = new Array(nextCount).fill(0);
+		for (let i = 0; i < count; i++) {
+			const ci = renumber.get(communityOf[i]);
+			nextSelfLoops[ci] += selfLoops[i];
+			for (const [j, w] of links[i]) {
+				const cj = renumber.get(communityOf[j]);
+				if (ci === cj) nextSelfLoops[ci] += w / 2;
+				else nextLinks[ci].set(cj, (nextLinks[ci].get(cj) ?? 0) + w);
+			}
+		}
+		membership = membership.map((c) => renumber.get(communityOf[c]));
+		links = nextLinks;
+		selfLoops = nextSelfLoops;
+		count = nextCount;
+		if (nextCount === 1) break;
+	}
+	const grouped = /* @__PURE__ */ new Map();
+	for (let i = 0; i < nodeIds.length; i++) {
+		const c = membership[i];
+		if (!grouped.has(c)) grouped.set(c, []);
+		grouped.get(c).push(nodeIds[i]);
+	}
+	return [...grouped.values()].map((ids) => ids.sort((a, b) => a.localeCompare(b))).sort((a, b) => a[0].localeCompare(b[0]));
+}
+
+//#endregion
+//#region src/algorithms/flow.ts
+/**
+* Shared Edmonds-Karp solver behind {@link getMaxFlow} and {@link getMinCut}.
+* `caller`/`fromOption`/`toOption` only shape the error messages.
+*/
+function solveMaxFlow(graph, caller, fromOption, toOption, from, to, getCapacity) {
+	const idx = getIndex(graph);
+	if (!idx.nodeById.has(from)) throw new Error(`${caller}: source node "${from}" not found in graph — pass an existing node id as ${fromOption}`);
+	if (!idx.nodeById.has(to)) throw new Error(`${caller}: sink node "${to}" not found in graph — pass an existing node id as ${toOption}`);
+	if (from === to) throw new Error(`${caller}: source and sink are both "${from}" — they must be different nodes`);
+	const arcs = [];
+	const outArcs = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) outArcs.set(node.id, []);
+	function addArc(u, v, capacity, edgeId, sign) {
+		outArcs.get(u).push(arcs.length);
+		arcs.push({
+			to: v,
+			capacity,
+			flow: 0,
+			edgeId,
+			sign
+		});
+		outArcs.get(v).push(arcs.length);
+		arcs.push({
+			to: u,
+			capacity: 0,
+			flow: 0
+		});
+	}
+	for (const edge of graph.edges) {
+		const capacity = getCapacity(edge);
+		if (capacity < 0) throw new Error(`${caller}: edge "${edge.id}" has negative capacity ${capacity} — capacities must be >= 0; fix edge.weight or provide a non-negative getCapacity`);
+		if (edge.sourceId === edge.targetId) continue;
+		addArc(edge.sourceId, edge.targetId, capacity, edge.id, 1);
+		if (getEdgeMode(graph, edge) !== "directed") addArc(edge.targetId, edge.sourceId, capacity, edge.id, -1);
+	}
+	function residual(arcIndex) {
+		return arcs[arcIndex].capacity - arcs[arcIndex].flow;
+	}
+	let value = 0;
+	while (true) {
+		const parentArc = /* @__PURE__ */ new Map();
+		const queue$1 = [from];
+		const visited = new Set([from]);
+		while (queue$1.length > 0 && !visited.has(to)) {
+			const u = queue$1.shift();
+			for (const ai of outArcs.get(u) ?? []) {
+				const arc = arcs[ai];
+				if (residual(ai) > 0 && !visited.has(arc.to)) {
+					visited.add(arc.to);
+					parentArc.set(arc.to, ai);
+					queue$1.push(arc.to);
+				}
+			}
+		}
+		if (!visited.has(to)) break;
+		let bottleneck = Infinity;
+		for (let v = to; v !== from;) {
+			const ai = parentArc.get(v);
+			bottleneck = Math.min(bottleneck, residual(ai));
+			v = arcs[ai ^ 1].to;
+		}
+		if (bottleneck === Infinity || bottleneck <= 0) break;
+		for (let v = to; v !== from;) {
+			const ai = parentArc.get(v);
+			arcs[ai].flow += bottleneck;
+			arcs[ai ^ 1].flow -= bottleneck;
+			v = arcs[ai ^ 1].to;
+		}
+		value += bottleneck;
+	}
+	const flows = Object.fromEntries(graph.edges.map((edge) => [edge.id, 0]));
+	for (const arc of arcs) if (arc.edgeId !== void 0 && arc.flow > 0) flows[arc.edgeId] += arc.sign * arc.flow;
+	const sourceSide = new Set([from]);
+	const queue = [from];
+	while (queue.length > 0) {
+		const u = queue.shift();
+		for (const ai of outArcs.get(u) ?? []) {
+			const arc = arcs[ai];
+			if (residual(ai) > 0 && !sourceSide.has(arc.to)) {
+				sourceSide.add(arc.to);
+				queue.push(arc.to);
+			}
+		}
+	}
+	const cutEdgeIds = /* @__PURE__ */ new Set();
+	for (let ai = 0; ai < arcs.length; ai++) {
+		const arc = arcs[ai];
+		if (arc.edgeId === void 0) continue;
+		const arcFrom = arcs[ai ^ 1].to;
+		if (sourceSide.has(arcFrom) && !sourceSide.has(arc.to)) cutEdgeIds.add(arc.edgeId);
+	}
+	const cutEdges = graph.edges.filter((edge) => cutEdgeIds.has(edge.id));
+	return {
+		value,
+		flows,
+		cutEdges,
+		sourceSide
+	};
+}
+/**
+* Returns the maximum flow from `from` to `to` using the Edmonds-Karp
+* algorithm (BFS augmenting paths).
+*
+* Directed edges carry capacity from source to target only. Edges whose
+* effective mode is not `'directed'` (undirected/bidirectional) are modeled
+* as two independent opposite arcs, each with the edge's full capacity.
+*
+* The returned `flows` record maps every edge id to its net flow (positive
+* in the source→target direction). `cutEdges` is a minimum s-t cut: the
+* edges crossing from the source side to the sink side of the final
+* residual graph; the sum of their capacities equals `value`.
+*
+* @example
+* ```ts
+* const { value, cutEdges } = getMaxFlow(graph, { from: 's', to: 't' });
+* ```
+*/
+function getMaxFlow(graph, options) {
+	const getCapacity = options.getCapacity ?? ((edge) => edge.weight ?? 1);
+	const { value, flows, cutEdges } = solveMaxFlow(graph, "getMaxFlow", "options.from", "options.to", options.from, options.to, getCapacity);
+	return {
+		value,
+		flows,
+		cutEdges
+	};
+}
+/**
+* Returns a minimum s-t cut between `source` and `sink` via the max-flow
+* min-cut theorem: runs the same Edmonds-Karp solver as {@link getMaxFlow},
+* then splits the nodes by residual reachability from the source.
+*
+* `partition.source` holds every node reachable from `source` in the final
+* residual graph; `partition.sink` holds the rest (both in `graph.nodes`
+* order). `cutEdges` are the ids of the edges crossing the cut, and their
+* total capacity equals `value` (the max-flow value).
+*
+* @example
+* ```ts
+* const { value, cutEdges, partition } = getMinCut(graph, {
+*   source: 's',
+*   sink: 't',
+* });
+* ```
+*/
+function getMinCut(graph, options) {
+	const getCapacity = options.getCapacity ?? ((edge) => edge.weight ?? 1);
+	const { value, cutEdges, sourceSide } = solveMaxFlow(graph, "getMinCut", "options.source", "options.sink", options.source, options.sink, getCapacity);
+	const sourcePartition = [];
+	const sinkPartition = [];
+	for (const node of graph.nodes) (sourceSide.has(node.id) ? sourcePartition : sinkPartition).push(node.id);
+	return {
+		value,
+		cutEdges: cutEdges.map((edge) => edge.id),
+		partition: {
+			source: sourcePartition,
+			sink: sinkPartition
+		}
+	};
+}
+
+//#endregion
+//#region src/algorithms/dominators.ts
+/**
+* Returns the dominator tree of the graph rooted at `from`, computed with
+* the Cooper–Harvey–Kennedy iterative algorithm.
+*
+* Each reachable node maps to its immediate dominator's id; the root maps
+* to `null`. Unreachable nodes are omitted. Traversal is mode-aware:
+* undirected/bidirectional edges are traversable both ways.
+*
+* For statecharts this answers "which states must every path from the
+* initial state pass through to reach this state?" — node `d` dominates
+* node `n` when every path from the initial state to `n` goes through `d`.
+*
+* @example
+* ```ts
+* // a→b, a→c, b→d, c→d (diamond)
+* getDominatorTree(graph, { from: 'a' });
+* // { a: null, b: 'a', c: 'a', d: 'a' }
+* ```
+*/
+function getDominatorTree(graph, options) {
+	const root = resolveFrom(graph, options);
+	if (!getIndex(graph).nodeById.has(root)) throw new Error(`getDominatorTree: root node "${root}" not found in graph — pass an existing node id as options.from`);
+	const postorder = [];
+	const visited = new Set([root]);
+	const stack = [{
+		id: root,
+		neighborIndex: 0
+	}];
+	const successors = /* @__PURE__ */ new Map();
+	function getSuccessors(id) {
+		let succ = successors.get(id);
+		if (!succ) {
+			succ = getNeighborEdges(graph, id).map((entry) => entry.neighborId);
+			successors.set(id, succ);
+		}
+		return succ;
+	}
+	while (stack.length > 0) {
+		const frame = stack[stack.length - 1];
+		const succ = getSuccessors(frame.id);
+		if (frame.neighborIndex < succ.length) {
+			const next = succ[frame.neighborIndex++];
+			if (!visited.has(next)) {
+				visited.add(next);
+				stack.push({
+					id: next,
+					neighborIndex: 0
+				});
+			}
+		} else {
+			postorder.push(frame.id);
+			stack.pop();
+		}
+	}
+	const rpo = [...postorder].reverse();
+	const rpoNumber = new Map(rpo.map((id, i) => [id, i]));
+	const predecessors = new Map(rpo.map((id) => [id, []]));
+	for (const id of rpo) for (const succ of getSuccessors(id)) if (visited.has(succ)) predecessors.get(succ).push(id);
+	const idom = /* @__PURE__ */ new Map();
+	idom.set(root, root);
+	function intersect(a, b) {
+		let f1 = a;
+		let f2 = b;
+		while (f1 !== f2) {
+			while (rpoNumber.get(f1) > rpoNumber.get(f2)) f1 = idom.get(f1);
+			while (rpoNumber.get(f2) > rpoNumber.get(f1)) f2 = idom.get(f2);
+		}
+		return f1;
+	}
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const id of rpo) {
+			if (id === root) continue;
+			let newIdom;
+			for (const pred of predecessors.get(id)) {
+				if (!idom.has(pred)) continue;
+				newIdom = newIdom === void 0 ? pred : intersect(pred, newIdom);
+			}
+			if (newIdom !== void 0 && idom.get(id) !== newIdom) {
+				idom.set(id, newIdom);
+				changed = true;
+			}
+		}
+	}
+	const result = {};
+	for (const id of rpo) result[id] = id === root ? null : idom.get(id);
+	return result;
+}
+
+//#endregion
+//#region src/algorithms/reduction.ts
+/**
+* Returns a new graph with all transitively-redundant edges removed (the
+* transitive reduction). The input graph is not mutated; nodes and surviving
+* edges keep all of their fields.
+*
+* An edge u→v is removed when v is also reachable from u via a path of
+* length ≥ 2. Exact-duplicate parallel edges u→v collapse to the first one
+* in `graph.edges` order (a duplicate adds no reachability, so at most one
+* edge per (u, v) pair survives).
+*
+* DAG-only: throws when the graph contains a cycle or any edge whose
+* effective mode is not `'directed'`.
+*
+* @example
+* ```ts
+* // a→b, b→c, a→c
+* const reduced = getTransitiveReduction(graph);
+* // a→c removed; edges: a→b, b→c
+* ```
+*/
+function getTransitiveReduction(graph) {
+	for (const edge of graph.edges) {
+		const mode = getEdgeMode(graph, edge);
+		if (mode !== "directed") throw new Error(`getTransitiveReduction: edge "${edge.id}" has effective mode "${mode}" — transitive reduction is only defined for directed acyclic graphs. Set edge.mode (or graph.mode) to 'directed'.`);
+	}
+	if (getEffectiveModeKind(graph) === "directed" && !isAcyclic(graph)) throw new Error("getTransitiveReduction: the graph contains a cycle — transitive reduction is only defined for directed acyclic graphs. Remove the cycle (see getCycles) first.");
+	const successorsOf = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) successorsOf.set(node.id, /* @__PURE__ */ new Set());
+	for (const edge of graph.edges) successorsOf.get(edge.sourceId)?.add(edge.targetId);
+	const reach = /* @__PURE__ */ new Map();
+	function getReach(id) {
+		let set = reach.get(id);
+		if (set) return set;
+		set = new Set([id]);
+		reach.set(id, set);
+		for (const succ of successorsOf.get(id) ?? []) for (const reached of getReach(succ)) set.add(reached);
+		return set;
+	}
+	function isRedundant(u, v) {
+		for (const w of successorsOf.get(u)) if (w !== v && getReach(w).has(v)) return true;
+		return false;
+	}
+	const keptPairs = /* @__PURE__ */ new Set();
+	const keptEdges = [];
+	for (const edge of graph.edges) {
+		const pair = `${edge.sourceId}${edge.targetId}`;
+		if (keptPairs.has(pair)) continue;
+		if (isRedundant(edge.sourceId, edge.targetId)) continue;
+		keptPairs.add(pair);
+		keptEdges.push(edge);
+	}
+	return createGraph({
+		id: graph.id,
+		mode: graph.mode,
+		initialNodeId: graph.initialNodeId ?? void 0,
+		data: graph.data ?? void 0,
+		direction: graph.direction,
+		style: graph.style,
+		nodes: graph.nodes.map((node) => {
+			const { type, parentId, initialNodeId, ...rest } = node;
+			return {
+				...rest,
+				parentId: parentId ?? void 0,
+				initialNodeId: initialNodeId ?? void 0
+			};
+		}),
+		edges: keptEdges.map((edge) => {
+			const { type, ...rest } = edge;
+			return rest;
+		})
+	});
+}
+
+//#endregion
+export { getAStarPath as $, genPreorders as A, getTopologicalSort as B, getHITS as C, getPageRank as D, getOutDegreeCentrality as E, bfs as F, flatten as G, isAcyclic as H, dfs as I, getSubgraph as J, getFlattenedGraph as K, genBFS as L, getPostorders as M, getPreorder as N, getMinimumSpanningTree as O, getPreorders as P, genSimplePaths as Q, genDFS as R, getEigenvectorCentrality as S, getKatzCentrality as T, isConnected as U, hasPath as V, isTree as W, genCycles as X, reverseGraph as Y, genShortestPaths as Z, getCoreNumbers as _, getLouvainCommunities as a, getSimplePath as at, getClosenessCentrality as b, getBiconnectedComponents as c, joinPaths as ct, getGirvanNewmanCommunities as d, getAllPairsShortestPaths as et, getGreedyModularityCommunities as f, isBipartite as g, getMaximumBipartiteMatching as h, getMinCut as i, getShortestPaths as it, getPostorder as j, genPostorders as k, getBridges as l, mulberry32 as lt, getModularity as m, getDominatorTree as n, getJoinedPath as nt, isIsomorphic as o, getSimplePaths as ot, getLabelPropagationCommunities as p, getReversedGraph as q, getMaxFlow as r, getShortestPath as rt, getArticulationPoints as s, getStronglyConnectedComponents as st, getTransitiveReduction as t, getCycles as tt, genGirvanNewmanCommunities as u, getKCore as v, getInDegreeCentrality as w, getDegreeCentrality as x, getBetweennessCentrality as y, getConnectedComponents as z };