graphwise 1.1.1 → 1.3.0

package/dist/index/index.cjs

@@ -1,11 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_graph = require("../graph-az06J1YV.cjs");
-const require_traversal = require("../traversal-QeHaNUWn.cjs");
-const require_structures = require("../structures-CJ_S_7fs.cjs");
-const require_kmeans = require("../kmeans-B0HEOU6k.cjs");
-const require_seeds = require("../seeds-B6J9oJfU.cjs");
-const require_utils = require("../utils-spZa1ZvS.cjs");
-const require_gpu = require("../gpu-BJRVYBjx.cjs");
+const require_graph = require("../graph/index.cjs");
+const require_traversal = require("../traversal/index.cjs");
+const require_structures = require("../structures/index.cjs");
+const require_kmeans = require("../kmeans-BIgSyGKu.cjs");
+const require_utils = require("../utils/index.cjs");
+const require_seeds = require("../seeds/index.cjs");
+const require_gpu = require("../gpu/index.cjs");
 //#region src/expansion/base.ts
 /**
 * Default priority function - degree-ordered (DOME).
@@ -243,6 +243,18 @@ function dome(graph, seeds, config) {
 		priority: domePriority
 	});
 }
+/**
+* DOME with reverse priority (high degree first).
+*/
+function domeHighDegree(graph, seeds, config) {
+	const domePriority = (nodeId, context) => {
+		return -graph.degree(nodeId);
+	};
+	return base(graph, seeds, {
+		...config,
+		priority: domePriority
+	});
+}
 //#endregion
 //#region src/expansion/edge.ts
 /**
@@ -287,15 +299,9 @@ function edge(graph, seeds, config) {
 */
 function jaccard(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
-	let intersectionSize = 0;
-	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) intersectionSize++;
-	const unionSize = sourceNeighbours.size + targetNeighbours.size - intersectionSize;
-	if (unionSize === 0) return 0;
-	const score = intersectionSize / unionSize;
+	const { intersection, union } = require_utils.neighbourOverlap(require_utils.neighbourSet(graph, source, target), require_utils.neighbourSet(graph, target, source));
+	if (union === 0) return 0;
+	const score = intersection / union;
 	return Math.max(epsilon, score);
 }
 //#endregion
@@ -521,6 +527,80 @@ function maze(graph, seeds, config) {
 	});
 }
 //#endregion
+//#region src/expansion/standard-bfs.ts
+/**
+* Run standard BFS expansion (FIFO discovery order).
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration
+* @returns Expansion result with discovered paths
+*/
+function standardBfs(graph, seeds, config) {
+	const bfsPriority = (_nodeId, context) => {
+		return context.iteration;
+	};
+	return base(graph, seeds, {
+		...config,
+		priority: bfsPriority
+	});
+}
+//#endregion
+//#region src/expansion/frontier-balanced.ts
+/**
+* Run frontier-balanced expansion (round-robin across frontiers).
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration
+* @returns Expansion result with discovered paths
+*/
+function frontierBalanced(graph, seeds, config) {
+	const balancedPriority = (_nodeId, context) => {
+		return context.frontierIndex * 1e9 + context.iteration;
+	};
+	return base(graph, seeds, {
+		...config,
+		priority: balancedPriority
+	});
+}
+//#endregion
+//#region src/expansion/random-priority.ts
+/**
+* Deterministic seeded random number generator.
+* Uses FNV-1a-like hash for input → [0, 1] output.
+*
+* @param input - String to hash
+* @param seed - Random seed for reproducibility
+* @returns Deterministic random value in [0, 1]
+*/
+function seededRandom$1(input, seed = 0) {
+	let h = seed;
+	for (let i = 0; i < input.length; i++) {
+		h = Math.imul(h ^ input.charCodeAt(i), 2654435769);
+		h ^= h >>> 16;
+	}
+	return (h >>> 0) / 4294967295;
+}
+/**
+* Run random-priority expansion (null hypothesis baseline).
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration
+* @returns Expansion result with discovered paths
+*/
+function randomPriority(graph, seeds, config) {
+	const { seed = 0 } = config ?? {};
+	const randomPriorityFn = (nodeId, context) => {
+		return seededRandom$1(nodeId, seed);
+	};
+	return base(graph, seeds, {
+		...config,
+		priority: randomPriorityFn
+	});
+}
+//#endregion
 //#region src/ranking/parse.ts
 /**
 * Rank paths using PARSE (Path-Aware Ranking via Salience Estimation).
@@ -601,19 +681,14 @@ function computePathSalience(graph, path, mi, epsilon) {
 */
 function adamicAdar(graph, source, target, config) {
 	const { epsilon = 1e-10, normalise = true } = config ?? {};
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
+	const commonNeighbours = require_utils.neighbourIntersection(require_utils.neighbourSet(graph, source, target), require_utils.neighbourSet(graph, target, source));
 	let score = 0;
-	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) {
+	for (const neighbour of commonNeighbours) {
 		const degree = graph.degree(neighbour);
-		if (degree > 1) score += 1 / Math.log(degree);
+		score += 1 / Math.log(degree + 1);
 	}
-	if (normalise) {
-		const commonCount = sourceNeighbours.size < targetNeighbours.size ? sourceNeighbours.size : targetNeighbours.size;
-		if (commonCount === 0) return 0;
-		const maxScore = commonCount / Math.log(2);
+	if (normalise && commonNeighbours.size > 0) {
+		const maxScore = commonNeighbours.size / Math.log(2);
 		score = score / maxScore;
 	}
 	return Math.max(epsilon, score);
@@ -625,22 +700,15 @@ function adamicAdar(graph, source, target, config) {
 */
 function scale(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
-	const sourceDegree = sourceNeighbours.size;
-	const targetDegree = targetNeighbours.size;
-	let intersectionSize = 0;
-	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) intersectionSize++;
-	const unionSize = sourceDegree + targetDegree - intersectionSize;
-	const jaccard = unionSize > 0 ? intersectionSize / unionSize : 0;
-	const minDegree = Math.min(sourceDegree, targetDegree);
-	const maxDegree = Math.max(sourceDegree, targetDegree);
-	const degreeRatio = maxDegree > 0 ? minDegree / maxDegree : 0;
-	if (jaccard + degreeRatio === 0) return epsilon;
-	const score = 2 * jaccard * degreeRatio / (jaccard + degreeRatio);
-	return Math.max(epsilon, Math.min(1, score));
+	const { intersection, union } = require_utils.neighbourOverlap(require_utils.neighbourSet(graph, source, target), require_utils.neighbourSet(graph, target, source));
+	const jaccard = union > 0 ? intersection / union : 0;
+	const n = graph.nodeCount;
+	const m = graph.edgeCount;
+	const densityNormaliser = graph.directed ? n * (n - 1) : 2 * n * (n - 1);
+	const density = densityNormaliser > 0 ? m / densityNormaliser : 0;
+	if (density === 0) return epsilon;
+	const score = jaccard / density;
+	return Math.max(epsilon, score);
 }
 //#endregion
 //#region src/ranking/mi/skew.ts
@@ -649,23 +717,15 @@ function scale(graph, source, target, config) {
 */
 function skew(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
-	let weightedIntersection = 0;
-	let commonCount = 0;
-	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) {
-		commonCount++;
-		const degree = graph.degree(neighbour);
-		if (degree > 1) weightedIntersection += 1 / Math.log(degree);
-	}
-	if (commonCount === 0) return epsilon;
-	const sourceDegree = sourceNeighbours.size;
-	const targetDegree = targetNeighbours.size;
-	const maxScore = Math.min(sourceDegree, targetDegree) / Math.log(2);
-	const score = weightedIntersection / maxScore;
-	return Math.max(epsilon, Math.min(1, score));
+	const { intersection, union } = require_utils.neighbourOverlap(require_utils.neighbourSet(graph, source, target), require_utils.neighbourSet(graph, target, source));
+	const jaccard = union > 0 ? intersection / union : 0;
+	const N = graph.nodeCount;
+	const sourceDegree = graph.degree(source);
+	const targetDegree = graph.degree(target);
+	const sourceIdf = Math.log(N / (sourceDegree + 1));
+	const targetIdf = Math.log(N / (targetDegree + 1));
+	const score = jaccard * sourceIdf * targetIdf;
+	return Math.max(epsilon, score);
 }
 //#endregion
 //#region src/ranking/mi/span.ts
@@ -674,21 +734,12 @@ function skew(graph, source, target, config) {
 */
 function span(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
-	const sourceDegree = sourceNeighbours.size;
-	const targetDegree = targetNeighbours.size;
-	let intersectionSize = 0;
-	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) intersectionSize++;
-	const unionSize = sourceDegree + targetDegree - intersectionSize;
-	const jaccard = unionSize > 0 ? intersectionSize / unionSize : 0;
-	const maxDegree = Math.max(sourceDegree, targetDegree);
-	const degreeDiff = Math.abs(sourceDegree - targetDegree);
-	const degreeSimilarity = maxDegree > 0 ? 1 - degreeDiff / maxDegree : 1;
-	const score = Math.sqrt(jaccard * degreeSimilarity);
-	return Math.max(epsilon, Math.min(1, score));
+	const { intersection, union } = require_utils.neighbourOverlap(require_utils.neighbourSet(graph, source, target), require_utils.neighbourSet(graph, target, source));
+	const jaccard = union > 0 ? intersection / union : 0;
+	const sourceCc = require_utils.localClusteringCoefficient(graph, source);
+	const targetCc = require_utils.localClusteringCoefficient(graph, target);
+	const score = jaccard * (1 - Math.max(sourceCc, targetCc));
+	return Math.max(epsilon, score);
 }
 //#endregion
 //#region src/ranking/mi/etch.ts
@@ -697,30 +748,14 @@ function span(graph, source, target, config) {
 */
 function etch(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
-	const commonNeighbours = [];
-	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) commonNeighbours.push(neighbour);
-	if (commonNeighbours.length < 2) return epsilon;
-	let jointEdges = 0;
-	for (let i = 0; i < commonNeighbours.length; i++) for (let j = i + 1; j < commonNeighbours.length; j++) {
-		const ni = commonNeighbours[i];
-		const nj = commonNeighbours[j];
-		if (ni !== void 0 && nj !== void 0 && graph.getEdge(ni, nj) !== void 0) jointEdges++;
-	}
-	const maxJointEdges = commonNeighbours.length * (commonNeighbours.length - 1) / 2;
-	const jointDensity = maxJointEdges > 0 ? jointEdges / maxJointEdges : 0;
-	let commonEdges = 0;
-	for (const cn of commonNeighbours) {
-		if (graph.getEdge(source, cn) !== void 0) commonEdges++;
-		if (graph.getEdge(target, cn) !== void 0) commonEdges++;
-	}
-	const maxCommonEdges = commonNeighbours.length * 2;
-	const commonDensity = maxCommonEdges > 0 ? commonEdges / maxCommonEdges : 0;
-	const score = jointDensity * .7 + commonDensity * .3;
-	return Math.max(epsilon, Math.min(1, score));
+	const { intersection, union } = require_utils.neighbourOverlap(require_utils.neighbourSet(graph, source, target), require_utils.neighbourSet(graph, target, source));
+	const jaccard = union > 0 ? intersection / union : 0;
+	const edge = graph.getEdge(source, target);
+	if (edge?.type === void 0) return Math.max(epsilon, jaccard);
+	const edgeTypeCount = require_utils.countEdgesOfType(graph, edge.type);
+	if (edgeTypeCount === 0) return Math.max(epsilon, jaccard);
+	const score = jaccard * Math.log(graph.edgeCount / edgeTypeCount);
+	return Math.max(epsilon, score);
 }
 //#endregion
 //#region src/ranking/mi/notch.ts
@@ -729,20 +764,18 @@ function etch(graph, source, target, config) {
 */
 function notch(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
-	const sourceDegree = sourceNeighbours.size;
-	const targetDegree = targetNeighbours.size;
-	let intersectionSize = 0;
-	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) intersectionSize++;
-	const minDegree = Math.min(sourceDegree, targetDegree);
-	const overlap = minDegree > 0 ? intersectionSize / minDegree : 0;
-	const maxDegree = Math.max(sourceDegree, targetDegree);
-	const correlation = maxDegree > 0 ? 1 - Math.abs(sourceDegree - targetDegree) / maxDegree : 1;
-	const score = overlap * .6 + correlation * .4;
-	return Math.max(epsilon, Math.min(1, score));
+	const { intersection, union } = require_utils.neighbourOverlap(require_utils.neighbourSet(graph, source, target), require_utils.neighbourSet(graph, target, source));
+	const jaccard = union > 0 ? intersection / union : 0;
+	const sourceNode = graph.getNode(source);
+	const targetNode = graph.getNode(target);
+	if (sourceNode?.type === void 0 || targetNode?.type === void 0) return Math.max(epsilon, jaccard);
+	const sourceTypeCount = require_utils.countNodesOfType(graph, sourceNode.type);
+	const targetTypeCount = require_utils.countNodesOfType(graph, targetNode.type);
+	if (sourceTypeCount === 0 || targetTypeCount === 0) return Math.max(epsilon, jaccard);
+	const sourceRarity = Math.log(graph.nodeCount / sourceTypeCount);
+	const targetRarity = Math.log(graph.nodeCount / targetTypeCount);
+	const score = jaccard * sourceRarity * targetRarity;
+	return Math.max(epsilon, score);
 }
 //#endregion
 //#region src/ranking/mi/adaptive.ts
@@ -750,7 +783,7 @@ function notch(graph, source, target, config) {
 * Compute unified adaptive MI between two connected nodes.
 *
 * Combines structural, degree, and overlap signals with
-* adaptive weighting based on graph density.
+* configurable weighting.
 *
 * @param graph - Source graph
 * @param source - Source node ID
@@ -765,17 +798,13 @@ function adaptive(graph, source, target, config) {
 		epsilon,
 		normalise: true
 	});
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
-	const sourceDegree = sourceNeighbours.size;
-	const targetDegree = targetNeighbours.size;
+	const sourceNeighbours = require_utils.neighbourSet(graph, source, target);
+	const targetNeighbours = require_utils.neighbourSet(graph, target, source);
 	let overlap;
-	if (sourceDegree > 0 && targetDegree > 0) {
-		let commonCount = 0;
-		for (const n of sourceNeighbours) if (targetNeighbours.has(n)) commonCount++;
-		overlap = commonCount / Math.min(sourceDegree, targetDegree);
+	if (sourceNeighbours.size > 0 && targetNeighbours.size > 0) {
+		const { intersection } = require_utils.neighbourOverlap(sourceNeighbours, targetNeighbours);
+		const minDegree = Math.min(sourceNeighbours.size, targetNeighbours.size);
+		overlap = minDegree > 0 ? intersection / minDegree : epsilon;
 	} else overlap = epsilon;
 	const totalWeight = structuralWeight + degreeWeight + overlapWeight;
 	const score = (structuralWeight * structural + degreeWeight * degreeComponent + overlapWeight * overlap) / totalWeight;
@@ -813,6 +842,712 @@ function shortest(_graph, paths, config) {
 	};
 }
 //#endregion
+//#region src/ranking/baselines/degree-sum.ts
+/**
+* Rank paths by sum of node degrees.
+*
+* @param graph - Source graph
+* @param paths - Paths to rank
+* @param config - Configuration options
+* @returns Ranked paths (highest degree-sum first)
+*/
+function degreeSum(graph, paths, config) {
+	const { includeScores = true } = config ?? {};
+	if (paths.length === 0) return {
+		paths: [],
+		method: "degree-sum"
+	};
+	const scored = paths.map((path) => {
+		let degreeSum = 0;
+		for (const nodeId of path.nodes) degreeSum += graph.degree(nodeId);
+		return {
+			path,
+			score: degreeSum
+		};
+	});
+	const maxScore = Math.max(...scored.map((s) => s.score));
+	if (maxScore === 0) return {
+		paths: paths.map((path) => ({
+			...path,
+			score: 0
+		})),
+		method: "degree-sum"
+	};
+	return {
+		paths: scored.map(({ path, score }) => ({
+			...path,
+			score: includeScores ? score / maxScore : score / maxScore
+		})).sort((a, b) => b.score - a.score),
+		method: "degree-sum"
+	};
+}
+//#endregion
+//#region src/ranking/baselines/widest-path.ts
+/**
+* Rank paths by widest bottleneck (minimum edge similarity).
+*
+* @param graph - Source graph
+* @param paths - Paths to rank
+* @param config - Configuration options
+* @returns Ranked paths (highest bottleneck first)
+*/
+function widestPath(graph, paths, config) {
+	const { includeScores = true } = config ?? {};
+	if (paths.length === 0) return {
+		paths: [],
+		method: "widest-path"
+	};
+	const scored = paths.map((path) => {
+		if (path.nodes.length < 2) return {
+			path,
+			score: 1
+		};
+		let minSimilarity = Number.POSITIVE_INFINITY;
+		for (let i = 0; i < path.nodes.length - 1; i++) {
+			const source = path.nodes[i];
+			const target = path.nodes[i + 1];
+			if (source === void 0 || target === void 0) continue;
+			const edgeSimilarity = jaccard(graph, source, target);
+			minSimilarity = Math.min(minSimilarity, edgeSimilarity);
+		}
+		return {
+			path,
+			score: minSimilarity === Number.POSITIVE_INFINITY ? 1 : minSimilarity
+		};
+	});
+	const maxScore = Math.max(...scored.map((s) => s.score));
+	if (maxScore === 0) return {
+		paths: paths.map((path) => ({
+			...path,
+			score: 0
+		})),
+		method: "widest-path"
+	};
+	return {
+		paths: scored.map(({ path, score }) => ({
+			...path,
+			score: includeScores ? score / maxScore : score / maxScore
+		})).sort((a, b) => b.score - a.score),
+		method: "widest-path"
+	};
+}
+//#endregion
+//#region src/ranking/baselines/jaccard-arithmetic.ts
+/**
+* Rank paths by arithmetic mean of edge Jaccard similarities.
+*
+* @param graph - Source graph
+* @param paths - Paths to rank
+* @param config - Configuration options
+* @returns Ranked paths (highest arithmetic mean first)
+*/
+function jaccardArithmetic(graph, paths, config) {
+	const { includeScores = true } = config ?? {};
+	if (paths.length === 0) return {
+		paths: [],
+		method: "jaccard-arithmetic"
+	};
+	const scored = paths.map((path) => {
+		if (path.nodes.length < 2) return {
+			path,
+			score: 1
+		};
+		let similaritySum = 0;
+		let edgeCount = 0;
+		for (let i = 0; i < path.nodes.length - 1; i++) {
+			const source = path.nodes[i];
+			const target = path.nodes[i + 1];
+			if (source === void 0 || target === void 0) continue;
+			const edgeSimilarity = jaccard(graph, source, target);
+			similaritySum += edgeSimilarity;
+			edgeCount++;
+		}
+		return {
+			path,
+			score: edgeCount > 0 ? similaritySum / edgeCount : 1
+		};
+	});
+	const maxScore = Math.max(...scored.map((s) => s.score));
+	if (maxScore === 0) return {
+		paths: paths.map((path) => ({
+			...path,
+			score: 0
+		})),
+		method: "jaccard-arithmetic"
+	};
+	return {
+		paths: scored.map(({ path, score }) => ({
+			...path,
+			score: includeScores ? score / maxScore : score / maxScore
+		})).sort((a, b) => b.score - a.score),
+		method: "jaccard-arithmetic"
+	};
+}
+//#endregion
+//#region src/ranking/baselines/pagerank.ts
+/**
+* Compute PageRank centrality for all nodes using power iteration.
+*
+* @param graph - Source graph
+* @param damping - Damping factor (default 0.85)
+* @param tolerance - Convergence tolerance (default 1e-6)
+* @param maxIterations - Maximum iterations (default 100)
+* @returns Map of node ID to PageRank value
+*/
+function computePageRank(graph, damping = .85, tolerance = 1e-6, maxIterations = 100) {
+	const nodes = Array.from(graph.nodeIds());
+	const n = nodes.length;
+	if (n === 0) return /* @__PURE__ */ new Map();
+	const ranks = /* @__PURE__ */ new Map();
+	const newRanks = /* @__PURE__ */ new Map();
+	for (const nodeId of nodes) {
+		ranks.set(nodeId, 1 / n);
+		newRanks.set(nodeId, 0);
+	}
+	let isCurrentRanks = true;
+	for (let iteration = 0; iteration < maxIterations; iteration++) {
+		let maxChange = 0;
+		const currMap = isCurrentRanks ? ranks : newRanks;
+		const nextMap = isCurrentRanks ? newRanks : ranks;
+		for (const nodeId of nodes) {
+			let incomingSum = 0;
+			for (const incomingId of graph.neighbours(nodeId, "in")) {
+				const incomingRank = currMap.get(incomingId) ?? 0;
+				const outDegree = graph.degree(incomingId);
+				if (outDegree > 0) incomingSum += incomingRank / outDegree;
+			}
+			const newRank = (1 - damping) / n + damping * incomingSum;
+			nextMap.set(nodeId, newRank);
+			const oldRank = currMap.get(nodeId) ?? 0;
+			maxChange = Math.max(maxChange, Math.abs(newRank - oldRank));
+		}
+		if (maxChange < tolerance) break;
+		isCurrentRanks = !isCurrentRanks;
+		currMap.clear();
+	}
+	return isCurrentRanks ? ranks : newRanks;
+}
+/**
+* Rank paths by sum of PageRank scores.
+*
+* @param graph - Source graph
+* @param paths - Paths to rank
+* @param config - Configuration options
+* @returns Ranked paths (highest PageRank sum first)
+*/
+function pagerank(graph, paths, config) {
+	const { includeScores = true } = config ?? {};
+	if (paths.length === 0) return {
+		paths: [],
+		method: "pagerank"
+	};
+	const ranks = computePageRank(graph);
+	const scored = paths.map((path) => {
+		let prSum = 0;
+		for (const nodeId of path.nodes) prSum += ranks.get(nodeId) ?? 0;
+		return {
+			path,
+			score: prSum
+		};
+	});
+	const maxScore = Math.max(...scored.map((s) => s.score));
+	if (maxScore === 0) return {
+		paths: paths.map((path) => ({
+			...path,
+			score: 0
+		})),
+		method: "pagerank"
+	};
+	return {
+		paths: scored.map(({ path, score }) => ({
+			...path,
+			score: includeScores ? score / maxScore : score / maxScore
+		})).sort((a, b) => b.score - a.score),
+		method: "pagerank"
+	};
+}
+//#endregion
+//#region src/ranking/baselines/betweenness.ts
+/**
+* Compute betweenness centrality for all nodes using Brandes algorithm.
+*
+* @param graph - Source graph
+* @returns Map of node ID to betweenness value
+*/
+function computeBetweenness(graph) {
+	const nodes = Array.from(graph.nodeIds());
+	const betweenness = /* @__PURE__ */ new Map();
+	for (const nodeId of nodes) betweenness.set(nodeId, 0);
+	for (const source of nodes) {
+		const predecessors = /* @__PURE__ */ new Map();
+		const distance = /* @__PURE__ */ new Map();
+		const sigma = /* @__PURE__ */ new Map();
+		const queue = [];
+		for (const nodeId of nodes) {
+			predecessors.set(nodeId, []);
+			distance.set(nodeId, -1);
+			sigma.set(nodeId, 0);
+		}
+		distance.set(source, 0);
+		sigma.set(source, 1);
+		queue.push(source);
+		for (const v of queue) {
+			const vDist = distance.get(v) ?? -1;
+			const neighbours = graph.neighbours(v);
+			for (const w of neighbours) {
+				const wDist = distance.get(w) ?? -1;
+				if (wDist < 0) {
+					distance.set(w, vDist + 1);
+					queue.push(w);
+				}
+				if (wDist === vDist + 1) {
+					const wSigma = sigma.get(w) ?? 0;
+					const vSigma = sigma.get(v) ?? 0;
+					sigma.set(w, wSigma + vSigma);
+					const wPred = predecessors.get(w) ?? [];
+					wPred.push(v);
+					predecessors.set(w, wPred);
+				}
+			}
+		}
+		const delta = /* @__PURE__ */ new Map();
+		for (const nodeId of nodes) delta.set(nodeId, 0);
+		const sorted = [...nodes].sort((a, b) => {
+			const aD = distance.get(a) ?? -1;
+			return (distance.get(b) ?? -1) - aD;
+		});
+		for (const w of sorted) {
+			if (w === source) continue;
+			const wDelta = delta.get(w) ?? 0;
+			const wSigma = sigma.get(w) ?? 0;
+			const wPred = predecessors.get(w) ?? [];
+			for (const v of wPred) {
+				const vSigma = sigma.get(v) ?? 0;
+				const vDelta = delta.get(v) ?? 0;
+				if (wSigma > 0) delta.set(v, vDelta + vSigma / wSigma * (1 + wDelta));
+			}
+			if (w !== source) {
+				const current = betweenness.get(w) ?? 0;
+				betweenness.set(w, current + wDelta);
+			}
+		}
+	}
+	return betweenness;
+}
+/**
+* Rank paths by sum of betweenness scores.
+*
+* @param graph - Source graph
+* @param paths - Paths to rank
+* @param config - Configuration options
+* @returns Ranked paths (highest betweenness sum first)
+*/
+function betweenness(graph, paths, config) {
+	const { includeScores = true } = config ?? {};
+	if (paths.length === 0) return {
+		paths: [],
+		method: "betweenness"
+	};
+	const bcMap = computeBetweenness(graph);
+	const scored = paths.map((path) => {
+		let bcSum = 0;
+		for (const nodeId of path.nodes) bcSum += bcMap.get(nodeId) ?? 0;
+		return {
+			path,
+			score: bcSum
+		};
+	});
+	const maxScore = Math.max(...scored.map((s) => s.score));
+	if (maxScore === 0) return {
+		paths: paths.map((path) => ({
+			...path,
+			score: 0
+		})),
+		method: "betweenness"
+	};
+	return {
+		paths: scored.map(({ path, score }) => ({
+			...path,
+			score: includeScores ? score / maxScore : score / maxScore
+		})).sort((a, b) => b.score - a.score),
+		method: "betweenness"
+	};
+}
+//#endregion
+//#region src/ranking/baselines/katz.ts
+/**
+* Compute truncated Katz centrality between two nodes.
+*
+* Uses iterative matrix-vector products to avoid full matrix powers.
+* score(s,t) = sum_{k=1}^{K} beta^k * walks_k(s,t)
+*
+* @param graph - Source graph
+* @param source - Source node ID
+* @param target - Target node ID
+* @param k - Truncation depth (default 5)
+* @param beta - Attenuation factor (default 0.005)
+* @returns Katz score
+*/
+function computeKatz(graph, source, target, k = 5, beta = .005) {
+	const nodes = Array.from(graph.nodeIds());
+	const nodeToIdx = /* @__PURE__ */ new Map();
+	nodes.forEach((nodeId, idx) => {
+		nodeToIdx.set(nodeId, idx);
+	});
+	const n = nodes.length;
+	if (n === 0) return 0;
+	const sourceIdx = nodeToIdx.get(source);
+	const targetIdx = nodeToIdx.get(target);
+	if (sourceIdx === void 0 || targetIdx === void 0) return 0;
+	let walks = new Float64Array(n);
+	walks[targetIdx] = 1;
+	let katzScore = 0;
+	for (let depth = 1; depth <= k; depth++) {
+		const walksNext = new Float64Array(n);
+		for (const sourceNode of nodes) {
+			const srcIdx = nodeToIdx.get(sourceNode);
+			if (srcIdx === void 0) continue;
+			const neighbours = graph.neighbours(sourceNode);
+			for (const neighbourId of neighbours) {
+				const nIdx = nodeToIdx.get(neighbourId);
+				if (nIdx === void 0) continue;
+				walksNext[srcIdx] = (walksNext[srcIdx] ?? 0) + (walks[nIdx] ?? 0);
+			}
+		}
+		const walkCount = walksNext[sourceIdx] ?? 0;
+		katzScore += Math.pow(beta, depth) * walkCount;
+		walks = walksNext;
+	}
+	return katzScore;
+}
+/**
+* Rank paths by Katz centrality between endpoints.
+*
+* @param graph - Source graph
+* @param paths - Paths to rank
+* @param config - Configuration options
+* @returns Ranked paths (highest Katz score first)
+*/
+function katz(graph, paths, config) {
+	const { includeScores = true } = config ?? {};
+	if (paths.length === 0) return {
+		paths: [],
+		method: "katz"
+	};
+	const scored = paths.map((path) => {
+		const source = path.nodes[0];
+		const target = path.nodes[path.nodes.length - 1];
+		if (source === void 0 || target === void 0) return {
+			path,
+			score: 0
+		};
+		return {
+			path,
+			score: computeKatz(graph, source, target)
+		};
+	});
+	const maxScore = Math.max(...scored.map((s) => s.score));
+	if (maxScore === 0) return {
+		paths: paths.map((path) => ({
+			...path,
+			score: 0
+		})),
+		method: "katz"
+	};
+	return {
+		paths: scored.map(({ path, score }) => ({
+			...path,
+			score: includeScores ? score / maxScore : score / maxScore
+		})).sort((a, b) => b.score - a.score),
+		method: "katz"
+	};
+}
+//#endregion
+//#region src/ranking/baselines/communicability.ts
+/**
+* Compute truncated communicability between two nodes.
+*
+* Uses Taylor series expansion: (e^A)_{s,t} ≈ sum_{k=0}^{K} A^k_{s,t} / k!
+*
+* @param graph - Source graph
+* @param source - Source node ID
+* @param target - Target node ID
+* @param k - Truncation depth (default 15)
+* @returns Communicability score
+*/
+function computeCommunicability(graph, source, target, k = 15) {
+	const nodes = Array.from(graph.nodeIds());
+	const nodeToIdx = /* @__PURE__ */ new Map();
+	nodes.forEach((nodeId, idx) => {
+		nodeToIdx.set(nodeId, idx);
+	});
+	const n = nodes.length;
+	if (n === 0) return 0;
+	const sourceIdx = nodeToIdx.get(source);
+	const targetIdx = nodeToIdx.get(target);
+	if (sourceIdx === void 0 || targetIdx === void 0) return 0;
+	let walks = new Float64Array(n);
+	walks[targetIdx] = 1;
+	let commScore = walks[sourceIdx] ?? 0;
+	let factorial = 1;
+	for (let depth = 1; depth <= k; depth++) {
+		const walksNext = new Float64Array(n);
+		for (const fromNode of nodes) {
+			const fromIdx = nodeToIdx.get(fromNode);
+			if (fromIdx === void 0) continue;
+			const neighbours = graph.neighbours(fromNode);
+			for (const toNodeId of neighbours) {
+				const toIdx = nodeToIdx.get(toNodeId);
+				if (toIdx === void 0) continue;
+				walksNext[fromIdx] = (walksNext[fromIdx] ?? 0) + (walks[toIdx] ?? 0);
+			}
+		}
+		factorial *= depth;
+		commScore += (walksNext[sourceIdx] ?? 0) / factorial;
+		walks = walksNext;
+	}
+	return commScore;
+}
+/**
+* Rank paths by communicability between endpoints.
+*
+* @param graph - Source graph
+* @param paths - Paths to rank
+* @param config - Configuration options
+* @returns Ranked paths (highest communicability first)
+*/
+function communicability(graph, paths, config) {
+	const { includeScores = true } = config ?? {};
+	if (paths.length === 0) return {
+		paths: [],
+		method: "communicability"
+	};
+	const scored = paths.map((path) => {
+		const source = path.nodes[0];
+		const target = path.nodes[path.nodes.length - 1];
+		if (source === void 0 || target === void 0) return {
+			path,
+			score: 0
+		};
+		return {
+			path,
+			score: computeCommunicability(graph, source, target)
+		};
+	});
+	const maxScore = Math.max(...scored.map((s) => s.score));
+	if (maxScore === 0) return {
+		paths: paths.map((path) => ({
+			...path,
+			score: 0
+		})),
+		method: "communicability"
+	};
+	return {
+		paths: scored.map(({ path, score }) => ({
+			...path,
+			score: includeScores ? score / maxScore : score / maxScore
+		})).sort((a, b) => b.score - a.score),
+		method: "communicability"
+	};
+}
+//#endregion
+//#region src/ranking/baselines/resistance-distance.ts
+/**
+* Compute effective resistance between two nodes via Laplacian pseudoinverse.
+*
+* Resistance = L^+_{s,s} + L^+_{t,t} - 2*L^+_{s,t}
+* where L^+ is the pseudoinverse of the Laplacian matrix.
+*
+* @param graph - Source graph
+* @param source - Source node ID
+* @param target - Target node ID
+* @returns Effective resistance
+*/
+function computeResistance(graph, source, target) {
+	const nodes = Array.from(graph.nodeIds());
+	const nodeToIdx = /* @__PURE__ */ new Map();
+	nodes.forEach((nodeId, idx) => {
+		nodeToIdx.set(nodeId, idx);
+	});
+	const n = nodes.length;
+	if (n === 0 || n > 5e3) throw new Error(`Cannot compute resistance distance: graph too large (${String(n)} nodes). Maximum 5000.`);
+	const sourceIdx = nodeToIdx.get(source);
+	const targetIdx = nodeToIdx.get(target);
+	if (sourceIdx === void 0 || targetIdx === void 0) return 0;
+	const L = Array.from({ length: n }, () => Array.from({ length: n }, () => 0));
+	for (let i = 0; i < n; i++) {
+		const nodeId = nodes[i];
+		if (nodeId === void 0) continue;
+		const degree = graph.degree(nodeId);
+		const row = L[i];
+		if (row !== void 0) row[i] = degree;
+		const neighbours = graph.neighbours(nodeId);
+		for (const neighbourId of neighbours) {
+			const j = nodeToIdx.get(neighbourId);
+			if (j !== void 0 && row !== void 0) row[j] = -1;
+		}
+	}
+	const Lpinv = pinv(L);
+	const resistance = (Lpinv[sourceIdx]?.[sourceIdx] ?? 0) + (Lpinv[targetIdx]?.[targetIdx] ?? 0) - 2 * (Lpinv[sourceIdx]?.[targetIdx] ?? 0);
+	return Math.max(resistance, 1e-10);
+}
+/**
+* Compute Moore-Penrose pseudoinverse of a matrix.
+* Simplified implementation for small dense matrices.
+*
+* @param A - Square matrix
+* @returns Pseudoinverse A^+
+*/
+function pinv(A) {
+	const n = A.length;
+	if (n === 0) return [];
+	const M = A.map((row) => [...row]);
+	const epsilon = 1e-10;
+	for (let i = 0; i < n; i++) {
+		const row = M[i];
+		if (row !== void 0) row[i] = (row[i] ?? 0) + epsilon;
+	}
+	return gaussianInverse(M);
+}
+/**
+* Compute matrix inverse using Gaussian elimination with partial pivoting.
+*
+* @param A - Matrix to invert
+* @returns Inverted matrix
+*/
+function gaussianInverse(A) {
+	const n = A.length;
+	const aug = A.map((row, i) => {
+		const identity = Array.from({ length: n }, (_, j) => i === j ? 1 : 0);
+		return [...row, ...identity];
+	});
+	for (let col = 0; col < n; col++) {
+		let maxRow = col;
+		for (let row = col + 1; row < n; row++) {
+			const currentRow = aug[row];
+			const maxRowRef = aug[maxRow];
+			if (currentRow !== void 0 && maxRowRef !== void 0 && Math.abs(currentRow[col] ?? 0) > Math.abs(maxRowRef[col] ?? 0)) maxRow = row;
+		}
+		const currentCol = aug[col];
+		const maxRowAug = aug[maxRow];
+		if (currentCol !== void 0 && maxRowAug !== void 0) {
+			aug[col] = maxRowAug;
+			aug[maxRow] = currentCol;
+		}
+		const pivotRow = aug[col];
+		const pivot = pivotRow?.[col];
+		if (pivot === void 0 || Math.abs(pivot) < 1e-12) continue;
+		if (pivotRow !== void 0) for (let j = col; j < 2 * n; j++) pivotRow[j] = (pivotRow[j] ?? 0) / pivot;
+		for (let row = 0; row < n; row++) {
+			if (row === col) continue;
+			const eliminationRow = aug[row];
+			const factor = eliminationRow?.[col] ?? 0;
+			if (eliminationRow !== void 0 && pivotRow !== void 0) for (let j = col; j < 2 * n; j++) eliminationRow[j] = (eliminationRow[j] ?? 0) - factor * (pivotRow[j] ?? 0);
+		}
+	}
+	const Ainv = [];
+	for (let i = 0; i < n; i++) Ainv[i] = (aug[i]?.slice(n) ?? []).map((v) => v);
+	return Ainv;
+}
+/**
+* Rank paths by reciprocal of resistance distance between endpoints.
+*
+* @param graph - Source graph
+* @param paths - Paths to rank
+* @param config - Configuration options
+* @returns Ranked paths (highest conductance first)
+*/
+function resistanceDistance(graph, paths, config) {
+	const { includeScores = true } = config ?? {};
+	if (paths.length === 0) return {
+		paths: [],
+		method: "resistance-distance"
+	};
+	const nodeCount = Array.from(graph.nodeIds()).length;
+	if (nodeCount > 5e3) throw new Error(`Cannot rank paths: graph too large (${String(nodeCount)} nodes). Resistance distance requires O(n^3) computation; maximum 5000 nodes.`);
+	const scored = paths.map((path) => {
+		const source = path.nodes[0];
+		const target = path.nodes[path.nodes.length - 1];
+		if (source === void 0 || target === void 0) return {
+			path,
+			score: 0
+		};
+		return {
+			path,
+			score: 1 / computeResistance(graph, source, target)
+		};
+	});
+	const maxScore = Math.max(...scored.map((s) => s.score));
+	if (maxScore === 0) return {
+		paths: paths.map((path) => ({
+			...path,
+			score: 0
+		})),
+		method: "resistance-distance"
+	};
+	return {
+		paths: scored.map(({ path, score }) => ({
+			...path,
+			score: includeScores ? score / maxScore : score / maxScore
+		})).sort((a, b) => b.score - a.score),
+		method: "resistance-distance"
+	};
+}
+//#endregion
+//#region src/ranking/baselines/random-ranking.ts
+/**
+* Deterministic seeded random number generator.
+* Uses FNV-1a-like hash for input → [0, 1] output.
+*
+* @param input - String to hash
+* @param seed - Random seed for reproducibility
+* @returns Deterministic random value in [0, 1]
+*/
+function seededRandom(input, seed = 0) {
+	let h = seed;
+	for (let i = 0; i < input.length; i++) {
+		h = Math.imul(h ^ input.charCodeAt(i), 2654435769);
+		h ^= h >>> 16;
+	}
+	return (h >>> 0) / 4294967295;
+}
+/**
+* Rank paths randomly (null hypothesis baseline).
+*
+* @param _graph - Source graph (unused)
+* @param paths - Paths to rank
+* @param config - Configuration options
+* @returns Ranked paths (randomly ordered)
+*/
+function randomRanking(_graph, paths, config) {
+	const { includeScores = true, seed = 0 } = config ?? {};
+	if (paths.length === 0) return {
+		paths: [],
+		method: "random"
+	};
+	const scored = paths.map((path) => {
+		return {
+			path,
+			score: seededRandom(path.nodes.join(","), seed)
+		};
+	});
+	const maxScore = Math.max(...scored.map((s) => s.score));
+	if (maxScore === 0) return {
+		paths: paths.map((path) => ({
+			...path,
+			score: 0
+		})),
+		method: "random"
+	};
+	return {
+		paths: scored.map(({ path, score }) => ({
+			...path,
+			score: includeScores ? score / maxScore : score / maxScore
+		})).sort((a, b) => b.score - a.score),
+		method: "random"
+	};
+}
+//#endregion
 //#region src/extraction/ego-network.ts
 /**
 * Extract the ego-network (k-hop neighbourhood) of a centre node.
@@ -1023,6 +1758,82 @@ function extractKTruss(graph, k) {
 	}
 	return result;
 }
+/**
+* Compute the truss number for each edge.
+*
+* The truss number of an edge is the largest k such that the edge
+* belongs to the k-truss.
+*
+* @param graph - The source graph
+* @returns Map from edge key (canonical "u::v") to truss number
+*
+* @example
+* ```typescript
+* const trussNumbers = computeTrussNumbers(graph);
+* const edgeKey = 'A::B'; // where A < B lexicographically
+* console.log(`Edge A-B is in the ${trussNumbers.get(edgeKey)}-truss`);
+* ```
+*/
+function computeTrussNumbers(graph) {
+	const adjacency = /* @__PURE__ */ new Map();
+	const edgeData = /* @__PURE__ */ new Map();
+	const remainingEdges = /* @__PURE__ */ new Set();
+	for (const nodeId of graph.nodeIds()) adjacency.set(nodeId, /* @__PURE__ */ new Set());
+	for (const edge of graph.edges()) {
+		const { source, target } = edge;
+		adjacency.get(source)?.add(target);
+		adjacency.get(target)?.add(source);
+		const key = source < target ? `${source}::${target}` : `${target}::${source}`;
+		edgeData.set(key, edge);
+		remainingEdges.add(key);
+	}
+	const triangleCounts = /* @__PURE__ */ new Map();
+	for (const key of remainingEdges) {
+		const edge = edgeData.get(key);
+		if (edge !== void 0) triangleCounts.set(key, countEdgeTriangles(graph, edge.source, edge.target));
+	}
+	const trussNumbers = /* @__PURE__ */ new Map();
+	const edgesByTriangleCount = /* @__PURE__ */ new Map();
+	for (const [key, count] of triangleCounts) {
+		if (!edgesByTriangleCount.has(count)) edgesByTriangleCount.set(count, /* @__PURE__ */ new Set());
+		edgesByTriangleCount.get(count)?.add(key);
+	}
+	const sortedCounts = [...edgesByTriangleCount.keys()].sort((a, b) => a - b);
+	for (const currentCount of sortedCounts) {
+		const bucket = edgesByTriangleCount.get(currentCount);
+		if (bucket === void 0) continue;
+		while (bucket.size > 0) {
+			const edgeKey = bucket.values().next().value;
+			if (edgeKey === void 0) break;
+			bucket.delete(edgeKey);
+			if (!remainingEdges.has(edgeKey)) continue;
+			const trussNumber = currentCount + 2;
+			trussNumbers.set(edgeKey, trussNumber);
+			remainingEdges.delete(edgeKey);
+			const edge = edgeData.get(edgeKey);
+			if (edge === void 0) continue;
+			const { source, target } = edge;
+			adjacency.get(source)?.delete(target);
+			adjacency.get(target)?.delete(source);
+			const sourceNeighbours = adjacency.get(source);
+			if (sourceNeighbours !== void 0) {
+				for (const w of adjacency.get(target) ?? []) if (sourceNeighbours.has(w)) {
+					const keySw = source < w ? `${source}::${w}` : `${w}::${source}`;
+					const keyTw = target < w ? `${target}::${w}` : `${w}::${target}`;
+					for (const keyToUpdate of [keySw, keyTw]) if (remainingEdges.has(keyToUpdate)) {
+						const oldCount = triangleCounts.get(keyToUpdate) ?? 0;
+						const newCount = oldCount - 1;
+						triangleCounts.set(keyToUpdate, newCount);
+						edgesByTriangleCount.get(oldCount)?.delete(keyToUpdate);
+						if (!edgesByTriangleCount.has(newCount)) edgesByTriangleCount.set(newCount, /* @__PURE__ */ new Set());
+						edgesByTriangleCount.get(newCount)?.add(keyToUpdate);
+					}
+				}
+			}
+		}
+	}
+	return trussNumbers;
+}
 //#endregion
 //#region src/extraction/motif.ts
 /**
@@ -1133,10 +1944,11 @@ function enumerate3NodeMotifs(graph, includeInstances) {
 			}
 		}
 	}
-	return {
+	if (instances !== void 0) return {
 		counts,
 		instances
 	};
+	return { counts };
 }
 /**
 * Enumerate all 4-node motifs in the graph.
@@ -1204,10 +2016,11 @@ function enumerate4NodeMotifs(graph, includeInstances) {
 			}
 		}
 	}
-	return {
+	if (instances !== void 0) return {
 		counts,
 		instances
 	};
+	return { counts };
 }
 /**
 * Human-readable names for common 3-node motifs.
@@ -1354,19 +2167,31 @@ function filterSubgraph(graph, options) {
 //#endregion
 exports.AdjacencyMapGraph = require_graph.AdjacencyMapGraph;
 exports.GPUContext = require_gpu.GPUContext;
+exports.GPUNotAvailableError = require_gpu.GPUNotAvailableError;
 exports.PriorityQueue = require_structures.PriorityQueue;
+exports._computeMean = require_kmeans._computeMean;
 exports.adamicAdar = adamicAdar;
 exports.adaptive = adaptive;
 exports.approximateClusteringCoefficient = require_utils.approximateClusteringCoefficient;
+exports.assertWebGPUAvailable = require_gpu.assertWebGPUAvailable;
 exports.base = base;
 exports.batchClusteringCoefficients = require_utils.batchClusteringCoefficients;
+exports.betweenness = betweenness;
 exports.bfs = require_traversal.bfs;
 exports.bfsWithPath = require_traversal.bfsWithPath;
+exports.communicability = communicability;
+exports.computeTrussNumbers = computeTrussNumbers;
+exports.countEdgesOfType = require_utils.countEdgesOfType;
+exports.countNodesOfType = require_utils.countNodesOfType;
+exports.createGPUContext = require_gpu.createGPUContext;
+exports.createResultBuffer = require_gpu.createResultBuffer;
 exports.csrToGPUBuffers = require_gpu.csrToGPUBuffers;
+exports.degreeSum = degreeSum;
 exports.detectWebGPU = require_gpu.detectWebGPU;
 exports.dfs = require_traversal.dfs;
 exports.dfsWithPath = require_traversal.dfsWithPath;
 exports.dome = dome;
+exports.domeHighDegree = domeHighDegree;
 exports.edge = edge;
 exports.entropyFromCounts = require_utils.entropyFromCounts;
 exports.enumerateMotifs = enumerateMotifs;
@@ -1377,28 +2202,43 @@ exports.extractInducedSubgraph = extractInducedSubgraph;
 exports.extractKCore = extractKCore;
 exports.extractKTruss = extractKTruss;
 exports.filterSubgraph = filterSubgraph;
+exports.frontierBalanced = frontierBalanced;
+exports.getGPUContext = require_gpu.getGPUContext;
 exports.getMotifName = getMotifName;
 exports.graphToCSR = require_gpu.graphToCSR;
 exports.grasp = require_seeds.grasp;
 exports.hae = hae;
+exports.isWebGPUAvailable = require_gpu.isWebGPUAvailable;
 exports.jaccard = jaccard;
+exports.jaccardArithmetic = jaccardArithmetic;
+exports.katz = katz;
 exports.localClusteringCoefficient = require_utils.localClusteringCoefficient;
 exports.localTypeEntropy = require_utils.localTypeEntropy;
 exports.maze = maze;
 exports.miniBatchKMeans = require_kmeans.miniBatchKMeans;
+exports.neighbourIntersection = require_utils.neighbourIntersection;
+exports.neighbourOverlap = require_utils.neighbourOverlap;
+exports.neighbourSet = require_utils.neighbourSet;
 exports.normaliseFeatures = require_kmeans.normaliseFeatures;
+exports.zScoreNormalise = require_kmeans.normaliseFeatures;
 exports.normalisedEntropy = require_utils.normalisedEntropy;
 exports.notch = notch;
+exports.pagerank = pagerank;
 exports.parse = parse;
 exports.pipe = pipe;
+exports.randomPriority = randomPriority;
+exports.randomRanking = randomRanking;
 exports.reach = reach;
+exports.readBufferToCPU = require_gpu.readBufferToCPU;
+exports.resistanceDistance = resistanceDistance;
 exports.sage = sage;
 exports.scale = scale;
 exports.shannonEntropy = require_utils.shannonEntropy;
 exports.shortest = shortest;
 exports.skew = skew;
 exports.span = span;
+exports.standardBfs = standardBfs;
 exports.stratified = require_seeds.stratified;
-exports.zScoreNormalise = require_kmeans.normaliseFeatures;
+exports.widestPath = widestPath;
 
 //# sourceMappingURL=index.cjs.map