graphwise 1.6.0 → 1.8.0

package/dist/index/index.cjs

@@ -6,22 +6,134 @@ const require_kmeans = require("../kmeans-BIgSyGKu.cjs");
 const require_utils = require("../utils/index.cjs");
 const require_seeds = require("../seeds/index.cjs");
 const require_gpu = require("../gpu/index.cjs");
-//#region src/expansion/base.ts
+const require_async = require("../async/index.cjs");
+//#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);
@@ -41,7 +153,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* require_async.opDegree(seedNode);
+		const seedPriority = priority(seedNode, buildPriorityContext(seedNode, i, combinedVisited, allVisited, [], 0, seedDegree, graphRef));
 		queues[i]?.push({
 			nodeId: seedNode,
 			frontierIndex: i,
@@ -53,22 +166,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++) {
@@ -112,7 +220,7 @@ function base(graph, seeds, config) {
 				}
 			}
 		}
-		const neighbours = graph.neighbours(nodeId);
+		const neighbours = yield* require_async.opNeighbours(nodeId);
 		for (const neighbour of neighbours) {
 			edgesTraversed++;
 			const [s, t] = nodeId < neighbour ? [nodeId, neighbour] : [neighbour, nodeId];
@@ -122,9 +230,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* require_async.opDegree(neighbour);
+			const neighbourPriority = priority(neighbour, buildPriorityContext(neighbour, activeFrontier, combinedVisited, allVisited, discoveredPaths, iterations + 1, neighbourDegree, graphRef));
 			queue.push({
 				nodeId: neighbour,
 				frontierIndex: activeFrontier,
@@ -154,12 +263,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,
@@ -167,65 +314,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 require_async.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 require_async.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
@@ -234,24 +387,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
@@ -296,6 +471,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". */
@@ -317,6 +512,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
 /**
@@ -352,6 +568,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
 /**
@@ -448,6 +683,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
 /**
@@ -465,6 +728,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([require_async.collectAsyncIterable(graph.neighbours(source)), require_async.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
 /**
@@ -521,6 +801,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) */
@@ -567,6 +881,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
 /**
@@ -598,6 +952,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
 /**
@@ -628,6 +1001,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
 /**
@@ -660,6 +1054,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
 /**
@@ -692,6 +1105,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
 /**
@@ -724,6 +1158,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
 /**
@@ -780,9 +1235,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
@@ -791,17 +1273,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
@@ -810,14 +1310,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
 /**
@@ -837,6 +1348,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
@@ -846,12 +1363,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
@@ -883,6 +1412,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
 /**
@@ -1240,6 +1783,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.
@@ -1287,6 +1898,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([require_async.collectAsyncIterable(graph.neighbours(source)), require_async.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
 /**
@@ -1308,6 +1942,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([require_async.collectAsyncIterable(graph.neighbours(source)), require_async.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
 /**
@@ -1329,6 +1980,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([require_async.collectAsyncIterable(graph.neighbours(source)), require_async.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
 /**
@@ -1354,6 +2022,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([require_async.collectAsyncIterable(graph.neighbours(source)), require_async.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
 /**
@@ -1375,6 +2066,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([require_async.collectAsyncIterable(graph.neighbours(source)), require_async.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
 /**
@@ -1396,6 +2104,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([
+		require_async.collectAsyncIterable(graph.neighbours(source)),
+		require_async.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
 /**
@@ -1412,6 +2142,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([
+		require_async.collectAsyncIterable(graph.neighbours(source)),
+		require_async.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
 /**
@@ -1428,6 +2183,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([
+		require_async.collectAsyncIterable(graph.neighbours(source)),
+		require_async.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
 /**
@@ -1441,6 +2221,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([require_async.collectAsyncIterable(graph.neighbours(source)), require_async.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
 /**
@@ -1456,6 +2270,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([
+		require_async.collectAsyncIterable(graph.neighbours(source)),
+		require_async.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
 /**
@@ -1475,6 +2320,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([
+		require_async.collectAsyncIterable(graph.neighbours(source)),
+		require_async.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
 /**
@@ -1507,6 +2390,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([
+		require_async.collectAsyncIterable(graph.neighbours(source)),
+		require_async.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
 /**
@@ -3007,60 +3922,79 @@ exports.GPUNotAvailableError = require_gpu.GPUNotAvailableError;
 exports.PriorityQueue = require_structures.PriorityQueue;
 exports._computeMean = require_kmeans._computeMean;
 exports.adamicAdar = adamicAdar;
+exports.adamicAdarAsync = adamicAdarAsync;
 exports.adaptive = adaptive;
+exports.adaptiveAsync = adaptiveAsync;
 exports.approximateClusteringCoefficient = require_utils.approximateClusteringCoefficient;
 exports.assertWebGPUAvailable = require_gpu.assertWebGPUAvailable;
 exports.base = base;
+exports.baseAsync = baseAsync;
 exports.batchClusteringCoefficients = require_utils.batchClusteringCoefficients;
 exports.betweenness = betweenness;
 exports.bfs = require_traversal.bfs;
 exports.bfsWithPath = require_traversal.bfsWithPath;
+exports.collectAsyncIterable = require_async.collectAsyncIterable;
 exports.communicability = communicability;
 exports.computeJaccard = require_utils.computeJaccard;
 exports.computeTrussNumbers = computeTrussNumbers;
 exports.cosine = cosine;
+exports.cosineAsync = cosineAsync;
 exports.countEdgesOfType = require_utils.countEdgesOfType;
 exports.countNodesOfType = require_utils.countNodesOfType;
 exports.createGPUContext = require_gpu.createGPUContext;
 exports.createResultBuffer = require_gpu.createResultBuffer;
 exports.csrToGPUBuffers = require_gpu.csrToGPUBuffers;
+exports.defaultYieldStrategy = require_async.defaultYieldStrategy;
 exports.degreeSum = degreeSum;
 exports.detectWebGPU = require_gpu.detectWebGPU;
 exports.dfs = require_traversal.dfs;
 exports.dfsPriority = dfsPriority;
+exports.dfsPriorityAsync = dfsPriorityAsync;
 exports.dfsPriorityFn = dfsPriorityFn;
 exports.dfsWithPath = require_traversal.dfsWithPath;
 exports.dome = dome;
+exports.domeAsync = domeAsync;
 exports.domeHighDegree = domeHighDegree;
+exports.domeHighDegreeAsync = domeHighDegreeAsync;
 exports.edge = edge;
+exports.edgeAsync = edgeAsync;
 exports.entropyFromCounts = require_utils.entropyFromCounts;
 exports.enumerateMotifs = enumerateMotifs;
 exports.enumerateMotifsWithInstances = enumerateMotifsWithInstances;
 exports.etch = etch;
+exports.etchAsync = etchAsync;
 exports.extractEgoNetwork = extractEgoNetwork;
 exports.extractInducedSubgraph = extractInducedSubgraph;
 exports.extractKCore = extractKCore;
 exports.extractKTruss = extractKTruss;
 exports.filterSubgraph = filterSubgraph;
 exports.flux = flux;
+exports.fluxAsync = fluxAsync;
 exports.frontierBalanced = frontierBalanced;
+exports.frontierBalancedAsync = frontierBalancedAsync;
 exports.fuse = fuse;
+exports.fuseAsync = fuseAsync;
 exports.getGPUContext = require_gpu.getGPUContext;
 exports.getMotifName = getMotifName;
 exports.graphToCSR = require_gpu.graphToCSR;
 exports.grasp = require_seeds.grasp;
 exports.hae = hae;
+exports.haeAsync = haeAsync;
 exports.hittingTime = hittingTime;
 exports.hubPromoted = hubPromoted;
+exports.hubPromotedAsync = hubPromotedAsync;
 exports.isWebGPUAvailable = require_gpu.isWebGPUAvailable;
 exports.jaccard = jaccard;
 exports.jaccardArithmetic = jaccardArithmetic;
+exports.jaccardAsync = jaccardAsync;
 exports.kHop = kHop;
 exports.katz = katz;
 exports.lace = lace;
+exports.laceAsync = laceAsync;
 exports.localClusteringCoefficient = require_utils.localClusteringCoefficient;
 exports.localTypeEntropy = require_utils.localTypeEntropy;
 exports.maze = maze;
+exports.mazeAsync = mazeAsync;
 exports.miniBatchKMeans = require_kmeans.miniBatchKMeans;
 exports.neighbourIntersection = require_utils.neighbourIntersection;
 exports.neighbourOverlap = require_utils.neighbourOverlap;
@@ -3069,29 +4003,56 @@ exports.normaliseFeatures = require_kmeans.normaliseFeatures;
 exports.zScoreNormalise = require_kmeans.normaliseFeatures;
 exports.normalisedEntropy = require_utils.normalisedEntropy;
 exports.notch = notch;
+exports.notchAsync = notchAsync;
+exports.opDegree = require_async.opDegree;
+exports.opGetEdge = require_async.opGetEdge;
+exports.opGetNode = require_async.opGetNode;
+exports.opHasNode = require_async.opHasNode;
+exports.opNeighbours = require_async.opNeighbours;
+exports.opProgress = require_async.opProgress;
+exports.opYield = require_async.opYield;
 exports.overlapCoefficient = overlapCoefficient;
+exports.overlapCoefficientAsync = overlapCoefficientAsync;
 exports.pagerank = pagerank;
 exports.parse = parse;
+exports.parseAsync = parseAsync;
 exports.pipe = pipe;
+exports.pipeAsync = pipeAsync;
 exports.randomPriority = randomPriority;
+exports.randomPriorityAsync = randomPriorityAsync;
 exports.randomRanking = randomRanking;
 exports.randomWalk = randomWalk;
 exports.reach = reach;
+exports.reachAsync = reachAsync;
 exports.readBufferToCPU = require_gpu.readBufferToCPU;
 exports.resistanceDistance = resistanceDistance;
+exports.resolveAsyncOp = require_async.resolveAsyncOp;
+exports.resolveSyncOp = require_async.resolveSyncOp;
 exports.resourceAllocation = resourceAllocation;
+exports.resourceAllocationAsync = resourceAllocationAsync;
+exports.runAsync = require_async.runAsync;
+exports.runSync = require_async.runSync;
 exports.sage = sage;
+exports.sageAsync = sageAsync;
 exports.scale = scale;
+exports.scaleAsync = scaleAsync;
 exports.shannonEntropy = require_utils.shannonEntropy;
 exports.shortest = shortest;
 exports.sift = sift;
+exports.siftAsync = siftAsync;
 exports.skew = skew;
+exports.skewAsync = skewAsync;
 exports.sorensen = sorensen;
+exports.sorensenAsync = sorensenAsync;
 exports.span = span;
+exports.spanAsync = spanAsync;
 exports.standardBfs = standardBfs;
+exports.standardBfsAsync = standardBfsAsync;
 exports.stratified = require_seeds.stratified;
 exports.tide = tide;
+exports.tideAsync = tideAsync;
 exports.warp = warp;
+exports.warpAsync = warpAsync;
 exports.widestPath = widestPath;
 
 //# sourceMappingURL=index.cjs.map