graphwise 1.6.0 → 1.8.0

package/dist/index/index.js

@@ -5,22 +5,134 @@ import { n as miniBatchKMeans, r as normaliseFeatures, t as _computeMean } from
 import { approximateClusteringCoefficient, batchClusteringCoefficients, computeJaccard, countEdgesOfType, countNodesOfType, entropyFromCounts, localClusteringCoefficient, localTypeEntropy, neighbourIntersection, neighbourOverlap, neighbourSet, normalisedEntropy, shannonEntropy } from "../utils/index.js";
 import { grasp, stratified } from "../seeds/index.js";
 import { GPUContext, GPUNotAvailableError, assertWebGPUAvailable, createGPUContext, createResultBuffer, csrToGPUBuffers, detectWebGPU, getGPUContext, graphToCSR, isWebGPUAvailable, readBufferToCPU } from "../gpu/index.js";
-//#region src/expansion/base.ts
+import { collectAsyncIterable, defaultYieldStrategy, opDegree, opGetEdge, opGetNode, opHasNode, opNeighbours, opProgress, opYield, resolveAsyncOp, resolveSyncOp, runAsync, runSync } from "../async/index.js";
+//#region src/expansion/base-helpers.ts
 /**
-* Default priority function - degree-ordered (DOME).
+* Check whether expansion should continue given current progress.
+*
+* Returns shouldContinue=false as soon as any configured limit is reached,
+* along with the appropriate termination reason.
+*
+* @param iterations - Number of iterations completed so far
+* @param nodesVisited - Number of distinct nodes visited so far
+* @param pathsFound - Number of paths discovered so far
+* @param limits - Configured expansion limits (0 = unlimited)
+* @returns Whether to continue and the termination reason if stopping
+*/
+function continueExpansion(iterations, nodesVisited, pathsFound, limits) {
+	if (limits.maxIterations > 0 && iterations >= limits.maxIterations) return {
+		shouldContinue: false,
+		termination: "limit"
+	};
+	if (limits.maxNodes > 0 && nodesVisited >= limits.maxNodes) return {
+		shouldContinue: false,
+		termination: "limit"
+	};
+	if (limits.maxPaths > 0 && pathsFound >= limits.maxPaths) return {
+		shouldContinue: false,
+		termination: "limit"
+	};
+	return {
+		shouldContinue: true,
+		termination: "exhausted"
+	};
+}
+/**
+* Reconstruct path from collision point.
+*
+* Traces backwards through the predecessor maps of both frontiers from the
+* collision node, then concatenates the two halves to form the full path.
+*
+* @param collisionNode - The node where the two frontiers met
+* @param frontierA - Index of the first frontier
+* @param frontierB - Index of the second frontier
+* @param predecessors - Predecessor maps, one per frontier
+* @param seeds - Seed nodes, one per frontier
+* @returns The reconstructed path, or null if seeds are missing
+*/
+function reconstructPath$1(collisionNode, frontierA, frontierB, predecessors, seeds) {
+	const pathA = [collisionNode];
+	const predA = predecessors[frontierA];
+	if (predA !== void 0) {
+		let node = collisionNode;
+		let next = predA.get(node);
+		while (next !== null && next !== void 0) {
+			node = next;
+			pathA.unshift(node);
+			next = predA.get(node);
+		}
+	}
+	const pathB = [];
+	const predB = predecessors[frontierB];
+	if (predB !== void 0) {
+		let node = collisionNode;
+		let next = predB.get(node);
+		while (next !== null && next !== void 0) {
+			node = next;
+			pathB.push(node);
+			next = predB.get(node);
+		}
+	}
+	const fullPath = [...pathA, ...pathB];
+	const seedA = seeds[frontierA];
+	const seedB = seeds[frontierB];
+	if (seedA === void 0 || seedB === void 0) return null;
+	return {
+		fromSeed: seedA,
+		toSeed: seedB,
+		nodes: fullPath
+	};
+}
+/**
+* Create an empty expansion result for early termination (e.g. no seeds given).
+*
+* @param algorithm - Name of the algorithm producing this result
+* @param startTime - performance.now() timestamp taken before the algorithm began
+* @returns An ExpansionResult with zero paths and zero stats
+*/
+function emptyResult$2(algorithm, startTime) {
+	return {
+		paths: [],
+		sampledNodes: /* @__PURE__ */ new Set(),
+		sampledEdges: /* @__PURE__ */ new Set(),
+		visitedPerFrontier: [],
+		stats: {
+			iterations: 0,
+			nodesVisited: 0,
+			edgesTraversed: 0,
+			pathsFound: 0,
+			durationMs: performance.now() - startTime,
+			algorithm,
+			termination: "exhausted"
+		}
+	};
+}
+//#endregion
+//#region src/expansion/base-core.ts
+/**
+* Default priority function — degree-ordered (DOME).
+*
+* Lower degree = higher priority, so sparse nodes are explored before hubs.
 */
 function degreePriority(_nodeId, context) {
 	return context.degree;
 }
 /**
-* Run BASE expansion algorithm.
+* Generator core of the BASE expansion algorithm.
 *
-* @param graph - Source graph
+* Yields GraphOp objects to request graph data, allowing the caller to
+* provide a sync or async runner. The optional `graphRef` parameter is
+* required when the priority function accesses `context.graph` — it is
+* populated in sync mode by `base()`. In async mode (Phase 4+), a proxy
+* graph may be supplied instead.
+*
+* @param graphMeta - Immutable graph metadata (directed, nodeCount, edgeCount)
 * @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
+* @param config - Expansion configuration (priority, limits, debug)
+* @param graphRef - Optional real graph reference for context.graph in priority functions
+* @returns An ExpansionResult with all discovered paths and statistics
 */
-function base(graph, seeds, config) {
+function* baseCore(graphMeta, seeds, config, graphRef) {
 	const startTime = performance.now();
 	const { maxNodes = 0, maxIterations = 0, maxPaths = 0, priority = degreePriority, debug = false } = config ?? {};
 	if (seeds.length === 0) return emptyResult$2("base", startTime);
@@ -40,7 +152,8 @@ function base(graph, seeds, config) {
 		predecessors[i]?.set(seedNode, null);
 		combinedVisited.set(seedNode, i);
 		allVisited.add(seedNode);
-		const seedPriority = priority(seedNode, createPriorityContext(graph, seedNode, i, combinedVisited, allVisited, [], 0));
+		const seedDegree = yield* opDegree(seedNode);
+		const seedPriority = priority(seedNode, buildPriorityContext(seedNode, i, combinedVisited, allVisited, [], 0, seedDegree, graphRef));
 		queues[i]?.push({
 			nodeId: seedNode,
 			frontierIndex: i,
@@ -52,22 +165,17 @@ function base(graph, seeds, config) {
 	let iterations = 0;
 	let edgesTraversed = 0;
 	let termination = "exhausted";
-	const continueExpansion = () => {
-		if (maxIterations > 0 && iterations >= maxIterations) {
-			termination = "limit";
-			return false;
-		}
-		if (maxNodes > 0 && allVisited.size >= maxNodes) {
-			termination = "limit";
-			return false;
-		}
-		if (maxPaths > 0 && discoveredPaths.length >= maxPaths) {
-			termination = "limit";
-			return false;
-		}
-		return true;
+	const limits = {
+		maxIterations,
+		maxNodes,
+		maxPaths
 	};
-	while (continueExpansion()) {
+	for (;;) {
+		const check = continueExpansion(iterations, allVisited.size, discoveredPaths.length, limits);
+		if (!check.shouldContinue) {
+			termination = check.termination;
+			break;
+		}
 		let lowestPriority = Number.POSITIVE_INFINITY;
 		let activeFrontier = -1;
 		for (let i = 0; i < numFrontiers; i++) {
@@ -111,7 +219,7 @@ function base(graph, seeds, config) {
 				}
 			}
 		}
-		const neighbours = graph.neighbours(nodeId);
+		const neighbours = yield* opNeighbours(nodeId);
 		for (const neighbour of neighbours) {
 			edgesTraversed++;
 			const [s, t] = nodeId < neighbour ? [nodeId, neighbour] : [neighbour, nodeId];
@@ -121,9 +229,10 @@ function base(graph, seeds, config) {
 				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, combinedVisited, allVisited, discoveredPaths, iterations + 1));
+			const fv = visitedByFrontier[activeFrontier];
+			if (fv === void 0 || fv.has(neighbour)) continue;
+			const neighbourDegree = yield* opDegree(neighbour);
+			const neighbourPriority = priority(neighbour, buildPriorityContext(neighbour, activeFrontier, combinedVisited, allVisited, discoveredPaths, iterations + 1, neighbourDegree, graphRef));
 			queue.push({
 				nodeId: neighbour,
 				frontierIndex: activeFrontier,
@@ -153,12 +262,50 @@ function base(graph, seeds, config) {
 	};
 }
 /**
-* Create priority context for a node.
+* Create a sentinel ReadableGraph that throws if any member is accessed.
+*
+* Used in async mode when no graphRef is provided. Gives a clear error
+* message rather than silently returning incorrect results if a priority
+* function attempts to access `context.graph` before Phase 4b introduces
+* a real async proxy.
 */
-function createPriorityContext(graph, nodeId, frontierIndex, combinedVisited, allVisited, discoveredPaths, iteration) {
+function makeNoGraphSentinel() {
+	const msg = "Priority function accessed context.graph in async mode without a graph proxy. Pass a graphRef or use a priority function that does not access context.graph.";
+	const fail = () => {
+		throw new Error(msg);
+	};
 	return {
-		graph,
-		degree: graph.degree(nodeId),
+		get directed() {
+			return fail();
+		},
+		get nodeCount() {
+			return fail();
+		},
+		get edgeCount() {
+			return fail();
+		},
+		hasNode: fail,
+		getNode: fail,
+		nodeIds: fail,
+		neighbours: fail,
+		degree: fail,
+		getEdge: fail,
+		edges: fail
+	};
+}
+/**
+* Build a PriorityContext for a node using a pre-fetched degree.
+*
+* When `graphRef` is provided (sync mode), it is used as `context.graph` so
+* priority functions can access the graph directly. When it is absent (async
+* mode), a Proxy is used in its place that throws a clear error if any
+* property is accessed — this prevents silent failures until Phase 4b
+* introduces a real async proxy graph.
+*/
+function buildPriorityContext(_nodeId, frontierIndex, combinedVisited, allVisited, discoveredPaths, iteration, degree, graphRef) {
+	return {
+		graph: graphRef ?? makeNoGraphSentinel(),
+		degree,
 		frontierIndex,
 		visitedByFrontier: combinedVisited,
 		allVisited,
@@ -166,65 +313,71 @@ function createPriorityContext(graph, nodeId, frontierIndex, combinedVisited, al
 		iteration
 	};
 }
+//#endregion
+//#region src/expansion/base.ts
 /**
-* Reconstruct path from collision point.
+* Run BASE expansion synchronously.
+*
+* Delegates to baseCore + runSync. Behaviour is identical to the previous
+* direct implementation — all existing callers are unaffected.
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration
+* @returns Expansion result with discovered paths
 */
-function reconstructPath$1(collisionNode, frontierA, frontierB, predecessors, seeds) {
-	const pathA = [collisionNode];
-	const predA = predecessors[frontierA];
-	if (predA !== void 0) {
-		let node = collisionNode;
-		let next = predA.get(node);
-		while (next !== null && next !== void 0) {
-			node = next;
-			pathA.unshift(node);
-			next = predA.get(node);
-		}
-	}
-	const pathB = [];
-	const predB = predecessors[frontierB];
-	if (predB !== void 0) {
-		let node = collisionNode;
-		let next = predB.get(node);
-		while (next !== null && next !== void 0) {
-			node = next;
-			pathB.push(node);
-			next = predB.get(node);
-		}
-	}
-	const fullPath = [...pathA, ...pathB];
-	const seedA = seeds[frontierA];
-	const seedB = seeds[frontierB];
-	if (seedA === void 0 || seedB === void 0) return null;
-	return {
-		fromSeed: seedA,
-		toSeed: seedB,
-		nodes: fullPath
-	};
+function base(graph, seeds, config) {
+	return runSync(baseCore({
+		directed: graph.directed,
+		nodeCount: graph.nodeCount,
+		edgeCount: graph.edgeCount
+	}, seeds, config, graph), graph);
 }
 /**
-* Create an empty result for early termination.
-*/
-function emptyResult$2(algorithm, startTime) {
-	return {
-		paths: [],
-		sampledNodes: /* @__PURE__ */ new Set(),
-		sampledEdges: /* @__PURE__ */ new Set(),
-		visitedPerFrontier: [],
-		stats: {
-			iterations: 0,
-			nodesVisited: 0,
-			edgesTraversed: 0,
-			pathsFound: 0,
-			durationMs: performance.now() - startTime,
-			algorithm,
-			termination: "exhausted"
-		}
-	};
+* Run BASE expansion asynchronously.
+*
+* Delegates to baseCore + runAsync. Supports:
+* - Cancellation via AbortSignal (config.signal)
+* - Progress callbacks (config.onProgress)
+* - Custom cooperative yield strategies (config.yieldStrategy)
+*
+* Note: priority functions that access `context.graph` are not supported in
+* async mode without a graph proxy (Phase 4b). The default degree-based
+* priority (DOME) does not access context.graph and works correctly.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function baseAsync(graph, seeds, config) {
+	const [nodeCount, edgeCount] = await Promise.all([graph.nodeCount, graph.edgeCount]);
+	const gen = baseCore({
+		directed: graph.directed,
+		nodeCount,
+		edgeCount
+	}, seeds, config);
+	const runnerOptions = {};
+	if (config?.signal !== void 0) runnerOptions.signal = config.signal;
+	if (config?.onProgress !== void 0) runnerOptions.onProgress = config.onProgress;
+	if (config?.yieldStrategy !== void 0) runnerOptions.yieldStrategy = config.yieldStrategy;
+	return runAsync(gen, graph, runnerOptions);
 }
 //#endregion
 //#region src/expansion/dome.ts
 /**
+* DOME priority: lower degree is expanded first.
+*/
+function domePriority(_nodeId, context) {
+	return context.degree;
+}
+/**
+* DOME high-degree priority: negate degree to prioritise high-degree nodes.
+*/
+function domeHighDegreePriority(_nodeId, context) {
+	return -context.degree;
+}
+/**
 * Run DOME expansion (degree-ordered).
 *
 * @param graph - Source graph
@@ -233,24 +386,46 @@ function emptyResult$2(algorithm, startTime) {
 * @returns Expansion result with discovered paths
 */
 function dome(graph, seeds, config) {
-	const domePriority = (nodeId, context) => {
-		return context.degree;
-	};
 	return base(graph, seeds, {
 		...config,
 		priority: domePriority
 	});
 }
 /**
+* Run DOME expansion asynchronously (degree-ordered).
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function domeAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: domePriority
+	});
+}
+/**
 * DOME with reverse priority (high degree first).
 */
 function domeHighDegree(graph, seeds, config) {
-	const domePriority = (nodeId, context) => {
-		return -context.degree;
-	};
 	return base(graph, seeds, {
 		...config,
-		priority: domePriority
+		priority: domeHighDegreePriority
+	});
+}
+/**
+* Run DOME high-degree expansion asynchronously (high degree first).
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function domeHighDegreeAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: domeHighDegreePriority
 	});
 }
 //#endregion
@@ -295,6 +470,26 @@ function hae(graph, seeds, config) {
 		priority: createHAEPriority(typeMapper)
 	});
 }
+/**
+* Run HAE expansion asynchronously.
+*
+* Note: the HAE priority function accesses `context.graph` to retrieve
+* neighbour types. Full async equivalence requires PriorityContext
+* refactoring (Phase 4b deferred). This export establishes the async API
+* surface; use with a `wrapAsync`-wrapped sync graph for testing.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - HAE configuration combined with async runner options
+* @returns Promise resolving to the expansion result
+*/
+async function haeAsync(graph, seeds, config) {
+	const typeMapper = config?.typeMapper ?? defaultTypeMapper$1;
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: createHAEPriority(typeMapper)
+	});
+}
 //#endregion
 //#region src/expansion/edge.ts
 /** Default type mapper: reads `node.type`, falling back to "default". */
@@ -316,6 +511,27 @@ function edge(graph, seeds, config) {
 		typeMapper: defaultTypeMapper
 	});
 }
+/**
+* Run EDGE expansion asynchronously.
+*
+* Delegates to `haeAsync` with the default `node.type` mapper.
+*
+* Note: the HAE priority function accesses `context.graph` to retrieve
+* neighbour types. Full async equivalence requires PriorityContext
+* refactoring (Phase 4b deferred). This export establishes the async API
+* surface; use with a `wrapAsync`-wrapped sync graph for testing.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function edgeAsync(graph, seeds, config) {
+	return haeAsync(graph, seeds, {
+		...config,
+		typeMapper: defaultTypeMapper
+	});
+}
 //#endregion
 //#region src/expansion/pipe.ts
 /**
@@ -351,6 +567,25 @@ function pipe(graph, seeds, config) {
 		priority: pipePriority
 	});
 }
+/**
+* Run PIPE expansion asynchronously.
+*
+* Note: the PIPE priority function accesses `context.graph` to retrieve
+* neighbour lists. Full async equivalence requires PriorityContext
+* refactoring (Phase 4b deferred). This export establishes the async API
+* surface; use with a `wrapAsync`-wrapped sync graph for testing.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function pipeAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: pipePriority
+	});
+}
 //#endregion
 //#region src/expansion/priority-helpers.ts
 /**
@@ -447,6 +682,34 @@ function sage(graph, seeds, config) {
 		priority: sagePriority
 	});
 }
+/**
+* Run SAGE expansion asynchronously.
+*
+* Creates fresh closure state (salienceCounts, phase tracking) for this
+* invocation. The SAGE priority function does not access `context.graph`
+* directly, so it is safe to use in async mode via `baseAsync`.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function sageAsync(graph, seeds, config) {
+	const salienceCounts = /* @__PURE__ */ new Map();
+	let inPhase2 = false;
+	let lastPathCount = 0;
+	function sagePriority(nodeId, context) {
+		const pathCount = context.discoveredPaths.length;
+		if (pathCount > 0 && !inPhase2) inPhase2 = true;
+		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);
+	}
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: sagePriority
+	});
+}
 //#endregion
 //#region src/ranking/mi/jaccard.ts
 /**
@@ -464,6 +727,23 @@ function jaccard(graph, source, target, config) {
 	if (sourceNeighbours.size === 0 && targetNeighbours.size === 0) return 0;
 	return Math.max(epsilon, jaccardScore);
 }
+/**
+* Async variant of Jaccard similarity for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then applies the same formula.
+*/
+async function jaccardAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceNeighboursArr, targetNeighboursArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceNeighboursArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetNeighboursArr.filter((n) => n !== source));
+	if (srcSet.size === 0 && tgtSet.size === 0) return 0;
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	return Math.max(epsilon, jaccardScore);
+}
 //#endregion
 //#region src/expansion/reach.ts
 /**
@@ -520,6 +800,40 @@ function reach(graph, seeds, config) {
 		priority: reachPriority
 	});
 }
+/**
+* Run REACH expansion asynchronously.
+*
+* Creates fresh closure state (phase tracking, Jaccard cache) for this
+* invocation. The REACH priority function uses `jaccard(context.graph, ...)`
+* in Phase 2; in async mode `context.graph` is the sentinel and will throw.
+* Full async equivalence requires PriorityContext refactoring (Phase 4b
+* deferred). This export establishes the async API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function reachAsync(graph, seeds, config) {
+	let inPhase2 = false;
+	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) {
+			totalMI += jaccard(context.graph, nodeId, path.fromSeed.id);
+			totalMI += jaccard(context.graph, nodeId, path.toSeed.id);
+			endpointCount += 2;
+		}
+		const miHat = endpointCount > 0 ? totalMI / endpointCount : 0;
+		return Math.log(context.degree + 1) * (1 - miHat);
+	}
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: reachPriority
+	});
+}
 //#endregion
 //#region src/expansion/maze.ts
 /** Default threshold for switching to phase 2 (after M paths) */
@@ -566,6 +880,46 @@ function maze(graph, seeds, config) {
 		priority: mazePriority
 	});
 }
+/**
+* Run MAZE expansion asynchronously.
+*
+* Creates fresh closure state (salienceCounts, phase tracking) for this
+* invocation. The MAZE priority function accesses `context.graph` to
+* retrieve neighbour lists for path potential computation. Full async
+* equivalence requires PriorityContext refactoring (Phase 4b deferred).
+* This export establishes the async API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function mazeAsync(graph, seeds, config) {
+	const salienceCounts = /* @__PURE__ */ new Map();
+	let inPhase2 = false;
+	let lastPathCount = 0;
+	function mazePriority(nodeId, context) {
+		const pathCount = context.discoveredPaths.length;
+		if (pathCount >= DEFAULT_PHASE2_THRESHOLD && !inPhase2) {
+			inPhase2 = true;
+			updateSalienceCounts(salienceCounts, context.discoveredPaths, 0);
+		}
+		if (inPhase2 && pathCount > lastPathCount) lastPathCount = updateSalienceCounts(salienceCounts, context.discoveredPaths, lastPathCount);
+		const nodeNeighbours = context.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 baseAsync(graph, seeds, {
+		...config,
+		priority: mazePriority
+	});
+}
 //#endregion
 //#region src/expansion/tide.ts
 /**
@@ -597,6 +951,25 @@ function tide(graph, seeds, config) {
 		priority: tidePriority
 	});
 }
+/**
+* Run TIDE expansion asynchronously.
+*
+* Note: the TIDE priority function accesses `context.graph` to retrieve
+* neighbour lists and per-neighbour degrees. Full async equivalence
+* requires PriorityContext refactoring (Phase 4b deferred). This export
+* establishes the async API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function tideAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: tidePriority
+	});
+}
 //#endregion
 //#region src/expansion/lace.ts
 /**
@@ -627,6 +1000,27 @@ function lace(graph, seeds, config) {
 		priority
 	});
 }
+/**
+* Run LACE expansion asynchronously.
+*
+* Note: the LACE priority function accesses `context.graph` via
+* `avgFrontierMI`. Full async equivalence requires PriorityContext
+* refactoring (Phase 4b deferred). This export establishes the async
+* API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - LACE configuration combined with async runner options
+* @returns Promise resolving to the expansion result
+*/
+async function laceAsync(graph, seeds, config) {
+	const { mi = jaccard, ...restConfig } = config ?? {};
+	const priority = (nodeId, context) => lacePriority(nodeId, context, mi);
+	return baseAsync(graph, seeds, {
+		...restConfig,
+		priority
+	});
+}
 //#endregion
 //#region src/expansion/warp.ts
 /**
@@ -659,6 +1053,25 @@ function warp(graph, seeds, config) {
 		priority: warpPriority
 	});
 }
+/**
+* Run WARP expansion asynchronously.
+*
+* Note: the WARP priority function accesses `context.graph` via
+* `countCrossFrontierNeighbours`. Full async equivalence requires
+* PriorityContext refactoring (Phase 4b deferred). This export
+* establishes the async API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function warpAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: warpPriority
+	});
+}
 //#endregion
 //#region src/expansion/fuse.ts
 /**
@@ -691,6 +1104,27 @@ function fuse(graph, seeds, config) {
 		priority
 	});
 }
+/**
+* Run FUSE expansion asynchronously.
+*
+* Note: the FUSE priority function accesses `context.graph` via
+* `avgFrontierMI`. Full async equivalence requires PriorityContext
+* refactoring (Phase 4b deferred). This export establishes the async
+* API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - FUSE configuration combined with async runner options
+* @returns Promise resolving to the expansion result
+*/
+async function fuseAsync(graph, seeds, config) {
+	const { mi = jaccard, salienceWeight = .5, ...restConfig } = config ?? {};
+	const priority = (nodeId, context) => fusePriority(nodeId, context, mi, salienceWeight);
+	return baseAsync(graph, seeds, {
+		...restConfig,
+		priority
+	});
+}
 //#endregion
 //#region src/expansion/sift.ts
 /**
@@ -723,6 +1157,27 @@ function sift(graph, seeds, config) {
 		priority
 	});
 }
+/**
+* Run SIFT expansion asynchronously.
+*
+* Note: the SIFT priority function accesses `context.graph` via
+* `avgFrontierMI`. Full async equivalence requires PriorityContext
+* refactoring (Phase 4b deferred). This export establishes the async
+* API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - SIFT (REACHConfig) configuration combined with async runner options
+* @returns Promise resolving to the expansion result
+*/
+async function siftAsync(graph, seeds, config) {
+	const { mi = jaccard, miThreshold = .25, ...restConfig } = config ?? {};
+	const priority = (nodeId, context) => siftPriority(nodeId, context, mi, miThreshold);
+	return baseAsync(graph, seeds, {
+		...restConfig,
+		priority
+	});
+}
 //#endregion
 //#region src/expansion/flux.ts
 /**
@@ -779,9 +1234,36 @@ function flux(graph, seeds, config) {
 		priority
 	});
 }
+/**
+* Run FLUX expansion asynchronously.
+*
+* Note: the FLUX priority function accesses `context.graph` to compute
+* local density and cross-frontier bridge scores. Full async equivalence
+* requires PriorityContext refactoring (Phase 4b deferred). This export
+* establishes the async API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - FLUX (MAZEConfig) configuration combined with async runner options
+* @returns Promise resolving to the expansion result
+*/
+async function fluxAsync(graph, seeds, config) {
+	const { densityThreshold = .5, bridgeThreshold = .3, ...restConfig } = config ?? {};
+	const priority = (nodeId, context) => fluxPriority(nodeId, context, densityThreshold, bridgeThreshold);
+	return baseAsync(graph, seeds, {
+		...restConfig,
+		priority
+	});
+}
 //#endregion
 //#region src/expansion/standard-bfs.ts
 /**
+* BFS priority: discovery iteration order (FIFO).
+*/
+function bfsPriority(_nodeId, context) {
+	return context.iteration;
+}
+/**
 * Run standard BFS expansion (FIFO discovery order).
 *
 * @param graph - Source graph
@@ -790,17 +1272,35 @@ function flux(graph, seeds, config) {
 * @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
 	});
 }
+/**
+* Run standard BFS expansion asynchronously (FIFO discovery order).
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function standardBfsAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: bfsPriority
+	});
+}
 //#endregion
 //#region src/expansion/frontier-balanced.ts
 /**
+* Frontier-balanced priority: frontier index dominates, then discovery iteration.
+* Scales frontier index by 1e9 to ensure round-robin ordering across frontiers.
+*/
+function balancedPriority(_nodeId, context) {
+	return context.frontierIndex * 1e9 + context.iteration;
+}
+/**
 * Run frontier-balanced expansion (round-robin across frontiers).
 *
 * @param graph - Source graph
@@ -809,14 +1309,25 @@ function standardBfs(graph, seeds, config) {
 * @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
 	});
 }
+/**
+* Run frontier-balanced expansion asynchronously (round-robin across frontiers).
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function frontierBalancedAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: balancedPriority
+	});
+}
 //#endregion
 //#region src/expansion/random-priority.ts
 /**
@@ -836,6 +1347,12 @@ function seededRandom$1(input, seed = 0) {
 	return (h >>> 0) / 4294967295;
 }
 /**
+* Build a seeded random priority function for a given seed value.
+*/
+function makeRandomPriorityFn(seed) {
+	return (nodeId) => seededRandom$1(nodeId, seed);
+}
+/**
 * Run random-priority expansion (null hypothesis baseline).
 *
 * @param graph - Source graph
@@ -845,12 +1362,24 @@ function seededRandom$1(input, seed = 0) {
 */
 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
+		priority: makeRandomPriorityFn(seed)
+	});
+}
+/**
+* Run random-priority expansion asynchronously (null hypothesis baseline).
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function randomPriorityAsync(graph, seeds, config) {
+	const { seed = 0 } = config ?? {};
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: makeRandomPriorityFn(seed)
 	});
 }
 //#endregion
@@ -882,6 +1411,20 @@ function dfsPriority(graph, seeds, config) {
 		priority: dfsPriorityFn
 	});
 }
+/**
+* Run DFS-priority expansion asynchronously (LIFO discovery order).
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function dfsPriorityAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: dfsPriorityFn
+	});
+}
 //#endregion
 //#region src/expansion/k-hop.ts
 /**
@@ -1239,6 +1782,74 @@ function parse(graph, paths, config) {
 	};
 }
 /**
+* Rank paths using async PARSE (Path-Aware Ranking via Salience Estimation).
+*
+* Async variant suitable for use with remote or lazy graph data sources.
+* Computes geometric mean of edge MI scores for each path using Promise.all
+* for parallelism, then sorts by salience (highest first).
+*
+* @param graph - Async source graph
+* @param paths - Paths to rank
+* @param config - Configuration options
+* @returns Ranked paths with statistics
+*/
+async function parseAsync(graph, paths, config) {
+	const startTime = performance.now();
+	const { mi = jaccardAsync, epsilon = 1e-10 } = config ?? {};
+	const rankedPaths = [];
+	for (const path of paths) {
+		const salience = await computePathSalienceAsync(graph, path, mi, epsilon);
+		rankedPaths.push({
+			...path,
+			salience
+		});
+	}
+	rankedPaths.sort((a, b) => b.salience - a.salience);
+	const endTime = performance.now();
+	const saliences = rankedPaths.map((p) => p.salience);
+	const meanSalience = saliences.length > 0 ? saliences.reduce((a, b) => a + b, 0) / saliences.length : 0;
+	const sortedSaliences = [...saliences].sort((a, b) => a - b);
+	const mid = Math.floor(sortedSaliences.length / 2);
+	const medianSalience = sortedSaliences.length > 0 ? sortedSaliences.length % 2 !== 0 ? sortedSaliences[mid] ?? 0 : ((sortedSaliences[mid - 1] ?? 0) + (sortedSaliences[mid] ?? 0)) / 2 : 0;
+	const maxSalience = sortedSaliences.length > 0 ? sortedSaliences[sortedSaliences.length - 1] ?? 0 : 0;
+	const minSalience = sortedSaliences.length > 0 ? sortedSaliences[0] ?? 0 : 0;
+	return {
+		paths: rankedPaths,
+		stats: {
+			pathsRanked: rankedPaths.length,
+			meanSalience,
+			medianSalience,
+			maxSalience,
+			minSalience,
+			durationMs: endTime - startTime
+		}
+	};
+}
+/**
+* Compute salience for a single path asynchronously.
+*
+* Uses geometric mean of edge MI scores for length-unbiased ranking.
+* Edge MI values are computed in parallel via Promise.all.
+*/
+async function computePathSalienceAsync(graph, path, mi, epsilon) {
+	const nodes = path.nodes;
+	if (nodes.length < 2) return epsilon;
+	const edgeMIs = await Promise.all(nodes.slice(0, -1).map((source, i) => {
+		const target = nodes[i + 1];
+		if (target !== void 0) return mi(graph, source, target);
+		return Promise.resolve(epsilon);
+	}));
+	let productMi = 1;
+	let edgeCount = 0;
+	for (const edgeMi of edgeMIs) {
+		productMi *= Math.max(epsilon, edgeMi);
+		edgeCount++;
+	}
+	if (edgeCount === 0) return epsilon;
+	const salience = Math.pow(productMi, 1 / edgeCount);
+	return Math.max(epsilon, Math.min(1, salience));
+}
+/**
 * Compute salience for a single path.
 *
 * Uses geometric mean of edge MI scores for length-unbiased ranking.
@@ -1286,6 +1897,29 @@ function adamicAdar(graph, source, target, config) {
 	}
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of Adamic-Adar index for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then fetches degree for each common
+* neighbour to compute the inverse-log-degree weighted sum.
+*/
+async function adamicAdarAsync(graph, source, target, config) {
+	const { epsilon = 1e-10, normalise = true } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	const commonNeighbours = [];
+	for (const n of srcSet) if (tgtSet.has(n)) commonNeighbours.push(n);
+	if (commonNeighbours.length === 0) return epsilon;
+	const degrees = await Promise.all(commonNeighbours.map((n) => graph.degree(n)));
+	let score = 0;
+	for (const degree of degrees) score += 1 / Math.log(degree + 1);
+	if (normalise) {
+		const maxScore = commonNeighbours.length / Math.log(2);
+		score = score / maxScore;
+	}
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/cosine.ts
 /**
@@ -1307,6 +1941,23 @@ function cosine(graph, source, target, config) {
 	const score = intersection / denominator;
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of cosine similarity for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then applies the same formula.
+*/
+async function cosineAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const denominator = Math.sqrt(srcSet.size) * Math.sqrt(tgtSet.size);
+	if (denominator === 0) return 0;
+	const score = intersection / denominator;
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/sorensen.ts
 /**
@@ -1328,6 +1979,23 @@ function sorensen(graph, source, target, config) {
 	const score = 2 * intersection / denominator;
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of Sorensen-Dice coefficient for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then applies the same formula.
+*/
+async function sorensenAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const denominator = srcSet.size + tgtSet.size;
+	if (denominator === 0) return 0;
+	const score = 2 * intersection / denominator;
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/resource-allocation.ts
 /**
@@ -1353,6 +2021,29 @@ function resourceAllocation(graph, source, target, config) {
 	}
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of Resource Allocation index for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then fetches degree for each common
+* neighbour to compute the inverse-degree weighted sum.
+*/
+async function resourceAllocationAsync(graph, source, target, config) {
+	const { epsilon = 1e-10, normalise = true } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	const commonNeighbours = [];
+	for (const n of srcSet) if (tgtSet.has(n)) commonNeighbours.push(n);
+	if (commonNeighbours.length === 0) return epsilon;
+	const degrees = await Promise.all(commonNeighbours.map((n) => graph.degree(n)));
+	let score = 0;
+	for (const degree of degrees) if (degree > 0) score += 1 / degree;
+	if (normalise) {
+		const maxScore = commonNeighbours.length;
+		score = score / maxScore;
+	}
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/overlap-coefficient.ts
 /**
@@ -1374,6 +2065,23 @@ function overlapCoefficient(graph, source, target, config) {
 	const score = intersection / denominator;
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of Overlap Coefficient for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then applies the same formula.
+*/
+async function overlapCoefficientAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const denominator = Math.min(srcSet.size, tgtSet.size);
+	if (denominator === 0) return 0;
+	const score = intersection / denominator;
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/hub-promoted.ts
 /**
@@ -1395,6 +2103,28 @@ function hubPromoted(graph, source, target, config) {
 	const score = intersection / denominator;
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of Hub Promoted index for use with async graph data sources.
+*
+* Fetches both neighbourhoods and degrees concurrently, then applies the same formula.
+*/
+async function hubPromotedAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr, sourceDegree, targetDegree] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		graph.degree(source),
+		graph.degree(target)
+	]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const denominator = Math.min(sourceDegree, targetDegree);
+	if (denominator === 0) return 0;
+	const score = intersection / denominator;
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/scale.ts
 /**
@@ -1411,6 +2141,31 @@ function scale(graph, source, target, config) {
 	const score = jaccardScore / density;
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of SCALE MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods, node count, and edge count concurrently.
+*/
+async function scaleAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr, n, m] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		graph.nodeCount,
+		graph.edgeCount
+	]);
+	const srcSet = new Set(sourceArr.filter((node) => node !== target));
+	const tgtSet = new Set(targetArr.filter((node) => node !== source));
+	let intersection = 0;
+	for (const node of srcSet) if (tgtSet.has(node)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	const possibleEdges = n * (n - 1);
+	const density = possibleEdges > 0 ? (graph.directed ? m : 2 * m) / possibleEdges : 0;
+	if (density === 0) return epsilon;
+	const score = jaccardScore / density;
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/skew.ts
 /**
@@ -1427,6 +2182,31 @@ function skew(graph, source, target, config) {
 	const score = jaccardScore * sourceIdf * targetIdf;
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of SKEW MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods, degrees, and node count concurrently.
+*/
+async function skewAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr, N, sourceDegree, targetDegree] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		graph.nodeCount,
+		graph.degree(source),
+		graph.degree(target)
+	]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	const sourceIdf = Math.log(N / (sourceDegree + 1));
+	const targetIdf = Math.log(N / (targetDegree + 1));
+	const score = jaccardScore * sourceIdf * targetIdf;
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/span.ts
 /**
@@ -1440,6 +2220,40 @@ function span(graph, source, target, config) {
 	const score = jaccardScore * (1 - Math.max(sourceCc, targetCc));
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of SPAN MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then computes the clustering
+* coefficient for each endpoint from the collected neighbour arrays.
+*/
+async function spanAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	const computeClusteringCoefficient = async (nodeId, neighbourArr) => {
+		const degree = neighbourArr.length;
+		if (degree < 2) return 0;
+		const pairs = [];
+		for (let i = 0; i < neighbourArr.length; i++) for (let j = i + 1; j < neighbourArr.length; j++) {
+			const u = neighbourArr[i];
+			const v = neighbourArr[j];
+			if (u !== void 0 && v !== void 0) pairs.push([u, v]);
+		}
+		const edgeResults = await Promise.all(pairs.flatMap(([u, v]) => [graph.getEdge(u, v), graph.getEdge(v, u)]));
+		let triangleCount = 0;
+		for (let i = 0; i < pairs.length; i++) if (edgeResults[2 * i] !== void 0 || edgeResults[2 * i + 1] !== void 0) triangleCount++;
+		const possibleTriangles = degree * (degree - 1) / 2;
+		return triangleCount / possibleTriangles;
+	};
+	const [sourceCc, targetCc] = await Promise.all([computeClusteringCoefficient(source, sourceArr), computeClusteringCoefficient(target, targetArr)]);
+	const score = jaccardScore * (1 - Math.max(sourceCc, targetCc));
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/etch.ts
 /**
@@ -1455,6 +2269,37 @@ function etch(graph, source, target, config) {
 	const score = jaccardScore * Math.log(graph.edgeCount / edgeTypeCount);
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of ETCH MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods and edge data concurrently, then counts
+* edges of the same type by iterating the async edge stream.
+*/
+async function etchAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr, edge] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		graph.getEdge(source, target)
+	]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	if (edge?.type === void 0) return Math.max(epsilon, jaccardScore);
+	const edgeType = edge.type;
+	let edgeTypeCount = 0;
+	let totalEdges = 0;
+	for await (const e of graph.edges()) {
+		totalEdges++;
+		if (e.type === edgeType) edgeTypeCount++;
+	}
+	if (edgeTypeCount === 0) return Math.max(epsilon, jaccardScore);
+	const score = jaccardScore * Math.log(totalEdges / edgeTypeCount);
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/notch.ts
 /**
@@ -1474,6 +2319,44 @@ function notch(graph, source, target, config) {
 	const score = jaccardScore * sourceRarity * targetRarity;
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of NOTCH MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods and node data concurrently, then counts
+* nodes of each type by iterating the async node stream.
+*/
+async function notchAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr, sourceNode, targetNode] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		graph.getNode(source),
+		graph.getNode(target)
+	]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	if (sourceNode?.type === void 0 || targetNode?.type === void 0) return Math.max(epsilon, jaccardScore);
+	const sourceType = sourceNode.type;
+	const targetType = targetNode.type;
+	let totalNodes = 0;
+	let sourceTypeCount = 0;
+	let targetTypeCount = 0;
+	for await (const nodeId of graph.nodeIds()) {
+		totalNodes++;
+		const node = await graph.getNode(nodeId);
+		if (node?.type === sourceType) sourceTypeCount++;
+		if (node?.type === targetType) targetTypeCount++;
+	}
+	if (sourceTypeCount === 0 || targetTypeCount === 0) return Math.max(epsilon, jaccardScore);
+	const sourceRarity = Math.log(totalNodes / sourceTypeCount);
+	const targetRarity = Math.log(totalNodes / targetTypeCount);
+	const score = jaccardScore * sourceRarity * targetRarity;
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/adaptive.ts
 /**
@@ -1506,6 +2389,38 @@ function adaptive(graph, source, target, config) {
 	const score = (structuralWeight * structural + degreeWeight * degreeComponent + overlapWeight * overlap) / totalWeight;
 	return Math.max(epsilon, Math.min(1, score));
 }
+/**
+* Async variant of Adaptive MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then delegates degree-weighted
+* component to the async Adamic-Adar variant.
+*/
+async function adaptiveAsync(graph, source, target, config) {
+	const { epsilon = 1e-10, structuralWeight = .4, degreeWeight = .3, overlapWeight = .3 } = config ?? {};
+	const [sourceArr, targetArr, degreeComponent] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		adamicAdarAsync(graph, source, target, {
+			epsilon,
+			normalise: true
+		})
+	]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	const structural = srcSet.size === 0 && tgtSet.size === 0 ? 0 : Math.max(epsilon, jaccardScore);
+	let overlap;
+	if (srcSet.size > 0 && tgtSet.size > 0) {
+		const minDegree = Math.min(srcSet.size, tgtSet.size);
+		overlap = minDegree > 0 ? intersection / minDegree : epsilon;
+	} else overlap = epsilon;
+	const totalWeight = structuralWeight + degreeWeight + overlapWeight;
+	const score = (structuralWeight * structural + degreeWeight * degreeComponent + overlapWeight * overlap) / totalWeight;
+	return Math.max(epsilon, Math.min(1, score));
+}
 //#endregion
 //#region src/ranking/baselines/utils.ts
 /**
@@ -3000,6 +3915,6 @@ function filterSubgraph(graph, options) {
 	return result;
 }
 //#endregion
-export { AdjacencyMapGraph, GPUContext, GPUNotAvailableError, PriorityQueue, _computeMean, adamicAdar, adaptive, approximateClusteringCoefficient, assertWebGPUAvailable, base, batchClusteringCoefficients, betweenness, bfs, bfsWithPath, communicability, computeJaccard, computeTrussNumbers, cosine, countEdgesOfType, countNodesOfType, createGPUContext, createResultBuffer, csrToGPUBuffers, degreeSum, detectWebGPU, dfs, dfsPriority, dfsPriorityFn, dfsWithPath, dome, domeHighDegree, edge, entropyFromCounts, enumerateMotifs, enumerateMotifsWithInstances, etch, extractEgoNetwork, extractInducedSubgraph, extractKCore, extractKTruss, filterSubgraph, flux, frontierBalanced, fuse, getGPUContext, getMotifName, graphToCSR, grasp, hae, hittingTime, hubPromoted, isWebGPUAvailable, jaccard, jaccardArithmetic, kHop, katz, lace, localClusteringCoefficient, localTypeEntropy, maze, miniBatchKMeans, neighbourIntersection, neighbourOverlap, neighbourSet, normaliseFeatures, normaliseFeatures as zScoreNormalise, normalisedEntropy, notch, overlapCoefficient, pagerank, parse, pipe, randomPriority, randomRanking, randomWalk, reach, readBufferToCPU, resistanceDistance, resourceAllocation, sage, scale, shannonEntropy, shortest, sift, skew, sorensen, span, standardBfs, stratified, tide, warp, widestPath };
+export { AdjacencyMapGraph, GPUContext, GPUNotAvailableError, PriorityQueue, _computeMean, adamicAdar, adamicAdarAsync, adaptive, adaptiveAsync, approximateClusteringCoefficient, assertWebGPUAvailable, base, baseAsync, batchClusteringCoefficients, betweenness, bfs, bfsWithPath, collectAsyncIterable, communicability, computeJaccard, computeTrussNumbers, cosine, cosineAsync, countEdgesOfType, countNodesOfType, createGPUContext, createResultBuffer, csrToGPUBuffers, defaultYieldStrategy, degreeSum, detectWebGPU, dfs, dfsPriority, dfsPriorityAsync, dfsPriorityFn, dfsWithPath, dome, domeAsync, domeHighDegree, domeHighDegreeAsync, edge, edgeAsync, entropyFromCounts, enumerateMotifs, enumerateMotifsWithInstances, etch, etchAsync, extractEgoNetwork, extractInducedSubgraph, extractKCore, extractKTruss, filterSubgraph, flux, fluxAsync, frontierBalanced, frontierBalancedAsync, fuse, fuseAsync, getGPUContext, getMotifName, graphToCSR, grasp, hae, haeAsync, hittingTime, hubPromoted, hubPromotedAsync, isWebGPUAvailable, jaccard, jaccardArithmetic, jaccardAsync, kHop, katz, lace, laceAsync, localClusteringCoefficient, localTypeEntropy, maze, mazeAsync, miniBatchKMeans, neighbourIntersection, neighbourOverlap, neighbourSet, normaliseFeatures, normaliseFeatures as zScoreNormalise, normalisedEntropy, notch, notchAsync, opDegree, opGetEdge, opGetNode, opHasNode, opNeighbours, opProgress, opYield, overlapCoefficient, overlapCoefficientAsync, pagerank, parse, parseAsync, pipe, pipeAsync, randomPriority, randomPriorityAsync, randomRanking, randomWalk, reach, reachAsync, readBufferToCPU, resistanceDistance, resolveAsyncOp, resolveSyncOp, resourceAllocation, resourceAllocationAsync, runAsync, runSync, sage, sageAsync, scale, scaleAsync, shannonEntropy, shortest, sift, siftAsync, skew, skewAsync, sorensen, sorensenAsync, span, spanAsync, standardBfs, standardBfsAsync, stratified, tide, tideAsync, warp, warpAsync, widestPath };
 
 //# sourceMappingURL=index.js.map