graphwise 1.3.3 → 1.4.1

package/dist/index/index.cjs

@@ -26,6 +26,8 @@ function base(graph, seeds, config) {
 	const { maxNodes = 0, maxIterations = 0, maxPaths = 0, priority = degreePriority, debug = false } = config ?? {};
 	if (seeds.length === 0) return emptyResult("base", startTime);
 	const numFrontiers = seeds.length;
+	const allVisited = /* @__PURE__ */ new Set();
+	const combinedVisited = /* @__PURE__ */ new Map();
 	const visitedByFrontier = [];
 	const predecessors = [];
 	const queues = [];
@@ -37,15 +39,16 @@ function base(graph, seeds, config) {
 		if (seed === void 0) continue;
 		const seedNode = seed.id;
 		predecessors[i]?.set(seedNode, null);
-		const seedPriority = priority(seedNode, createPriorityContext(graph, seedNode, i, visitedByFrontier, [], 0));
+		combinedVisited.set(seedNode, i);
+		allVisited.add(seedNode);
+		const seedPriority = priority(seedNode, createPriorityContext(graph, seedNode, i, combinedVisited, allVisited, [], 0));
 		queues[i]?.push({
 			nodeId: seedNode,
 			frontierIndex: i,
 			predecessor: null
 		}, seedPriority);
 	}
-	const allVisited = /* @__PURE__ */ new Set();
-	const sampledEdges = /* @__PURE__ */ new Set();
+	const sampledEdgeMap = /* @__PURE__ */ new Map();
 	const discoveredPaths = [];
 	let iterations = 0;
 	let edgesTraversed = 0;
@@ -90,6 +93,7 @@ function base(graph, seeds, config) {
 		const frontierVisited = visitedByFrontier[activeFrontier];
 		if (frontierVisited === void 0 || frontierVisited.has(nodeId)) continue;
 		frontierVisited.set(nodeId, activeFrontier);
+		combinedVisited.set(nodeId, activeFrontier);
 		if (predecessor !== null) {
 			const predMap = predecessors[activeFrontier];
 			if (predMap !== void 0) predMap.set(nodeId, predecessor);
@@ -111,11 +115,16 @@ function base(graph, seeds, config) {
 		const neighbours = graph.neighbours(nodeId);
 		for (const neighbour of neighbours) {
 			edgesTraversed++;
-			const edgeKey = nodeId < neighbour ? `${nodeId}::${neighbour}` : `${neighbour}::${nodeId}`;
-			sampledEdges.add(edgeKey);
+			const [s, t] = nodeId < neighbour ? [nodeId, neighbour] : [neighbour, nodeId];
+			let targets = sampledEdgeMap.get(s);
+			if (targets === void 0) {
+				targets = /* @__PURE__ */ new Set();
+				sampledEdgeMap.set(s, targets);
+			}
+			targets.add(t);
 			const frontierVisited = visitedByFrontier[activeFrontier];
 			if (frontierVisited === void 0 || frontierVisited.has(neighbour)) continue;
-			const neighbourPriority = priority(neighbour, createPriorityContext(graph, neighbour, activeFrontier, visitedByFrontier, discoveredPaths, iterations + 1));
+			const neighbourPriority = priority(neighbour, createPriorityContext(graph, neighbour, activeFrontier, combinedVisited, allVisited, discoveredPaths, iterations + 1));
 			queue.push({
 				nodeId: neighbour,
 				frontierIndex: activeFrontier,
@@ -127,14 +136,7 @@ function base(graph, seeds, config) {
 	const endTime = performance.now();
 	const visitedPerFrontier = visitedByFrontier.map((m) => new Set(m.keys()));
 	const edgeTuples = /* @__PURE__ */ new Set();
-	for (const edgeKey of sampledEdges) {
-		const parts = edgeKey.split("::");
-		if (parts.length === 2) {
-			const source = parts[0];
-			const target = parts[1];
-			if (source !== void 0 && target !== void 0) edgeTuples.add([source, target]);
-		}
-	}
+	for (const [source, targets] of sampledEdgeMap) for (const target of targets) edgeTuples.add([source, target]);
 	return {
 		paths: discoveredPaths,
 		sampledNodes: allVisited,
@@ -154,10 +156,7 @@ function base(graph, seeds, config) {
 /**
 * Create priority context for a node.
 */
-function createPriorityContext(graph, nodeId, frontierIndex, visitedByFrontier, discoveredPaths, iteration) {
-	const combinedVisited = /* @__PURE__ */ new Map();
-	for (const frontierMap of visitedByFrontier) for (const [id, idx] of frontierMap) combinedVisited.set(id, idx);
-	const allVisited = new Set(combinedVisited.keys());
+function createPriorityContext(graph, nodeId, frontierIndex, combinedVisited, allVisited, discoveredPaths, iteration) {
 	return {
 		graph,
 		degree: graph.degree(nodeId),
@@ -236,7 +235,7 @@ function emptyResult(algorithm, startTime) {
 */
 function dome(graph, seeds, config) {
 	const domePriority = (nodeId, context) => {
-		return graph.degree(nodeId);
+		return context.degree;
 	};
 	return base(graph, seeds, {
 		...config,
@@ -248,7 +247,7 @@ function dome(graph, seeds, config) {
 */
 function domeHighDegree(graph, seeds, config) {
 	const domePriority = (nodeId, context) => {
-		return -graph.degree(nodeId);
+		return -context.degree;
 	};
 	return base(graph, seeds, {
 		...config,
@@ -257,23 +256,26 @@ function domeHighDegree(graph, seeds, config) {
 }
 //#endregion
 //#region src/expansion/edge.ts
+var EPSILON$1 = 1e-10;
 /**
-* EDGE priority function.
-*
-* Priority = degree(source) + degree(target)
-* Lower values = higher priority (explored first)
+* Priority function using local type entropy.
+* Lower values = higher priority (expanded first).
 */
 function edgePriority(nodeId, context) {
 	const graph = context.graph;
-	let totalDegree = context.degree;
-	for (const neighbour of graph.neighbours(nodeId)) totalDegree += graph.degree(neighbour);
-	return totalDegree;
+	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 algorithm.
+* Run EDGE expansion (Entropy-Driven Graph Expansion).
 *
-* Expands from seeds prioritising low-degree edges first.
-* Useful for avoiding hubs and exploring sparse regions.
+* Discovers paths by prioritising nodes with diverse neighbour types,
+* deferring nodes with homogeneous neighbourhoods.
 *
 * @param graph - Source graph
 * @param seeds - Seed nodes for expansion
@@ -287,6 +289,122 @@ function edge(graph, seeds, config) {
 	});
 }
 //#endregion
+//#region src/expansion/hae.ts
+var EPSILON = 1e-10;
+/**
+* Default type mapper - uses node.type property.
+*/
+function defaultTypeMapper(node) {
+	return node.type ?? "default";
+}
+/**
+* Create a priority function using the given type mapper.
+*/
+function createHAEPriority(typeMapper) {
+	return function haePriority(nodeId, context) {
+		const graph = context.graph;
+		const neighbours = graph.neighbours(nodeId);
+		const neighbourTypes = [];
+		for (const neighbour of neighbours) {
+			const node = graph.getNode(neighbour);
+			if (node !== void 0) neighbourTypes.push(typeMapper(node));
+		}
+		return 1 / (require_utils.localTypeEntropy(neighbourTypes) + EPSILON) * Math.log(context.degree + 1);
+	};
+}
+/**
+* Run HAE expansion (Heterogeneity-Aware Expansion).
+*
+* Discovers paths by prioritising nodes with diverse neighbour types,
+* using a custom type mapper for flexible type extraction.
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - HAE configuration with optional typeMapper
+* @returns Expansion result with discovered paths
+*/
+function hae(graph, seeds, config) {
+	const typeMapper = config?.typeMapper ?? defaultTypeMapper;
+	return base(graph, seeds, {
+		...config,
+		priority: createHAEPriority(typeMapper)
+	});
+}
+//#endregion
+//#region src/expansion/pipe.ts
+/**
+* Priority function using path potential.
+* Lower values = higher priority (expanded first).
+*
+* Path potential measures how many of a node's neighbours have been
+* visited by OTHER frontiers (not the current frontier).
+*/
+function pipePriority(nodeId, context) {
+	const neighbours = context.graph.neighbours(nodeId);
+	let pathPotential = 0;
+	for (const neighbour of neighbours) {
+		const visitedBy = context.visitedByFrontier.get(neighbour);
+		if (visitedBy !== void 0 && visitedBy !== context.frontierIndex) pathPotential++;
+	}
+	return context.degree / (1 + pathPotential);
+}
+/**
+* Run PIPE expansion (Path-Potential Informed Priority Expansion).
+*
+* Discovers paths by prioritising nodes that bridge multiple frontiers,
+* identifying connecting points between seed regions.
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration
+* @returns Expansion result with discovered paths
+*/
+function pipe(graph, seeds, config) {
+	return base(graph, seeds, {
+		...config,
+		priority: pipePriority
+	});
+}
+//#endregion
+//#region src/expansion/sage.ts
+/**
+* Run SAGE expansion algorithm.
+*
+* Salience-aware multi-frontier expansion with two phases:
+* - Phase 1: Degree-based priority (early exploration)
+* - Phase 2: Salience feedback (path-aware frontier steering)
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration
+* @returns Expansion result with discovered paths
+*/
+function sage(graph, seeds, config) {
+	const salienceCounts = /* @__PURE__ */ new Map();
+	let inPhase2 = false;
+	let lastPathCount = 0;
+	/**
+	* SAGE priority function with phase transition logic.
+	*/
+	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 (!inPhase2) return Math.log(context.degree + 1);
+		return -((salienceCounts.get(nodeId) ?? 0) * 1e3 - context.degree);
+	}
+	return base(graph, seeds, {
+		...config,
+		priority: sagePriority
+	});
+}
+//#endregion
 //#region src/ranking/mi/jaccard.ts
 /**
 * Compute Jaccard similarity between neighbourhoods of two nodes.
@@ -305,14 +423,153 @@ function jaccard(graph, source, target, config) {
 	return Math.max(epsilon, score);
 }
 //#endregion
-//#region src/expansion/hae.ts
+//#region src/expansion/reach.ts
 /**
-* HAE priority function.
+* Run REACH expansion algorithm.
+*
+* Mutual information-aware multi-frontier expansion with two phases:
+* - Phase 1: Degree-based priority (early exploration)
+* - Phase 2: Structural similarity feedback (MI-guided frontier steering)
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration
+* @returns Expansion result with discovered paths
+*/
+function reach(graph, seeds, config) {
+	let inPhase2 = false;
+	const jaccardCache = /* @__PURE__ */ new Map();
+	/**
+	* Compute Jaccard similarity with caching.
+	*
+	* Exploits symmetry of Jaccard (J(A,B) = J(B,A)) to reduce
+	* duplicate computations when the same pair appears in multiple
+	* discovered paths. Key format ensures consistent ordering.
+	*/
+	function cachedJaccard(source, target) {
+		const key = source < target ? `${source}::${target}` : `${target}::${source}`;
+		let score = jaccardCache.get(key);
+		if (score === void 0) {
+			score = jaccard(graph, source, target);
+			jaccardCache.set(key, score);
+		}
+		return score;
+	}
+	/**
+	* REACH priority function with MI estimation.
+	*/
+	function reachPriority(nodeId, context) {
+		if (context.discoveredPaths.length > 0 && !inPhase2) inPhase2 = true;
+		if (!inPhase2) return Math.log(context.degree + 1);
+		let totalMI = 0;
+		let endpointCount = 0;
+		for (const path of context.discoveredPaths) {
+			const fromNodeId = path.fromSeed.id;
+			const toNodeId = path.toSeed.id;
+			totalMI += cachedJaccard(nodeId, fromNodeId);
+			totalMI += cachedJaccard(nodeId, toNodeId);
+			endpointCount += 2;
+		}
+		const miHat = endpointCount > 0 ? totalMI / endpointCount : 0;
+		return Math.log(context.degree + 1) * (1 - miHat);
+	}
+	return base(graph, seeds, {
+		...config,
+		priority: reachPriority
+	});
+}
+//#endregion
+//#region src/expansion/maze.ts
+/** Default threshold for switching to phase 2 (after M paths) */
+var DEFAULT_PHASE2_THRESHOLD = 1;
+/** Salience weighting factor */
+var SALIENCE_WEIGHT = 1e3;
+/**
+* Run MAZE expansion algorithm.
+*
+* Multi-phase expansion combining path potential and salience with
+* adaptive frontier steering.
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration
+* @returns Expansion result with discovered paths
+*/
+function maze(graph, seeds, config) {
+	const salienceCounts = /* @__PURE__ */ new Map();
+	let inPhase2 = false;
+	let lastPathCount = 0;
+	/**
+	* MAZE priority function with path potential and salience feedback.
+	*/
+	function mazePriority(nodeId, context) {
+		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;
+		}
+		const nodeNeighbours = graph.neighbours(nodeId);
+		let pathPotential = 0;
+		for (const neighbour of nodeNeighbours) {
+			const visitedBy = context.visitedByFrontier.get(neighbour);
+			if (visitedBy !== void 0 && visitedBy !== context.frontierIndex) pathPotential++;
+		}
+		if (!inPhase2) return context.degree / (1 + pathPotential);
+		const salience = salienceCounts.get(nodeId) ?? 0;
+		return context.degree / (1 + pathPotential) * (1 / (1 + SALIENCE_WEIGHT * salience));
+	}
+	return base(graph, seeds, {
+		...config,
+		priority: mazePriority
+	});
+}
+//#endregion
+//#region src/expansion/tide.ts
+/**
+* TIDE priority function.
+*
+* Priority = degree(source) + degree(target)
+* Lower values = higher priority (explored first)
+*/
+function tidePriority(nodeId, context) {
+	const graph = context.graph;
+	let totalDegree = context.degree;
+	for (const neighbour of graph.neighbours(nodeId)) totalDegree += graph.degree(neighbour);
+	return totalDegree;
+}
+/**
+* Run TIDE expansion algorithm.
+*
+* Expands from seeds prioritising low-degree edges first.
+* Useful for avoiding hubs and exploring sparse regions.
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration
+* @returns Expansion result with discovered paths
+*/
+function tide(graph, seeds, config) {
+	return base(graph, seeds, {
+		...config,
+		priority: tidePriority
+	});
+}
+//#endregion
+//#region src/expansion/lace.ts
+/**
+* LACE priority function.
 *
 * Priority = 1 - MI(source, neighbour)
 * Higher MI = lower priority value = explored first
 */
-function haePriority(nodeId, context, mi) {
+function lacePriority(nodeId, context, mi) {
 	const graph = context.graph;
 	const frontierIndex = context.frontierIndex;
 	let maxMi = 0;
@@ -327,7 +584,7 @@ function haePriority(nodeId, context, mi) {
 	return 1 - (count > 0 ? totalMi / count : 0);
 }
 /**
-* Run HAE expansion algorithm.
+* Run LACE expansion algorithm.
 *
 * Expands from seeds prioritising high-MI edges.
 * Useful for finding paths with strong semantic associations.
@@ -337,16 +594,16 @@ function haePriority(nodeId, context, mi) {
 * @param config - Expansion configuration with MI function
 * @returns Expansion result with discovered paths
 */
-function hae(graph, seeds, config) {
+function lace(graph, seeds, config) {
 	const { mi = jaccard, ...restConfig } = config ?? {};
-	const priority = (nodeId, context) => haePriority(nodeId, context, mi);
+	const priority = (nodeId, context) => lacePriority(nodeId, context, mi);
 	return base(graph, seeds, {
 		...restConfig,
 		priority
 	});
 }
 //#endregion
-//#region src/expansion/pipe.ts
+//#region src/expansion/warp.ts
 /**
 * PIPE priority function.
 *
@@ -354,7 +611,7 @@ function hae(graph, seeds, config) {
 * Bridge score = neighbourhood overlap with other frontiers
 * Higher bridge score = more likely to be on paths = explored first
 */
-function pipePriority(nodeId, context) {
+function warpPriority(nodeId, context) {
 	const graph = context.graph;
 	const currentFrontier = context.frontierIndex;
 	const nodeNeighbours = new Set(graph.neighbours(nodeId));
@@ -364,7 +621,7 @@ function pipePriority(nodeId, context) {
 	return 1 / (1 + bridgeScore);
 }
 /**
-* Run PIPE expansion algorithm.
+* Run WARP expansion algorithm.
 *
 * Expands from seeds prioritising bridge nodes.
 * Useful for finding paths through structurally important nodes.
@@ -374,14 +631,14 @@ function pipePriority(nodeId, context) {
 * @param config - Expansion configuration
 * @returns Expansion result with discovered paths
 */
-function pipe(graph, seeds, config) {
+function warp(graph, seeds, config) {
 	return base(graph, seeds, {
 		...config,
-		priority: pipePriority
+		priority: warpPriority
 	});
 }
 //#endregion
-//#region src/expansion/sage.ts
+//#region src/expansion/fuse.ts
 /**
 * SAGE priority function.
 *
@@ -389,7 +646,7 @@ function pipe(graph, seeds, config) {
 * Priority = (1 - w) * degree + w * (1 - avg_salience)
 * Lower values = higher priority
 */
-function sagePriority(nodeId, context, mi, salienceWeight) {
+function fusePriority(nodeId, context, mi, salienceWeight) {
 	const graph = context.graph;
 	const degree = context.degree;
 	const frontierIndex = context.frontierIndex;
@@ -403,7 +660,7 @@ function sagePriority(nodeId, context, mi, salienceWeight) {
 	return (1 - salienceWeight) * degree + salienceWeight * (1 - avgSalience);
 }
 /**
-* Run SAGE expansion algorithm.
+* Run FUSE expansion algorithm.
 *
 * Combines structural exploration with semantic salience.
 * Useful for finding paths that are both short and semantically meaningful.
@@ -413,22 +670,22 @@ function sagePriority(nodeId, context, mi, salienceWeight) {
 * @param config - Expansion configuration with MI function
 * @returns Expansion result with discovered paths
 */
-function sage(graph, seeds, config) {
+function fuse(graph, seeds, config) {
 	const { mi = jaccard, salienceWeight = .5, ...restConfig } = config ?? {};
-	const priority = (nodeId, context) => sagePriority(nodeId, context, mi, salienceWeight);
+	const priority = (nodeId, context) => fusePriority(nodeId, context, mi, salienceWeight);
 	return base(graph, seeds, {
 		...restConfig,
 		priority
 	});
 }
 //#endregion
-//#region src/expansion/reach.ts
+//#region src/expansion/sift.ts
 /**
 * REACH priority function (phase 2).
 *
 * Uses learned MI threshold to prioritise high-MI edges.
 */
-function reachPriority(nodeId, context, mi, miThreshold) {
+function siftPriority(nodeId, context, mi, miThreshold) {
 	const graph = context.graph;
 	const frontierIndex = context.frontierIndex;
 	let totalMi = 0;
@@ -442,7 +699,7 @@ function reachPriority(nodeId, context, mi, miThreshold) {
 	else return context.degree + 100;
 }
 /**
-* Run REACH expansion algorithm.
+* Run SIFT expansion algorithm.
 *
 * Two-phase adaptive expansion that learns MI thresholds
 * from initial sampling, then uses them for guided expansion.
@@ -452,16 +709,16 @@ function reachPriority(nodeId, context, mi, miThreshold) {
 * @param config - Expansion configuration
 * @returns Expansion result with discovered paths
 */
-function reach(graph, seeds, config) {
+function sift(graph, seeds, config) {
 	const { mi = jaccard, miThreshold = .25, ...restConfig } = config ?? {};
-	const priority = (nodeId, context) => reachPriority(nodeId, context, mi, miThreshold);
+	const priority = (nodeId, context) => siftPriority(nodeId, context, mi, miThreshold);
 	return base(graph, seeds, {
 		...restConfig,
 		priority
 	});
 }
 //#endregion
-//#region src/expansion/maze.ts
+//#region src/expansion/flux.ts
 /**
 * Compute local density around a node.
 */
@@ -496,7 +753,7 @@ function bridgeScore(nodeId, context) {
 * - Low density + low bridge: DOME mode
 * - High bridge score: PIPE mode
 */
-function mazePriority(nodeId, context, densityThreshold, bridgeThreshold) {
+function fluxPriority(nodeId, context, densityThreshold, bridgeThreshold) {
 	const graph = context.graph;
 	const degree = context.degree;
 	const density = localDensity(graph, nodeId);
@@ -507,7 +764,7 @@ function mazePriority(nodeId, context, densityThreshold, bridgeThreshold) {
 	else return degree;
 }
 /**
-* Run MAZE expansion algorithm.
+* Run FLUX expansion algorithm.
 *
 * Adaptively switches between expansion strategies based on
 * local graph structure. Useful for heterogeneous graphs
@@ -518,9 +775,9 @@ function mazePriority(nodeId, context, densityThreshold, bridgeThreshold) {
 * @param config - Expansion configuration
 * @returns Expansion result with discovered paths
 */
-function maze(graph, seeds, config) {
+function flux(graph, seeds, config) {
 	const { densityThreshold = .5, bridgeThreshold = .3, ...restConfig } = config ?? {};
-	const priority = (nodeId, context) => mazePriority(nodeId, context, densityThreshold, bridgeThreshold);
+	const priority = (nodeId, context) => fluxPriority(nodeId, context, densityThreshold, bridgeThreshold);
 	return base(graph, seeds, {
 		...restConfig,
 		priority
@@ -704,8 +961,8 @@ function scale(graph, source, target, config) {
 	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;
+	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;
 	return Math.max(epsilon, score);
@@ -876,7 +1133,7 @@ function degreeSum(graph, paths, config) {
 	return {
 		paths: scored.map(({ path, score }) => ({
 			...path,
-			score: includeScores ? score / maxScore : score / maxScore
+			score: includeScores ? score / maxScore : score
 		})).sort((a, b) => b.score - a.score),
 		method: "degree-sum"
 	};
@@ -978,7 +1235,7 @@ function jaccardArithmetic(graph, paths, config) {
 	return {
 		paths: scored.map(({ path, score }) => ({
 			...path,
-			score: includeScores ? score / maxScore : score / maxScore
+			score: includeScores ? score / maxScore : score
 		})).sort((a, b) => b.score - a.score),
 		method: "jaccard-arithmetic"
 	};
@@ -2202,7 +2459,9 @@ exports.extractInducedSubgraph = extractInducedSubgraph;
 exports.extractKCore = extractKCore;
 exports.extractKTruss = extractKTruss;
 exports.filterSubgraph = filterSubgraph;
+exports.flux = flux;
 exports.frontierBalanced = frontierBalanced;
+exports.fuse = fuse;
 exports.getGPUContext = require_gpu.getGPUContext;
 exports.getMotifName = getMotifName;
 exports.graphToCSR = require_gpu.graphToCSR;
@@ -2212,6 +2471,7 @@ exports.isWebGPUAvailable = require_gpu.isWebGPUAvailable;
 exports.jaccard = jaccard;
 exports.jaccardArithmetic = jaccardArithmetic;
 exports.katz = katz;
+exports.lace = lace;
 exports.localClusteringCoefficient = require_utils.localClusteringCoefficient;
 exports.localTypeEntropy = require_utils.localTypeEntropy;
 exports.maze = maze;
@@ -2235,10 +2495,13 @@ exports.sage = sage;
 exports.scale = scale;
 exports.shannonEntropy = require_utils.shannonEntropy;
 exports.shortest = shortest;
+exports.sift = sift;
 exports.skew = skew;
 exports.span = span;
 exports.standardBfs = standardBfs;
 exports.stratified = require_seeds.stratified;
+exports.tide = tide;
+exports.warp = warp;
 exports.widestPath = widestPath;
 
 //# sourceMappingURL=index.cjs.map