graphwise 1.5.0 → 1.5.2

package/dist/index/index.cjs

@@ -255,46 +255,12 @@ function domeHighDegree(graph, seeds, config) {
 	});
 }
 //#endregion
-//#region src/expansion/edge.ts
-var EPSILON$1 = 1e-10;
-/**
-* Priority function using local type entropy.
-* Lower values = higher priority (expanded first).
-*/
-function edgePriority(nodeId, context) {
-	const graph = context.graph;
-	const neighbours = graph.neighbours(nodeId);
-	const neighbourTypes = [];
-	for (const neighbour of neighbours) {
-		const node = graph.getNode(neighbour);
-		neighbourTypes.push(node?.type ?? "default");
-	}
-	return 1 / (require_utils.localTypeEntropy(neighbourTypes) + EPSILON$1) * Math.log(context.degree + 1);
-}
-/**
-* Run EDGE expansion (Entropy-Driven Graph Expansion).
-*
-* Discovers paths by prioritising nodes with diverse neighbour types,
-* deferring nodes with homogeneous neighbourhoods.
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function edge(graph, seeds, config) {
-	return base(graph, seeds, {
-		...config,
-		priority: edgePriority
-	});
-}
-//#endregion
 //#region src/expansion/hae.ts
 var EPSILON = 1e-10;
 /**
 * Default type mapper - uses node.type property.
 */
-function defaultTypeMapper(node) {
+function defaultTypeMapper$1(node) {
 	return node.type ?? "default";
 }
 /**
@@ -324,13 +290,34 @@ function createHAEPriority(typeMapper) {
 * @returns Expansion result with discovered paths
 */
 function hae(graph, seeds, config) {
-	const typeMapper = config?.typeMapper ?? defaultTypeMapper;
+	const typeMapper = config?.typeMapper ?? defaultTypeMapper$1;
 	return base(graph, seeds, {
 		...config,
 		priority: createHAEPriority(typeMapper)
 	});
 }
 //#endregion
+//#region src/expansion/edge.ts
+/** Default type mapper: reads `node.type`, falling back to "default". */
+var defaultTypeMapper = (n) => typeof n.type === "string" ? n.type : "default";
+/**
+* Run EDGE expansion (Entropy-Driven Graph Expansion).
+*
+* Discovers paths by prioritising nodes with diverse neighbour types,
+* deferring nodes with homogeneous neighbourhoods.
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration
+* @returns Expansion result with discovered paths
+*/
+function edge(graph, seeds, config) {
+	return hae(graph, seeds, {
+		...config,
+		typeMapper: defaultTypeMapper
+	});
+}
+//#endregion
 //#region src/expansion/pipe.ts
 /**
 * Priority function using path potential.
@@ -366,6 +353,69 @@ function pipe(graph, seeds, config) {
 	});
 }
 //#endregion
+//#region src/expansion/priority-helpers.ts
+/**
+* Compute the average mutual information between a node and all visited
+* nodes in the same frontier.
+*
+* Returns a value in [0, 1] — higher means the node is more similar
+* (on average) to already-visited same-frontier nodes.
+*
+* @param graph - Source graph
+* @param nodeId - Node being prioritised
+* @param context - Current priority context
+* @param mi - MI function to use for pairwise scoring
+* @returns Average MI score, or 0 if no same-frontier visited nodes exist
+*/
+function avgFrontierMI(graph, nodeId, context, mi) {
+	const { frontierIndex, visitedByFrontier } = context;
+	let total = 0;
+	let count = 0;
+	for (const [visitedId, idx] of visitedByFrontier) if (idx === frontierIndex && visitedId !== nodeId) {
+		total += mi(graph, visitedId, nodeId);
+		count++;
+	}
+	return count > 0 ? total / count : 0;
+}
+/**
+* Count the number of a node's neighbours that have been visited by
+* frontiers other than the node's own frontier.
+*
+* A higher count indicates this node is likely to bridge two frontiers,
+* making it a strong candidate for path completion.
+*
+* @param graph - Source graph
+* @param nodeId - Node being evaluated
+* @param context - Current priority context
+* @returns Number of neighbours visited by other frontiers
+*/
+function countCrossFrontierNeighbours(graph, nodeId, context) {
+	const { frontierIndex, visitedByFrontier } = context;
+	const nodeNeighbours = new Set(graph.neighbours(nodeId));
+	let count = 0;
+	for (const [visitedId, idx] of visitedByFrontier) if (idx !== frontierIndex && nodeNeighbours.has(visitedId)) count++;
+	return count;
+}
+/**
+* Incrementally update salience counts for paths discovered since the
+* last update.
+*
+* Iterates only over paths from `fromIndex` onwards, avoiding redundant
+* re-processing of already-counted paths.
+*
+* @param salienceCounts - Mutable map of node ID to salience count (mutated in place)
+* @param paths - Full list of discovered paths
+* @param fromIndex - Index to start counting from (exclusive of earlier paths)
+* @returns The new `fromIndex` value (i.e. `paths.length` after update)
+*/
+function updateSalienceCounts(salienceCounts, paths, fromIndex) {
+	for (let i = fromIndex; i < paths.length; i++) {
+		const path = paths[i];
+		if (path !== void 0) for (const node of path.nodes) salienceCounts.set(node, (salienceCounts.get(node) ?? 0) + 1);
+	}
+	return paths.length;
+}
+//#endregion
 //#region src/expansion/sage.ts
 /**
 * Run SAGE expansion algorithm.
@@ -389,13 +439,7 @@ function sage(graph, seeds, config) {
 	function sagePriority(nodeId, context) {
 		const pathCount = context.discoveredPaths.length;
 		if (pathCount > 0 && !inPhase2) inPhase2 = true;
-		if (pathCount > lastPathCount) {
-			for (let i = lastPathCount; i < pathCount; i++) {
-				const path = context.discoveredPaths[i];
-				if (path !== void 0) for (const node of path.nodes) salienceCounts.set(node, (salienceCounts.get(node) ?? 0) + 1);
-			}
-			lastPathCount = pathCount;
-		}
+		if (pathCount > lastPathCount) lastPathCount = updateSalienceCounts(salienceCounts, context.discoveredPaths, lastPathCount);
 		if (!inPhase2) return Math.log(context.degree + 1);
 		return -((salienceCounts.get(nodeId) ?? 0) * 1e3 - context.degree);
 	}
@@ -417,10 +461,9 @@ function sage(graph, seeds, config) {
 */
 function jaccard(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	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);
+	const { jaccard: jaccardScore, sourceNeighbours, targetNeighbours } = require_utils.computeJaccard(graph, source, target);
+	if (sourceNeighbours.size === 0 && targetNeighbours.size === 0) return 0;
+	return Math.max(epsilon, jaccardScore);
 }
 //#endregion
 //#region src/expansion/reach.ts
@@ -506,15 +549,9 @@ function maze(graph, seeds, config) {
 		const pathCount = context.discoveredPaths.length;
 		if (pathCount >= DEFAULT_PHASE2_THRESHOLD && !inPhase2) {
 			inPhase2 = true;
-			for (const path of context.discoveredPaths) for (const node of path.nodes) salienceCounts.set(node, (salienceCounts.get(node) ?? 0) + 1);
-		}
-		if (inPhase2 && pathCount > lastPathCount) {
-			for (let i = lastPathCount; i < pathCount; i++) {
-				const path = context.discoveredPaths[i];
-				if (path !== void 0) for (const node of path.nodes) salienceCounts.set(node, (salienceCounts.get(node) ?? 0) + 1);
-			}
-			lastPathCount = pathCount;
+			updateSalienceCounts(salienceCounts, context.discoveredPaths, 0);
 		}
+		if (inPhase2 && pathCount > lastPathCount) lastPathCount = updateSalienceCounts(salienceCounts, context.discoveredPaths, lastPathCount);
 		const nodeNeighbours = graph.neighbours(nodeId);
 		let pathPotential = 0;
 		for (const neighbour of nodeNeighbours) {
@@ -566,22 +603,11 @@ function tide(graph, seeds, config) {
 /**
 * LACE priority function.
 *
-* Priority = 1 - MI(source, neighbour)
-* Higher MI = lower priority value = explored first
+* Priority = 1 - avgMI(node, same-frontier visited nodes)
+* Higher average MI = lower priority value = explored first
 */
 function lacePriority(nodeId, context, mi) {
-	const graph = context.graph;
-	const frontierIndex = context.frontierIndex;
-	let maxMi = 0;
-	let totalMi = 0;
-	let count = 0;
-	for (const [visitedId, idx] of context.visitedByFrontier) if (idx === frontierIndex && visitedId !== nodeId) {
-		const edgeMi = mi(graph, visitedId, nodeId);
-		totalMi += edgeMi;
-		count++;
-		if (edgeMi > maxMi) maxMi = edgeMi;
-	}
-	return 1 - (count > 0 ? totalMi / count : 0);
+	return 1 - avgFrontierMI(context.graph, nodeId, context, mi);
 }
 /**
 * Run LACE expansion algorithm.
@@ -605,18 +631,15 @@ function lace(graph, seeds, config) {
 //#endregion
 //#region src/expansion/warp.ts
 /**
-* PIPE priority function.
+* WARP priority function.
 *
 * Priority = 1 / (1 + bridge_score)
-* Bridge score = neighbourhood overlap with other frontiers
-* Higher bridge score = more likely to be on paths = explored first
+* Bridge score = cross-frontier neighbour count plus bonus for nodes
+* already on discovered paths.
+* Higher bridge score = more likely to complete paths = explored first.
 */
 function warpPriority(nodeId, context) {
-	const graph = context.graph;
-	const currentFrontier = context.frontierIndex;
-	const nodeNeighbours = new Set(graph.neighbours(nodeId));
-	let bridgeScore = 0;
-	for (const [visitedId, frontierIdx] of context.visitedByFrontier) if (frontierIdx !== currentFrontier && nodeNeighbours.has(visitedId)) bridgeScore++;
+	let bridgeScore = countCrossFrontierNeighbours(context.graph, nodeId, context);
 	for (const path of context.discoveredPaths) if (path.nodes.includes(nodeId)) bridgeScore += 2;
 	return 1 / (1 + bridgeScore);
 }
@@ -640,24 +663,15 @@ function warp(graph, seeds, config) {
 //#endregion
 //#region src/expansion/fuse.ts
 /**
-* SAGE priority function.
+* FUSE priority function.
 *
-* Combines degree with salience:
-* Priority = (1 - w) * degree + w * (1 - avg_salience)
-* Lower values = higher priority
+* Combines degree with average frontier MI as a salience proxy:
+* Priority = (1 - w) * degree + w * (1 - avgMI)
+* Lower values = higher priority; high salience lowers priority
 */
 function fusePriority(nodeId, context, mi, salienceWeight) {
-	const graph = context.graph;
-	const degree = context.degree;
-	const frontierIndex = context.frontierIndex;
-	let totalSalience = 0;
-	let count = 0;
-	for (const [visitedId, idx] of context.visitedByFrontier) if (idx === frontierIndex && visitedId !== nodeId) {
-		totalSalience += mi(graph, visitedId, nodeId);
-		count++;
-	}
-	const avgSalience = count > 0 ? totalSalience / count : 0;
-	return (1 - salienceWeight) * degree + salienceWeight * (1 - avgSalience);
+	const avgSalience = avgFrontierMI(context.graph, nodeId, context, mi);
+	return (1 - salienceWeight) * context.degree + salienceWeight * (1 - avgSalience);
 }
 /**
 * Run FUSE expansion algorithm.
@@ -681,20 +695,13 @@ function fuse(graph, seeds, config) {
 //#endregion
 //#region src/expansion/sift.ts
 /**
-* REACH priority function (phase 2).
+* REACH (SIFT) priority function.
 *
-* Uses learned MI threshold to prioritise high-MI edges.
+* Prioritises nodes with average frontier MI above the threshold;
+* falls back to degree-based ordering for those below it.
 */
 function siftPriority(nodeId, context, mi, miThreshold) {
-	const graph = context.graph;
-	const frontierIndex = context.frontierIndex;
-	let totalMi = 0;
-	let count = 0;
-	for (const [visitedId, idx] of context.visitedByFrontier) if (idx === frontierIndex && visitedId !== nodeId) {
-		totalMi += mi(graph, visitedId, nodeId);
-		count++;
-	}
-	const avgMi = count > 0 ? totalMi / count : 0;
+	const avgMi = avgFrontierMI(context.graph, nodeId, context, mi);
 	if (avgMi >= miThreshold) return 1 - avgMi;
 	else return context.degree + 100;
 }
@@ -736,16 +743,6 @@ function localDensity(graph, nodeId) {
 	return edges / maxEdges;
 }
 /**
-* Compute bridge score (how many other frontiers visit neighbours).
-*/
-function bridgeScore(nodeId, context) {
-	const currentFrontier = context.frontierIndex;
-	const nodeNeighbours = new Set(context.graph.neighbours(nodeId));
-	let score = 0;
-	for (const [visitedId, idx] of context.visitedByFrontier) if (idx !== currentFrontier && nodeNeighbours.has(visitedId)) score++;
-	return score;
-}
-/**
 * MAZE adaptive priority function.
 *
 * Switches strategies based on local conditions:
@@ -757,7 +754,7 @@ function fluxPriority(nodeId, context, densityThreshold, bridgeThreshold) {
 	const graph = context.graph;
 	const degree = context.degree;
 	const density = localDensity(graph, nodeId);
-	const bridge = bridgeScore(nodeId, context);
+	const bridge = countCrossFrontierNeighbours(graph, nodeId, context);
 	const numFrontiers = new Set(context.visitedByFrontier.values()).size;
 	if ((numFrontiers > 0 ? bridge / numFrontiers : 0) >= bridgeThreshold) return 1 / (1 + bridge);
 	else if (density >= densityThreshold) return 1 / (degree + 1);
@@ -1406,14 +1403,13 @@ function hubPromoted(graph, source, target, config) {
 */
 function scale(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	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 { jaccard: jaccardScore } = require_utils.computeJaccard(graph, source, target);
 	const n = graph.nodeCount;
 	const m = graph.edgeCount;
 	const possibleEdges = n * (n - 1);
 	const density = possibleEdges > 0 ? (graph.directed ? m : 2 * m) / possibleEdges : 0;
 	if (density === 0) return epsilon;
-	const score = jaccard / density;
+	const score = jaccardScore / density;
 	return Math.max(epsilon, score);
 }
 //#endregion
@@ -1423,14 +1419,13 @@ function scale(graph, source, target, config) {
 */
 function skew(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	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 { jaccard: jaccardScore } = require_utils.computeJaccard(graph, source, target);
 	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;
+	const score = jaccardScore * sourceIdf * targetIdf;
 	return Math.max(epsilon, score);
 }
 //#endregion
@@ -1440,11 +1435,10 @@ function skew(graph, source, target, config) {
 */
 function span(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	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 { jaccard: jaccardScore } = require_utils.computeJaccard(graph, source, target);
 	const sourceCc = require_utils.localClusteringCoefficient(graph, source);
 	const targetCc = require_utils.localClusteringCoefficient(graph, target);
-	const score = jaccard * (1 - Math.max(sourceCc, targetCc));
+	const score = jaccardScore * (1 - Math.max(sourceCc, targetCc));
 	return Math.max(epsilon, score);
 }
 //#endregion
@@ -1454,13 +1448,12 @@ function span(graph, source, target, config) {
 */
 function etch(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	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 { jaccard: jaccardScore } = require_utils.computeJaccard(graph, source, target);
 	const edge = graph.getEdge(source, target);
-	if (edge?.type === void 0) return Math.max(epsilon, jaccard);
+	if (edge?.type === void 0) return Math.max(epsilon, jaccardScore);
 	const edgeTypeCount = require_utils.countEdgesOfType(graph, edge.type);
-	if (edgeTypeCount === 0) return Math.max(epsilon, jaccard);
-	const score = jaccard * Math.log(graph.edgeCount / edgeTypeCount);
+	if (edgeTypeCount === 0) return Math.max(epsilon, jaccardScore);
+	const score = jaccardScore * Math.log(graph.edgeCount / edgeTypeCount);
 	return Math.max(epsilon, score);
 }
 //#endregion
@@ -1470,17 +1463,16 @@ function etch(graph, source, target, config) {
 */
 function notch(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	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 { jaccard: jaccardScore } = require_utils.computeJaccard(graph, source, target);
 	const sourceNode = graph.getNode(source);
 	const targetNode = graph.getNode(target);
-	if (sourceNode?.type === void 0 || targetNode?.type === void 0) return Math.max(epsilon, jaccard);
+	if (sourceNode?.type === void 0 || targetNode?.type === void 0) return Math.max(epsilon, jaccardScore);
 	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);
+	if (sourceTypeCount === 0 || targetTypeCount === 0) return Math.max(epsilon, jaccardScore);
 	const sourceRarity = Math.log(graph.nodeCount / sourceTypeCount);
 	const targetRarity = Math.log(graph.nodeCount / targetTypeCount);
-	const score = jaccard * sourceRarity * targetRarity;
+	const score = jaccardScore * sourceRarity * targetRarity;
 	return Math.max(epsilon, score);
 }
 //#endregion
@@ -1499,13 +1491,12 @@ function notch(graph, source, target, config) {
 */
 function adaptive(graph, source, target, config) {
 	const { epsilon = 1e-10, structuralWeight = .4, degreeWeight = .3, overlapWeight = .3 } = config ?? {};
-	const structural = jaccard(graph, source, target, { epsilon });
+	const { jaccard: jaccardScore, sourceNeighbours, targetNeighbours } = require_utils.computeJaccard(graph, source, target);
+	const structural = sourceNeighbours.size === 0 && targetNeighbours.size === 0 ? 0 : Math.max(epsilon, jaccardScore);
 	const degreeComponent = adamicAdar(graph, source, target, {
 		epsilon,
 		normalise: true
 	});
-	const sourceNeighbours = require_utils.neighbourSet(graph, source, target);
-	const targetNeighbours = require_utils.neighbourSet(graph, target, source);
 	let overlap;
 	if (sourceNeighbours.size > 0 && targetNeighbours.size > 0) {
 		const { intersection } = require_utils.neighbourOverlap(sourceNeighbours, targetNeighbours);
@@ -1517,6 +1508,42 @@ function adaptive(graph, source, target, config) {
 	return Math.max(epsilon, Math.min(1, score));
 }
 //#endregion
+//#region src/ranking/baselines/utils.ts
+/**
+* Normalise a set of scored paths and return them sorted highest-first.
+*
+* All scores are normalised relative to the maximum observed score.
+* When `includeScores` is false, raw (un-normalised) scores are preserved.
+* Handles degenerate cases: empty input and all-zero scores.
+*
+* @param paths - Original paths in input order
+* @param scored - Paths paired with their computed scores
+* @param method - Method name to embed in the result
+* @param includeScores - When true, normalise scores to [0, 1]; when false, keep raw scores
+* @returns BaselineResult with ranked paths
+*/
+function normaliseAndRank(paths, scored, method, includeScores) {
+	if (scored.length === 0) return {
+		paths: [],
+		method
+	};
+	const maxScore = Math.max(...scored.map((s) => s.score));
+	if (maxScore === 0) return {
+		paths: paths.map((path) => ({
+			...path,
+			score: 0
+		})),
+		method
+	};
+	return {
+		paths: scored.map(({ path, score }) => ({
+			...path,
+			score: includeScores ? score / maxScore : score
+		})).sort((a, b) => b.score - a.score),
+		method
+	};
+}
+//#endregion
 //#region src/ranking/baselines/shortest.ts
 /**
 * Rank paths by length (shortest first).
@@ -1534,18 +1561,10 @@ function shortest(_graph, paths, config) {
 		paths: [],
 		method: "shortest"
 	};
-	const scored = paths.map((path) => ({
+	return normaliseAndRank(paths, paths.map((path) => ({
 		path,
 		score: 1 / path.nodes.length
-	}));
-	const maxScore = Math.max(...scored.map((s) => s.score));
-	return {
-		paths: scored.map(({ path, score }) => ({
-			...path,
-			score: includeScores ? score / maxScore : score / maxScore
-		})).sort((a, b) => b.score - a.score),
-		method: "shortest"
-	};
+	})), "shortest", includeScores);
 }
 //#endregion
 //#region src/ranking/baselines/degree-sum.ts
@@ -1563,29 +1582,14 @@ function degreeSum(graph, paths, config) {
 		paths: [],
 		method: "degree-sum"
 	};
-	const scored = paths.map((path) => {
+	return normaliseAndRank(paths, 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
-		})).sort((a, b) => b.score - a.score),
-		method: "degree-sum"
-	};
+	}), "degree-sum", includeScores);
 }
 //#endregion
 //#region src/ranking/baselines/widest-path.ts
@@ -1603,7 +1607,7 @@ function widestPath(graph, paths, config) {
 		paths: [],
 		method: "widest-path"
 	};
-	const scored = paths.map((path) => {
+	return normaliseAndRank(paths, paths.map((path) => {
 		if (path.nodes.length < 2) return {
 			path,
 			score: 1
@@ -1620,22 +1624,7 @@ function widestPath(graph, paths, config) {
 			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"
-	};
+	}), "widest-path", includeScores);
 }
 //#endregion
 //#region src/ranking/baselines/jaccard-arithmetic.ts
@@ -1653,7 +1642,7 @@ function jaccardArithmetic(graph, paths, config) {
 		paths: [],
 		method: "jaccard-arithmetic"
 	};
-	const scored = paths.map((path) => {
+	return normaliseAndRank(paths, paths.map((path) => {
 		if (path.nodes.length < 2) return {
 			path,
 			score: 1
@@ -1672,22 +1661,7 @@ function jaccardArithmetic(graph, paths, config) {
 			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
-		})).sort((a, b) => b.score - a.score),
-		method: "jaccard-arithmetic"
-	};
+	}), "jaccard-arithmetic", includeScores);
 }
 //#endregion
 //#region src/ranking/baselines/pagerank.ts
@@ -1748,29 +1722,14 @@ function pagerank(graph, paths, config) {
 		method: "pagerank"
 	};
 	const ranks = computePageRank(graph);
-	const scored = paths.map((path) => {
+	return normaliseAndRank(paths, 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"
-	};
+	}), "pagerank", includeScores);
 }
 //#endregion
 //#region src/ranking/baselines/betweenness.ts
@@ -1855,29 +1814,14 @@ function betweenness(graph, paths, config) {
 		method: "betweenness"
 	};
 	const bcMap = computeBetweenness(graph);
-	const scored = paths.map((path) => {
+	return normaliseAndRank(paths, 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"
-	};
+	}), "betweenness", includeScores);
 }
 //#endregion
 //#region src/ranking/baselines/katz.ts
@@ -1940,7 +1884,7 @@ function katz(graph, paths, config) {
 		paths: [],
 		method: "katz"
 	};
-	const scored = paths.map((path) => {
+	return normaliseAndRank(paths, paths.map((path) => {
 		const source = path.nodes[0];
 		const target = path.nodes[path.nodes.length - 1];
 		if (source === void 0 || target === void 0) return {
@@ -1951,22 +1895,7 @@ function katz(graph, paths, config) {
 			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"
-	};
+	}), "katz", includeScores);
 }
 //#endregion
 //#region src/ranking/baselines/communicability.ts
@@ -2028,7 +1957,7 @@ function communicability(graph, paths, config) {
 		paths: [],
 		method: "communicability"
 	};
-	const scored = paths.map((path) => {
+	return normaliseAndRank(paths, paths.map((path) => {
 		const source = path.nodes[0];
 		const target = path.nodes[path.nodes.length - 1];
 		if (source === void 0 || target === void 0) return {
@@ -2039,22 +1968,7 @@ function communicability(graph, paths, config) {
 			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"
-	};
+	}), "communicability", includeScores);
 }
 //#endregion
 //#region src/ranking/baselines/resistance-distance.ts
@@ -2171,7 +2085,7 @@ function resistanceDistance(graph, paths, config) {
 	};
 	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) => {
+	return normaliseAndRank(paths, paths.map((path) => {
 		const source = path.nodes[0];
 		const target = path.nodes[path.nodes.length - 1];
 		if (source === void 0 || target === void 0) return {
@@ -2182,22 +2096,7 @@ function resistanceDistance(graph, paths, config) {
 			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"
-	};
+	}), "resistance-distance", includeScores);
 }
 //#endregion
 //#region src/ranking/baselines/random-ranking.ts
@@ -2231,27 +2130,12 @@ function randomRanking(_graph, paths, config) {
 		paths: [],
 		method: "random"
 	};
-	const scored = paths.map((path) => {
+	return normaliseAndRank(paths, 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"
-	};
+	}), "random", includeScores);
 }
 //#endregion
 //#region src/ranking/baselines/hitting-time.ts
@@ -2490,20 +2374,14 @@ function hittingTime(graph, paths, config) {
 		};
 	});
 	const maxScore = Math.max(...scored.map((s) => s.score));
-	if (maxScore === 0 || !Number.isFinite(maxScore)) return {
+	if (!Number.isFinite(maxScore)) return {
 		paths: paths.map((path) => ({
 			...path,
 			score: 0
 		})),
 		method: "hitting-time"
 	};
-	return {
-		paths: scored.map(({ path, score }) => ({
-			...path,
-			score: includeScores ? score / maxScore : score / maxScore
-		})).sort((a, b) => b.score - a.score),
-		method: "hitting-time"
-	};
+	return normaliseAndRank(paths, scored, "hitting-time", includeScores);
 }
 //#endregion
 //#region src/extraction/ego-network.ts
@@ -3138,6 +3016,7 @@ exports.betweenness = betweenness;
 exports.bfs = require_traversal.bfs;
 exports.bfsWithPath = require_traversal.bfsWithPath;
 exports.communicability = communicability;
+exports.computeJaccard = require_utils.computeJaccard;
 exports.computeTrussNumbers = computeTrussNumbers;
 exports.cosine = cosine;
 exports.countEdgesOfType = require_utils.countEdgesOfType;