graphwise 1.7.0 → 1.8.0

package/dist/index/index.js

@@ -5,199 +5,7 @@ import { n as miniBatchKMeans, r as normaliseFeatures, t as _computeMean } from
 import { approximateClusteringCoefficient, batchClusteringCoefficients, computeJaccard, countEdgesOfType, countNodesOfType, entropyFromCounts, localClusteringCoefficient, localTypeEntropy, neighbourIntersection, neighbourOverlap, neighbourSet, normalisedEntropy, shannonEntropy } from "../utils/index.js";
 import { grasp, stratified } from "../seeds/index.js";
 import { GPUContext, GPUNotAvailableError, assertWebGPUAvailable, createGPUContext, createResultBuffer, csrToGPUBuffers, detectWebGPU, getGPUContext, graphToCSR, isWebGPUAvailable, readBufferToCPU } from "../gpu/index.js";
-//#region src/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
+import { collectAsyncIterable, defaultYieldStrategy, opDegree, opGetEdge, opGetNode, opHasNode, opNeighbours, opProgress, opYield, resolveAsyncOp, resolveSyncOp, runAsync, runSync } from "../async/index.js";
 //#region src/expansion/base-helpers.ts
 /**
 * Check whether expansion should continue given current progress.
@@ -558,6 +366,18 @@ async function baseAsync(graph, seeds, config) {
 //#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
@@ -566,24 +386,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
@@ -628,6 +470,26 @@ function hae(graph, seeds, config) {
 		priority: createHAEPriority(typeMapper)
 	});
 }
+/**
+* Run HAE expansion asynchronously.
+*
+* Note: the HAE priority function accesses `context.graph` to retrieve
+* neighbour types. Full async equivalence requires PriorityContext
+* refactoring (Phase 4b deferred). This export establishes the async API
+* surface; use with a `wrapAsync`-wrapped sync graph for testing.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - HAE configuration combined with async runner options
+* @returns Promise resolving to the expansion result
+*/
+async function haeAsync(graph, seeds, config) {
+	const typeMapper = config?.typeMapper ?? defaultTypeMapper$1;
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: createHAEPriority(typeMapper)
+	});
+}
 //#endregion
 //#region src/expansion/edge.ts
 /** Default type mapper: reads `node.type`, falling back to "default". */
@@ -649,6 +511,27 @@ function edge(graph, seeds, config) {
 		typeMapper: defaultTypeMapper
 	});
 }
+/**
+* Run EDGE expansion asynchronously.
+*
+* Delegates to `haeAsync` with the default `node.type` mapper.
+*
+* Note: the HAE priority function accesses `context.graph` to retrieve
+* neighbour types. Full async equivalence requires PriorityContext
+* refactoring (Phase 4b deferred). This export establishes the async API
+* surface; use with a `wrapAsync`-wrapped sync graph for testing.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function edgeAsync(graph, seeds, config) {
+	return haeAsync(graph, seeds, {
+		...config,
+		typeMapper: defaultTypeMapper
+	});
+}
 //#endregion
 //#region src/expansion/pipe.ts
 /**
@@ -684,6 +567,25 @@ function pipe(graph, seeds, config) {
 		priority: pipePriority
 	});
 }
+/**
+* Run PIPE expansion asynchronously.
+*
+* Note: the PIPE priority function accesses `context.graph` to retrieve
+* neighbour lists. Full async equivalence requires PriorityContext
+* refactoring (Phase 4b deferred). This export establishes the async API
+* surface; use with a `wrapAsync`-wrapped sync graph for testing.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function pipeAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: pipePriority
+	});
+}
 //#endregion
 //#region src/expansion/priority-helpers.ts
 /**
@@ -780,6 +682,34 @@ function sage(graph, seeds, config) {
 		priority: sagePriority
 	});
 }
+/**
+* Run SAGE expansion asynchronously.
+*
+* Creates fresh closure state (salienceCounts, phase tracking) for this
+* invocation. The SAGE priority function does not access `context.graph`
+* directly, so it is safe to use in async mode via `baseAsync`.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function sageAsync(graph, seeds, config) {
+	const salienceCounts = /* @__PURE__ */ new Map();
+	let inPhase2 = false;
+	let lastPathCount = 0;
+	function sagePriority(nodeId, context) {
+		const pathCount = context.discoveredPaths.length;
+		if (pathCount > 0 && !inPhase2) inPhase2 = true;
+		if (pathCount > lastPathCount) lastPathCount = updateSalienceCounts(salienceCounts, context.discoveredPaths, lastPathCount);
+		if (!inPhase2) return Math.log(context.degree + 1);
+		return -((salienceCounts.get(nodeId) ?? 0) * 1e3 - context.degree);
+	}
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: sagePriority
+	});
+}
 //#endregion
 //#region src/ranking/mi/jaccard.ts
 /**
@@ -797,6 +727,23 @@ function jaccard(graph, source, target, config) {
 	if (sourceNeighbours.size === 0 && targetNeighbours.size === 0) return 0;
 	return Math.max(epsilon, jaccardScore);
 }
+/**
+* Async variant of Jaccard similarity for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then applies the same formula.
+*/
+async function jaccardAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceNeighboursArr, targetNeighboursArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceNeighboursArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetNeighboursArr.filter((n) => n !== source));
+	if (srcSet.size === 0 && tgtSet.size === 0) return 0;
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	return Math.max(epsilon, jaccardScore);
+}
 //#endregion
 //#region src/expansion/reach.ts
 /**
@@ -853,6 +800,40 @@ function reach(graph, seeds, config) {
 		priority: reachPriority
 	});
 }
+/**
+* Run REACH expansion asynchronously.
+*
+* Creates fresh closure state (phase tracking, Jaccard cache) for this
+* invocation. The REACH priority function uses `jaccard(context.graph, ...)`
+* in Phase 2; in async mode `context.graph` is the sentinel and will throw.
+* Full async equivalence requires PriorityContext refactoring (Phase 4b
+* deferred). This export establishes the async API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function reachAsync(graph, seeds, config) {
+	let inPhase2 = false;
+	function reachPriority(nodeId, context) {
+		if (context.discoveredPaths.length > 0 && !inPhase2) inPhase2 = true;
+		if (!inPhase2) return Math.log(context.degree + 1);
+		let totalMI = 0;
+		let endpointCount = 0;
+		for (const path of context.discoveredPaths) {
+			totalMI += jaccard(context.graph, nodeId, path.fromSeed.id);
+			totalMI += jaccard(context.graph, nodeId, path.toSeed.id);
+			endpointCount += 2;
+		}
+		const miHat = endpointCount > 0 ? totalMI / endpointCount : 0;
+		return Math.log(context.degree + 1) * (1 - miHat);
+	}
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: reachPriority
+	});
+}
 //#endregion
 //#region src/expansion/maze.ts
 /** Default threshold for switching to phase 2 (after M paths) */
@@ -899,6 +880,46 @@ function maze(graph, seeds, config) {
 		priority: mazePriority
 	});
 }
+/**
+* Run MAZE expansion asynchronously.
+*
+* Creates fresh closure state (salienceCounts, phase tracking) for this
+* invocation. The MAZE priority function accesses `context.graph` to
+* retrieve neighbour lists for path potential computation. Full async
+* equivalence requires PriorityContext refactoring (Phase 4b deferred).
+* This export establishes the async API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function mazeAsync(graph, seeds, config) {
+	const salienceCounts = /* @__PURE__ */ new Map();
+	let inPhase2 = false;
+	let lastPathCount = 0;
+	function mazePriority(nodeId, context) {
+		const pathCount = context.discoveredPaths.length;
+		if (pathCount >= DEFAULT_PHASE2_THRESHOLD && !inPhase2) {
+			inPhase2 = true;
+			updateSalienceCounts(salienceCounts, context.discoveredPaths, 0);
+		}
+		if (inPhase2 && pathCount > lastPathCount) lastPathCount = updateSalienceCounts(salienceCounts, context.discoveredPaths, lastPathCount);
+		const nodeNeighbours = context.graph.neighbours(nodeId);
+		let pathPotential = 0;
+		for (const neighbour of nodeNeighbours) {
+			const visitedBy = context.visitedByFrontier.get(neighbour);
+			if (visitedBy !== void 0 && visitedBy !== context.frontierIndex) pathPotential++;
+		}
+		if (!inPhase2) return context.degree / (1 + pathPotential);
+		const salience = salienceCounts.get(nodeId) ?? 0;
+		return context.degree / (1 + pathPotential) * (1 / (1 + SALIENCE_WEIGHT * salience));
+	}
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: mazePriority
+	});
+}
 //#endregion
 //#region src/expansion/tide.ts
 /**
@@ -930,6 +951,25 @@ function tide(graph, seeds, config) {
 		priority: tidePriority
 	});
 }
+/**
+* Run TIDE expansion asynchronously.
+*
+* Note: the TIDE priority function accesses `context.graph` to retrieve
+* neighbour lists and per-neighbour degrees. Full async equivalence
+* requires PriorityContext refactoring (Phase 4b deferred). This export
+* establishes the async API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function tideAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: tidePriority
+	});
+}
 //#endregion
 //#region src/expansion/lace.ts
 /**
@@ -960,6 +1000,27 @@ function lace(graph, seeds, config) {
 		priority
 	});
 }
+/**
+* Run LACE expansion asynchronously.
+*
+* Note: the LACE priority function accesses `context.graph` via
+* `avgFrontierMI`. Full async equivalence requires PriorityContext
+* refactoring (Phase 4b deferred). This export establishes the async
+* API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - LACE configuration combined with async runner options
+* @returns Promise resolving to the expansion result
+*/
+async function laceAsync(graph, seeds, config) {
+	const { mi = jaccard, ...restConfig } = config ?? {};
+	const priority = (nodeId, context) => lacePriority(nodeId, context, mi);
+	return baseAsync(graph, seeds, {
+		...restConfig,
+		priority
+	});
+}
 //#endregion
 //#region src/expansion/warp.ts
 /**
@@ -992,6 +1053,25 @@ function warp(graph, seeds, config) {
 		priority: warpPriority
 	});
 }
+/**
+* Run WARP expansion asynchronously.
+*
+* Note: the WARP priority function accesses `context.graph` via
+* `countCrossFrontierNeighbours`. Full async equivalence requires
+* PriorityContext refactoring (Phase 4b deferred). This export
+* establishes the async API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function warpAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: warpPriority
+	});
+}
 //#endregion
 //#region src/expansion/fuse.ts
 /**
@@ -1024,6 +1104,27 @@ function fuse(graph, seeds, config) {
 		priority
 	});
 }
+/**
+* Run FUSE expansion asynchronously.
+*
+* Note: the FUSE priority function accesses `context.graph` via
+* `avgFrontierMI`. Full async equivalence requires PriorityContext
+* refactoring (Phase 4b deferred). This export establishes the async
+* API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - FUSE configuration combined with async runner options
+* @returns Promise resolving to the expansion result
+*/
+async function fuseAsync(graph, seeds, config) {
+	const { mi = jaccard, salienceWeight = .5, ...restConfig } = config ?? {};
+	const priority = (nodeId, context) => fusePriority(nodeId, context, mi, salienceWeight);
+	return baseAsync(graph, seeds, {
+		...restConfig,
+		priority
+	});
+}
 //#endregion
 //#region src/expansion/sift.ts
 /**
@@ -1056,6 +1157,27 @@ function sift(graph, seeds, config) {
 		priority
 	});
 }
+/**
+* Run SIFT expansion asynchronously.
+*
+* Note: the SIFT priority function accesses `context.graph` via
+* `avgFrontierMI`. Full async equivalence requires PriorityContext
+* refactoring (Phase 4b deferred). This export establishes the async
+* API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - SIFT (REACHConfig) configuration combined with async runner options
+* @returns Promise resolving to the expansion result
+*/
+async function siftAsync(graph, seeds, config) {
+	const { mi = jaccard, miThreshold = .25, ...restConfig } = config ?? {};
+	const priority = (nodeId, context) => siftPriority(nodeId, context, mi, miThreshold);
+	return baseAsync(graph, seeds, {
+		...restConfig,
+		priority
+	});
+}
 //#endregion
 //#region src/expansion/flux.ts
 /**
@@ -1112,9 +1234,36 @@ function flux(graph, seeds, config) {
 		priority
 	});
 }
+/**
+* Run FLUX expansion asynchronously.
+*
+* Note: the FLUX priority function accesses `context.graph` to compute
+* local density and cross-frontier bridge scores. Full async equivalence
+* requires PriorityContext refactoring (Phase 4b deferred). This export
+* establishes the async API surface.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - FLUX (MAZEConfig) configuration combined with async runner options
+* @returns Promise resolving to the expansion result
+*/
+async function fluxAsync(graph, seeds, config) {
+	const { densityThreshold = .5, bridgeThreshold = .3, ...restConfig } = config ?? {};
+	const priority = (nodeId, context) => fluxPriority(nodeId, context, densityThreshold, bridgeThreshold);
+	return baseAsync(graph, seeds, {
+		...restConfig,
+		priority
+	});
+}
 //#endregion
 //#region src/expansion/standard-bfs.ts
 /**
+* BFS priority: discovery iteration order (FIFO).
+*/
+function bfsPriority(_nodeId, context) {
+	return context.iteration;
+}
+/**
 * Run standard BFS expansion (FIFO discovery order).
 *
 * @param graph - Source graph
@@ -1123,17 +1272,35 @@ function flux(graph, seeds, config) {
 * @returns Expansion result with discovered paths
 */
 function standardBfs(graph, seeds, config) {
-	const bfsPriority = (_nodeId, context) => {
-		return context.iteration;
-	};
 	return base(graph, seeds, {
 		...config,
 		priority: bfsPriority
 	});
 }
+/**
+* Run standard BFS expansion asynchronously (FIFO discovery order).
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function standardBfsAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: bfsPriority
+	});
+}
 //#endregion
 //#region src/expansion/frontier-balanced.ts
 /**
+* Frontier-balanced priority: frontier index dominates, then discovery iteration.
+* Scales frontier index by 1e9 to ensure round-robin ordering across frontiers.
+*/
+function balancedPriority(_nodeId, context) {
+	return context.frontierIndex * 1e9 + context.iteration;
+}
+/**
 * Run frontier-balanced expansion (round-robin across frontiers).
 *
 * @param graph - Source graph
@@ -1142,14 +1309,25 @@ function standardBfs(graph, seeds, config) {
 * @returns Expansion result with discovered paths
 */
 function frontierBalanced(graph, seeds, config) {
-	const balancedPriority = (_nodeId, context) => {
-		return context.frontierIndex * 1e9 + context.iteration;
-	};
 	return base(graph, seeds, {
 		...config,
 		priority: balancedPriority
 	});
 }
+/**
+* Run frontier-balanced expansion asynchronously (round-robin across frontiers).
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function frontierBalancedAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: balancedPriority
+	});
+}
 //#endregion
 //#region src/expansion/random-priority.ts
 /**
@@ -1169,6 +1347,12 @@ function seededRandom$1(input, seed = 0) {
 	return (h >>> 0) / 4294967295;
 }
 /**
+* Build a seeded random priority function for a given seed value.
+*/
+function makeRandomPriorityFn(seed) {
+	return (nodeId) => seededRandom$1(nodeId, seed);
+}
+/**
 * Run random-priority expansion (null hypothesis baseline).
 *
 * @param graph - Source graph
@@ -1178,12 +1362,24 @@ function seededRandom$1(input, seed = 0) {
 */
 function randomPriority(graph, seeds, config) {
 	const { seed = 0 } = config ?? {};
-	const randomPriorityFn = (nodeId, context) => {
-		return seededRandom$1(nodeId, seed);
-	};
 	return base(graph, seeds, {
 		...config,
-		priority: randomPriorityFn
+		priority: makeRandomPriorityFn(seed)
+	});
+}
+/**
+* Run random-priority expansion asynchronously (null hypothesis baseline).
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function randomPriorityAsync(graph, seeds, config) {
+	const { seed = 0 } = config ?? {};
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: makeRandomPriorityFn(seed)
 	});
 }
 //#endregion
@@ -1215,6 +1411,20 @@ function dfsPriority(graph, seeds, config) {
 		priority: dfsPriorityFn
 	});
 }
+/**
+* Run DFS-priority expansion asynchronously (LIFO discovery order).
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function dfsPriorityAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: dfsPriorityFn
+	});
+}
 //#endregion
 //#region src/expansion/k-hop.ts
 /**
@@ -1572,6 +1782,74 @@ function parse(graph, paths, config) {
 	};
 }
 /**
+* Rank paths using async PARSE (Path-Aware Ranking via Salience Estimation).
+*
+* Async variant suitable for use with remote or lazy graph data sources.
+* Computes geometric mean of edge MI scores for each path using Promise.all
+* for parallelism, then sorts by salience (highest first).
+*
+* @param graph - Async source graph
+* @param paths - Paths to rank
+* @param config - Configuration options
+* @returns Ranked paths with statistics
+*/
+async function parseAsync(graph, paths, config) {
+	const startTime = performance.now();
+	const { mi = jaccardAsync, epsilon = 1e-10 } = config ?? {};
+	const rankedPaths = [];
+	for (const path of paths) {
+		const salience = await computePathSalienceAsync(graph, path, mi, epsilon);
+		rankedPaths.push({
+			...path,
+			salience
+		});
+	}
+	rankedPaths.sort((a, b) => b.salience - a.salience);
+	const endTime = performance.now();
+	const saliences = rankedPaths.map((p) => p.salience);
+	const meanSalience = saliences.length > 0 ? saliences.reduce((a, b) => a + b, 0) / saliences.length : 0;
+	const sortedSaliences = [...saliences].sort((a, b) => a - b);
+	const mid = Math.floor(sortedSaliences.length / 2);
+	const medianSalience = sortedSaliences.length > 0 ? sortedSaliences.length % 2 !== 0 ? sortedSaliences[mid] ?? 0 : ((sortedSaliences[mid - 1] ?? 0) + (sortedSaliences[mid] ?? 0)) / 2 : 0;
+	const maxSalience = sortedSaliences.length > 0 ? sortedSaliences[sortedSaliences.length - 1] ?? 0 : 0;
+	const minSalience = sortedSaliences.length > 0 ? sortedSaliences[0] ?? 0 : 0;
+	return {
+		paths: rankedPaths,
+		stats: {
+			pathsRanked: rankedPaths.length,
+			meanSalience,
+			medianSalience,
+			maxSalience,
+			minSalience,
+			durationMs: endTime - startTime
+		}
+	};
+}
+/**
+* Compute salience for a single path asynchronously.
+*
+* Uses geometric mean of edge MI scores for length-unbiased ranking.
+* Edge MI values are computed in parallel via Promise.all.
+*/
+async function computePathSalienceAsync(graph, path, mi, epsilon) {
+	const nodes = path.nodes;
+	if (nodes.length < 2) return epsilon;
+	const edgeMIs = await Promise.all(nodes.slice(0, -1).map((source, i) => {
+		const target = nodes[i + 1];
+		if (target !== void 0) return mi(graph, source, target);
+		return Promise.resolve(epsilon);
+	}));
+	let productMi = 1;
+	let edgeCount = 0;
+	for (const edgeMi of edgeMIs) {
+		productMi *= Math.max(epsilon, edgeMi);
+		edgeCount++;
+	}
+	if (edgeCount === 0) return epsilon;
+	const salience = Math.pow(productMi, 1 / edgeCount);
+	return Math.max(epsilon, Math.min(1, salience));
+}
+/**
 * Compute salience for a single path.
 *
 * Uses geometric mean of edge MI scores for length-unbiased ranking.
@@ -1619,6 +1897,29 @@ function adamicAdar(graph, source, target, config) {
 	}
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of Adamic-Adar index for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then fetches degree for each common
+* neighbour to compute the inverse-log-degree weighted sum.
+*/
+async function adamicAdarAsync(graph, source, target, config) {
+	const { epsilon = 1e-10, normalise = true } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	const commonNeighbours = [];
+	for (const n of srcSet) if (tgtSet.has(n)) commonNeighbours.push(n);
+	if (commonNeighbours.length === 0) return epsilon;
+	const degrees = await Promise.all(commonNeighbours.map((n) => graph.degree(n)));
+	let score = 0;
+	for (const degree of degrees) score += 1 / Math.log(degree + 1);
+	if (normalise) {
+		const maxScore = commonNeighbours.length / Math.log(2);
+		score = score / maxScore;
+	}
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/cosine.ts
 /**
@@ -1640,6 +1941,23 @@ function cosine(graph, source, target, config) {
 	const score = intersection / denominator;
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of cosine similarity for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then applies the same formula.
+*/
+async function cosineAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const denominator = Math.sqrt(srcSet.size) * Math.sqrt(tgtSet.size);
+	if (denominator === 0) return 0;
+	const score = intersection / denominator;
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/sorensen.ts
 /**
@@ -1661,6 +1979,23 @@ function sorensen(graph, source, target, config) {
 	const score = 2 * intersection / denominator;
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of Sorensen-Dice coefficient for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then applies the same formula.
+*/
+async function sorensenAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const denominator = srcSet.size + tgtSet.size;
+	if (denominator === 0) return 0;
+	const score = 2 * intersection / denominator;
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/resource-allocation.ts
 /**
@@ -1686,6 +2021,29 @@ function resourceAllocation(graph, source, target, config) {
 	}
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of Resource Allocation index for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then fetches degree for each common
+* neighbour to compute the inverse-degree weighted sum.
+*/
+async function resourceAllocationAsync(graph, source, target, config) {
+	const { epsilon = 1e-10, normalise = true } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	const commonNeighbours = [];
+	for (const n of srcSet) if (tgtSet.has(n)) commonNeighbours.push(n);
+	if (commonNeighbours.length === 0) return epsilon;
+	const degrees = await Promise.all(commonNeighbours.map((n) => graph.degree(n)));
+	let score = 0;
+	for (const degree of degrees) if (degree > 0) score += 1 / degree;
+	if (normalise) {
+		const maxScore = commonNeighbours.length;
+		score = score / maxScore;
+	}
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/overlap-coefficient.ts
 /**
@@ -1707,6 +2065,23 @@ function overlapCoefficient(graph, source, target, config) {
 	const score = intersection / denominator;
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of Overlap Coefficient for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then applies the same formula.
+*/
+async function overlapCoefficientAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const denominator = Math.min(srcSet.size, tgtSet.size);
+	if (denominator === 0) return 0;
+	const score = intersection / denominator;
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/hub-promoted.ts
 /**
@@ -1728,6 +2103,28 @@ function hubPromoted(graph, source, target, config) {
 	const score = intersection / denominator;
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of Hub Promoted index for use with async graph data sources.
+*
+* Fetches both neighbourhoods and degrees concurrently, then applies the same formula.
+*/
+async function hubPromotedAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr, sourceDegree, targetDegree] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		graph.degree(source),
+		graph.degree(target)
+	]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const denominator = Math.min(sourceDegree, targetDegree);
+	if (denominator === 0) return 0;
+	const score = intersection / denominator;
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/scale.ts
 /**
@@ -1744,6 +2141,31 @@ function scale(graph, source, target, config) {
 	const score = jaccardScore / density;
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of SCALE MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods, node count, and edge count concurrently.
+*/
+async function scaleAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr, n, m] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		graph.nodeCount,
+		graph.edgeCount
+	]);
+	const srcSet = new Set(sourceArr.filter((node) => node !== target));
+	const tgtSet = new Set(targetArr.filter((node) => node !== source));
+	let intersection = 0;
+	for (const node of srcSet) if (tgtSet.has(node)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	const possibleEdges = n * (n - 1);
+	const density = possibleEdges > 0 ? (graph.directed ? m : 2 * m) / possibleEdges : 0;
+	if (density === 0) return epsilon;
+	const score = jaccardScore / density;
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/skew.ts
 /**
@@ -1760,6 +2182,31 @@ function skew(graph, source, target, config) {
 	const score = jaccardScore * sourceIdf * targetIdf;
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of SKEW MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods, degrees, and node count concurrently.
+*/
+async function skewAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr, N, sourceDegree, targetDegree] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		graph.nodeCount,
+		graph.degree(source),
+		graph.degree(target)
+	]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	const sourceIdf = Math.log(N / (sourceDegree + 1));
+	const targetIdf = Math.log(N / (targetDegree + 1));
+	const score = jaccardScore * sourceIdf * targetIdf;
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/span.ts
 /**
@@ -1773,6 +2220,40 @@ function span(graph, source, target, config) {
 	const score = jaccardScore * (1 - Math.max(sourceCc, targetCc));
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of SPAN MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then computes the clustering
+* coefficient for each endpoint from the collected neighbour arrays.
+*/
+async function spanAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	const computeClusteringCoefficient = async (nodeId, neighbourArr) => {
+		const degree = neighbourArr.length;
+		if (degree < 2) return 0;
+		const pairs = [];
+		for (let i = 0; i < neighbourArr.length; i++) for (let j = i + 1; j < neighbourArr.length; j++) {
+			const u = neighbourArr[i];
+			const v = neighbourArr[j];
+			if (u !== void 0 && v !== void 0) pairs.push([u, v]);
+		}
+		const edgeResults = await Promise.all(pairs.flatMap(([u, v]) => [graph.getEdge(u, v), graph.getEdge(v, u)]));
+		let triangleCount = 0;
+		for (let i = 0; i < pairs.length; i++) if (edgeResults[2 * i] !== void 0 || edgeResults[2 * i + 1] !== void 0) triangleCount++;
+		const possibleTriangles = degree * (degree - 1) / 2;
+		return triangleCount / possibleTriangles;
+	};
+	const [sourceCc, targetCc] = await Promise.all([computeClusteringCoefficient(source, sourceArr), computeClusteringCoefficient(target, targetArr)]);
+	const score = jaccardScore * (1 - Math.max(sourceCc, targetCc));
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/etch.ts
 /**
@@ -1788,6 +2269,37 @@ function etch(graph, source, target, config) {
 	const score = jaccardScore * Math.log(graph.edgeCount / edgeTypeCount);
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of ETCH MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods and edge data concurrently, then counts
+* edges of the same type by iterating the async edge stream.
+*/
+async function etchAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr, edge] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		graph.getEdge(source, target)
+	]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	if (edge?.type === void 0) return Math.max(epsilon, jaccardScore);
+	const edgeType = edge.type;
+	let edgeTypeCount = 0;
+	let totalEdges = 0;
+	for await (const e of graph.edges()) {
+		totalEdges++;
+		if (e.type === edgeType) edgeTypeCount++;
+	}
+	if (edgeTypeCount === 0) return Math.max(epsilon, jaccardScore);
+	const score = jaccardScore * Math.log(totalEdges / edgeTypeCount);
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/notch.ts
 /**
@@ -1807,6 +2319,44 @@ function notch(graph, source, target, config) {
 	const score = jaccardScore * sourceRarity * targetRarity;
 	return Math.max(epsilon, score);
 }
+/**
+* Async variant of NOTCH MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods and node data concurrently, then counts
+* nodes of each type by iterating the async node stream.
+*/
+async function notchAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr, sourceNode, targetNode] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		graph.getNode(source),
+		graph.getNode(target)
+	]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	if (sourceNode?.type === void 0 || targetNode?.type === void 0) return Math.max(epsilon, jaccardScore);
+	const sourceType = sourceNode.type;
+	const targetType = targetNode.type;
+	let totalNodes = 0;
+	let sourceTypeCount = 0;
+	let targetTypeCount = 0;
+	for await (const nodeId of graph.nodeIds()) {
+		totalNodes++;
+		const node = await graph.getNode(nodeId);
+		if (node?.type === sourceType) sourceTypeCount++;
+		if (node?.type === targetType) targetTypeCount++;
+	}
+	if (sourceTypeCount === 0 || targetTypeCount === 0) return Math.max(epsilon, jaccardScore);
+	const sourceRarity = Math.log(totalNodes / sourceTypeCount);
+	const targetRarity = Math.log(totalNodes / targetTypeCount);
+	const score = jaccardScore * sourceRarity * targetRarity;
+	return Math.max(epsilon, score);
+}
 //#endregion
 //#region src/ranking/mi/adaptive.ts
 /**
@@ -1839,6 +2389,38 @@ function adaptive(graph, source, target, config) {
 	const score = (structuralWeight * structural + degreeWeight * degreeComponent + overlapWeight * overlap) / totalWeight;
 	return Math.max(epsilon, Math.min(1, score));
 }
+/**
+* Async variant of Adaptive MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then delegates degree-weighted
+* component to the async Adamic-Adar variant.
+*/
+async function adaptiveAsync(graph, source, target, config) {
+	const { epsilon = 1e-10, structuralWeight = .4, degreeWeight = .3, overlapWeight = .3 } = config ?? {};
+	const [sourceArr, targetArr, degreeComponent] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		adamicAdarAsync(graph, source, target, {
+			epsilon,
+			normalise: true
+		})
+	]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	const structural = srcSet.size === 0 && tgtSet.size === 0 ? 0 : Math.max(epsilon, jaccardScore);
+	let overlap;
+	if (srcSet.size > 0 && tgtSet.size > 0) {
+		const minDegree = Math.min(srcSet.size, tgtSet.size);
+		overlap = minDegree > 0 ? intersection / minDegree : epsilon;
+	} else overlap = epsilon;
+	const totalWeight = structuralWeight + degreeWeight + overlapWeight;
+	const score = (structuralWeight * structural + degreeWeight * degreeComponent + overlapWeight * overlap) / totalWeight;
+	return Math.max(epsilon, Math.min(1, score));
+}
 //#endregion
 //#region src/ranking/baselines/utils.ts
 /**
@@ -3333,6 +3915,6 @@ function filterSubgraph(graph, options) {
 	return result;
 }
 //#endregion
-export { AdjacencyMapGraph, GPUContext, GPUNotAvailableError, PriorityQueue, _computeMean, adamicAdar, adaptive, approximateClusteringCoefficient, assertWebGPUAvailable, base, baseAsync, batchClusteringCoefficients, betweenness, bfs, bfsWithPath, communicability, computeJaccard, computeTrussNumbers, cosine, countEdgesOfType, countNodesOfType, createGPUContext, createResultBuffer, csrToGPUBuffers, degreeSum, detectWebGPU, dfs, dfsPriority, dfsPriorityFn, dfsWithPath, dome, domeHighDegree, edge, entropyFromCounts, enumerateMotifs, enumerateMotifsWithInstances, etch, extractEgoNetwork, extractInducedSubgraph, extractKCore, extractKTruss, filterSubgraph, flux, frontierBalanced, fuse, getGPUContext, getMotifName, graphToCSR, grasp, hae, hittingTime, hubPromoted, isWebGPUAvailable, jaccard, jaccardArithmetic, kHop, katz, lace, localClusteringCoefficient, localTypeEntropy, maze, miniBatchKMeans, neighbourIntersection, neighbourOverlap, neighbourSet, normaliseFeatures, normaliseFeatures as zScoreNormalise, normalisedEntropy, notch, overlapCoefficient, pagerank, parse, pipe, randomPriority, randomRanking, randomWalk, reach, readBufferToCPU, resistanceDistance, resourceAllocation, sage, scale, shannonEntropy, shortest, sift, skew, sorensen, span, standardBfs, stratified, tide, warp, widestPath };
+export { AdjacencyMapGraph, GPUContext, GPUNotAvailableError, PriorityQueue, _computeMean, adamicAdar, adamicAdarAsync, adaptive, adaptiveAsync, approximateClusteringCoefficient, assertWebGPUAvailable, base, baseAsync, batchClusteringCoefficients, betweenness, bfs, bfsWithPath, collectAsyncIterable, communicability, computeJaccard, computeTrussNumbers, cosine, cosineAsync, countEdgesOfType, countNodesOfType, createGPUContext, createResultBuffer, csrToGPUBuffers, defaultYieldStrategy, degreeSum, detectWebGPU, dfs, dfsPriority, dfsPriorityAsync, dfsPriorityFn, dfsWithPath, dome, domeAsync, domeHighDegree, domeHighDegreeAsync, edge, edgeAsync, entropyFromCounts, enumerateMotifs, enumerateMotifsWithInstances, etch, etchAsync, extractEgoNetwork, extractInducedSubgraph, extractKCore, extractKTruss, filterSubgraph, flux, fluxAsync, frontierBalanced, frontierBalancedAsync, fuse, fuseAsync, getGPUContext, getMotifName, graphToCSR, grasp, hae, haeAsync, hittingTime, hubPromoted, hubPromotedAsync, isWebGPUAvailable, jaccard, jaccardArithmetic, jaccardAsync, kHop, katz, lace, laceAsync, localClusteringCoefficient, localTypeEntropy, maze, mazeAsync, miniBatchKMeans, neighbourIntersection, neighbourOverlap, neighbourSet, normaliseFeatures, normaliseFeatures as zScoreNormalise, normalisedEntropy, notch, notchAsync, opDegree, opGetEdge, opGetNode, opHasNode, opNeighbours, opProgress, opYield, overlapCoefficient, overlapCoefficientAsync, pagerank, parse, parseAsync, pipe, pipeAsync, randomPriority, randomPriorityAsync, randomRanking, randomWalk, reach, reachAsync, readBufferToCPU, resistanceDistance, resolveAsyncOp, resolveSyncOp, resourceAllocation, resourceAllocationAsync, runAsync, runSync, sage, sageAsync, scale, scaleAsync, shannonEntropy, shortest, sift, siftAsync, skew, skewAsync, sorensen, sorensenAsync, span, spanAsync, standardBfs, standardBfsAsync, stratified, tide, tideAsync, warp, warpAsync, widestPath };
 
 //# sourceMappingURL=index.js.map