graphwise 1.7.0 → 1.8.0

package/dist/index/index.cjs

@@ -6,199 +6,7 @@ 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/async/utils.ts
-/**
-* Async utility functions.
-*
-* @module async/utils
-*/
-/** Collect an AsyncIterable into a readonly array. */
-async function collectAsyncIterable(iter) {
-	const result = [];
-	for await (const item of iter) result.push(item);
-	return result;
-}
-/** Default yield strategy: setTimeout(0) to yield to the event loop. */
-function defaultYieldStrategy() {
-	return new Promise((r) => {
-		setTimeout(r, 0);
-	});
-}
-//#endregion
-//#region src/async/runners.ts
-/**
-* Resolve a single GraphOp against a synchronous ReadableGraph.
-*
-* Returns a tagged GraphOpResponse so the receiving generator can narrow
-* the result type without type assertions.
-*
-* @param graph - The synchronous graph to query
-* @param op - The operation to resolve
-* @returns The tagged response
-*/
-function resolveSyncOp(graph, op) {
-	switch (op.tag) {
-		case "neighbours": return {
-			tag: "neighbours",
-			value: Array.from(graph.neighbours(op.id, op.direction))
-		};
-		case "degree": return {
-			tag: "degree",
-			value: graph.degree(op.id, op.direction)
-		};
-		case "getNode": return {
-			tag: "getNode",
-			value: graph.getNode(op.id)
-		};
-		case "getEdge": return {
-			tag: "getEdge",
-			value: graph.getEdge(op.source, op.target)
-		};
-		case "hasNode": return {
-			tag: "hasNode",
-			value: graph.hasNode(op.id)
-		};
-		case "yield": return { tag: "yield" };
-		case "progress": return { tag: "progress" };
-	}
-}
-/**
-* Drive a generator to completion using a synchronous graph.
-*
-* The generator yields GraphOp requests; each is resolved immediately
-* against the graph and the tagged response is fed back via gen.next().
-*
-* @param gen - The generator to drive
-* @param graph - The graph to resolve ops against
-* @returns The generator's return value
-*/
-function runSync(gen, graph) {
-	let step = gen.next();
-	while (step.done !== true) {
-		const response = resolveSyncOp(graph, step.value);
-		step = gen.next(response);
-	}
-	return step.value;
-}
-/**
-* Resolve a single GraphOp against an async ReadableGraph.
-*
-* AsyncIterables (neighbours) are collected into readonly arrays so the
-* generator receives the same value type as in sync mode. Returns a tagged
-* GraphOpResponse for type-safe narrowing without assertions.
-*
-* @param graph - The async graph to query
-* @param op - The operation to resolve
-* @returns A promise resolving to the tagged response
-*/
-async function resolveAsyncOp(graph, op) {
-	switch (op.tag) {
-		case "neighbours": return {
-			tag: "neighbours",
-			value: await collectAsyncIterable(graph.neighbours(op.id, op.direction))
-		};
-		case "degree": return {
-			tag: "degree",
-			value: await graph.degree(op.id, op.direction)
-		};
-		case "getNode": return {
-			tag: "getNode",
-			value: await graph.getNode(op.id)
-		};
-		case "getEdge": return {
-			tag: "getEdge",
-			value: await graph.getEdge(op.source, op.target)
-		};
-		case "hasNode": return {
-			tag: "hasNode",
-			value: await graph.hasNode(op.id)
-		};
-		case "yield": return { tag: "yield" };
-		case "progress": return { tag: "progress" };
-	}
-}
-/**
-* Drive a generator to completion using an async graph.
-*
-* Extends sync semantics with:
-* - Cancellation via AbortSignal (throws DOMException "AbortError")
-* - Cooperative yielding at `yield` ops (calls yieldStrategy)
-* - Progress callbacks at `progress` ops (may be async for backpressure)
-* - Error propagation: graph errors are forwarded via gen.throw(); if the
-*   generator does not handle them, they propagate to the caller
-*
-* @param gen - The generator to drive
-* @param graph - The async graph to resolve ops against
-* @param options - Runner configuration
-* @returns A promise resolving to the generator's return value
-*/
-async function runAsync(gen, graph, options) {
-	const signal = options?.signal;
-	const onProgress = options?.onProgress;
-	const yieldStrategy = options?.yieldStrategy ?? defaultYieldStrategy;
-	let step = gen.next();
-	while (step.done !== true) {
-		if (signal?.aborted === true) {
-			const abortError = new DOMException("Aborted", "AbortError");
-			try {
-				gen.throw(abortError);
-			} catch {
-				throw abortError;
-			}
-			throw abortError;
-		}
-		const op = step.value;
-		if (op.tag === "yield") {
-			await yieldStrategy();
-			step = gen.next({ tag: "yield" });
-			continue;
-		}
-		if (op.tag === "progress") {
-			if (onProgress !== void 0) {
-				const maybePromise = onProgress(op.stats);
-				if (maybePromise instanceof Promise) await maybePromise;
-			}
-			step = gen.next({ tag: "progress" });
-			continue;
-		}
-		let response;
-		try {
-			response = await resolveAsyncOp(graph, op);
-		} catch (error) {
-			step = gen.throw(error);
-			continue;
-		}
-		step = gen.next(response);
-	}
-	return step.value;
-}
-//#endregion
-//#region src/async/ops.ts
-function* opNeighbours(id, direction) {
-	const response = yield direction !== void 0 ? {
-		tag: "neighbours",
-		id,
-		direction
-	} : {
-		tag: "neighbours",
-		id
-	};
-	if (response.tag !== "neighbours") throw new TypeError(`Expected neighbours response, got ${response.tag}`);
-	return response.value;
-}
-function* opDegree(id, direction) {
-	const response = yield direction !== void 0 ? {
-		tag: "degree",
-		id,
-		direction
-	} : {
-		tag: "degree",
-		id
-	};
-	if (response.tag !== "degree") throw new TypeError(`Expected degree response, got ${response.tag}`);
-	return response.value;
-}
-//#endregion
+const require_async = require("../async/index.cjs");
 //#region src/expansion/base-helpers.ts
 /**
 * Check whether expansion should continue given current progress.
@@ -345,7 +153,7 @@ function* baseCore(graphMeta, seeds, config, graphRef) {
 		predecessors[i]?.set(seedNode, null);
 		combinedVisited.set(seedNode, i);
 		allVisited.add(seedNode);
-		const seedDegree = yield* opDegree(seedNode);
+		const seedDegree = yield* require_async.opDegree(seedNode);
 		const seedPriority = priority(seedNode, buildPriorityContext(seedNode, i, combinedVisited, allVisited, [], 0, seedDegree, graphRef));
 		queues[i]?.push({
 			nodeId: seedNode,
@@ -412,7 +220,7 @@ function* baseCore(graphMeta, seeds, config, graphRef) {
 				}
 			}
 		}
-		const neighbours = yield* opNeighbours(nodeId);
+		const neighbours = yield* require_async.opNeighbours(nodeId);
 		for (const neighbour of neighbours) {
 			edgesTraversed++;
 			const [s, t] = nodeId < neighbour ? [nodeId, neighbour] : [neighbour, nodeId];
@@ -424,7 +232,7 @@ function* baseCore(graphMeta, seeds, config, graphRef) {
 			targets.add(t);
 			const fv = visitedByFrontier[activeFrontier];
 			if (fv === void 0 || fv.has(neighbour)) continue;
-			const neighbourDegree = yield* opDegree(neighbour);
+			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,
@@ -520,7 +328,7 @@ function buildPriorityContext(_nodeId, frontierIndex, combinedVisited, allVisite
 * @returns Expansion result with discovered paths
 */
 function base(graph, seeds, config) {
-	return runSync(baseCore({
+	return require_async.runSync(baseCore({
 		directed: graph.directed,
 		nodeCount: graph.nodeCount,
 		edgeCount: graph.edgeCount
@@ -554,11 +362,23 @@ async function baseAsync(graph, seeds, config) {
 	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);
+	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
@@ -567,24 +387,46 @@ async function baseAsync(graph, seeds, config) {
 * @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
@@ -629,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". */
@@ -650,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
 /**
@@ -685,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
 /**
@@ -781,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
 /**
@@ -798,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
 /**
@@ -854,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) */
@@ -900,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
 /**
@@ -931,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
 /**
@@ -961,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
 /**
@@ -993,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
 /**
@@ -1025,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
 /**
@@ -1057,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
 /**
@@ -1113,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
@@ -1124,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
@@ -1143,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
 /**
@@ -1170,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
@@ -1179,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
@@ -1216,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
 /**
@@ -1573,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.
@@ -1620,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
 /**
@@ -1641,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
 /**
@@ -1662,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
 /**
@@ -1687,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
 /**
@@ -1708,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
 /**
@@ -1729,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
 /**
@@ -1745,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
 /**
@@ -1761,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
 /**
@@ -1774,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
 /**
@@ -1789,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
 /**
@@ -1808,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
 /**
@@ -1840,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
 /**
@@ -3340,7 +3922,9 @@ 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;
@@ -3349,52 +3933,68 @@ 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;
@@ -3403,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