graphwise 1.8.0 → 1.9.0

package/dist/index/index.cjs

@@ -1,4058 +1,159 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_graph = require("../graph/index.cjs");
+const require_gpu = require("../gpu-Y6owRVMi.cjs");
+const require_adjacency_map = require("../adjacency-map-JqBnMNkF.cjs");
+require("../graph/index.cjs");
 const require_traversal = require("../traversal/index.cjs");
-const require_structures = require("../structures/index.cjs");
-const require_kmeans = require("../kmeans-BIgSyGKu.cjs");
-const require_utils = require("../utils/index.cjs");
+const require_priority_queue = require("../priority-queue-BIiD1L0k.cjs");
+require("../structures/index.cjs");
+const require_utils = require("../utils-CDtCcsyF.cjs");
+const require_ops = require("../ops-djAsQQSh.cjs");
+const require_expansion = require("../expansion-DaTroIyv.cjs");
+const require_kmeans = require("../kmeans-B8x9D1kt.cjs");
+const require_utils$1 = require("../utils/index.cjs");
+const require_jaccard = require("../jaccard-Bys9_dGW.cjs");
+const require_ranking = require("../ranking-DVvajgUZ.cjs");
+const require_ranking_mi = require("../ranking/mi/index.cjs");
 const require_seeds = require("../seeds/index.cjs");
-const require_gpu = require("../gpu/index.cjs");
-const require_async = require("../async/index.cjs");
-//#region src/expansion/base-helpers.ts
-/**
-* Check whether expansion should continue given current progress.
-*
-* Returns shouldContinue=false as soon as any configured limit is reached,
-* along with the appropriate termination reason.
-*
-* @param iterations - Number of iterations completed so far
-* @param nodesVisited - Number of distinct nodes visited so far
-* @param pathsFound - Number of paths discovered so far
-* @param limits - Configured expansion limits (0 = unlimited)
-* @returns Whether to continue and the termination reason if stopping
-*/
-function continueExpansion(iterations, nodesVisited, pathsFound, limits) {
-	if (limits.maxIterations > 0 && iterations >= limits.maxIterations) return {
-		shouldContinue: false,
-		termination: "limit"
-	};
-	if (limits.maxNodes > 0 && nodesVisited >= limits.maxNodes) return {
-		shouldContinue: false,
-		termination: "limit"
-	};
-	if (limits.maxPaths > 0 && pathsFound >= limits.maxPaths) return {
-		shouldContinue: false,
-		termination: "limit"
-	};
-	return {
-		shouldContinue: true,
-		termination: "exhausted"
-	};
-}
-/**
-* Reconstruct path from collision point.
-*
-* Traces backwards through the predecessor maps of both frontiers from the
-* collision node, then concatenates the two halves to form the full path.
-*
-* @param collisionNode - The node where the two frontiers met
-* @param frontierA - Index of the first frontier
-* @param frontierB - Index of the second frontier
-* @param predecessors - Predecessor maps, one per frontier
-* @param seeds - Seed nodes, one per frontier
-* @returns The reconstructed path, or null if seeds are missing
-*/
-function reconstructPath$1(collisionNode, frontierA, frontierB, predecessors, seeds) {
-	const pathA = [collisionNode];
-	const predA = predecessors[frontierA];
-	if (predA !== void 0) {
-		let node = collisionNode;
-		let next = predA.get(node);
-		while (next !== null && next !== void 0) {
-			node = next;
-			pathA.unshift(node);
-			next = predA.get(node);
-		}
-	}
-	const pathB = [];
-	const predB = predecessors[frontierB];
-	if (predB !== void 0) {
-		let node = collisionNode;
-		let next = predB.get(node);
-		while (next !== null && next !== void 0) {
-			node = next;
-			pathB.push(node);
-			next = predB.get(node);
-		}
-	}
-	const fullPath = [...pathA, ...pathB];
-	const seedA = seeds[frontierA];
-	const seedB = seeds[frontierB];
-	if (seedA === void 0 || seedB === void 0) return null;
-	return {
-		fromSeed: seedA,
-		toSeed: seedB,
-		nodes: fullPath
-	};
-}
-/**
-* Create an empty expansion result for early termination (e.g. no seeds given).
-*
-* @param algorithm - Name of the algorithm producing this result
-* @param startTime - performance.now() timestamp taken before the algorithm began
-* @returns An ExpansionResult with zero paths and zero stats
-*/
-function emptyResult$2(algorithm, startTime) {
-	return {
-		paths: [],
-		sampledNodes: /* @__PURE__ */ new Set(),
-		sampledEdges: /* @__PURE__ */ new Set(),
-		visitedPerFrontier: [],
-		stats: {
-			iterations: 0,
-			nodesVisited: 0,
-			edgesTraversed: 0,
-			pathsFound: 0,
-			durationMs: performance.now() - startTime,
-			algorithm,
-			termination: "exhausted"
-		}
-	};
-}
-//#endregion
-//#region src/expansion/base-core.ts
-/**
-* Default priority function — degree-ordered (DOME).
-*
-* Lower degree = higher priority, so sparse nodes are explored before hubs.
-*/
-function degreePriority(_nodeId, context) {
-	return context.degree;
-}
-/**
-* Generator core of the BASE expansion algorithm.
-*
-* Yields GraphOp objects to request graph data, allowing the caller to
-* provide a sync or async runner. The optional `graphRef` parameter is
-* required when the priority function accesses `context.graph` — it is
-* populated in sync mode by `base()`. In async mode (Phase 4+), a proxy
-* graph may be supplied instead.
-*
-* @param graphMeta - Immutable graph metadata (directed, nodeCount, edgeCount)
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration (priority, limits, debug)
-* @param graphRef - Optional real graph reference for context.graph in priority functions
-* @returns An ExpansionResult with all discovered paths and statistics
-*/
-function* baseCore(graphMeta, seeds, config, graphRef) {
-	const startTime = performance.now();
-	const { maxNodes = 0, maxIterations = 0, maxPaths = 0, priority = degreePriority, debug = false } = config ?? {};
-	if (seeds.length === 0) return emptyResult$2("base", startTime);
-	const numFrontiers = seeds.length;
-	const allVisited = /* @__PURE__ */ new Set();
-	const combinedVisited = /* @__PURE__ */ new Map();
-	const visitedByFrontier = [];
-	const predecessors = [];
-	const queues = [];
-	for (let i = 0; i < numFrontiers; i++) {
-		visitedByFrontier.push(/* @__PURE__ */ new Map());
-		predecessors.push(/* @__PURE__ */ new Map());
-		queues.push(new require_structures.PriorityQueue());
-		const seed = seeds[i];
-		if (seed === void 0) continue;
-		const seedNode = seed.id;
-		predecessors[i]?.set(seedNode, null);
-		combinedVisited.set(seedNode, i);
-		allVisited.add(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,
-			frontierIndex: i,
-			predecessor: null
-		}, seedPriority);
-	}
-	const sampledEdgeMap = /* @__PURE__ */ new Map();
-	const discoveredPaths = [];
-	let iterations = 0;
-	let edgesTraversed = 0;
-	let termination = "exhausted";
-	const limits = {
-		maxIterations,
-		maxNodes,
-		maxPaths
-	};
-	for (;;) {
-		const check = continueExpansion(iterations, allVisited.size, discoveredPaths.length, limits);
-		if (!check.shouldContinue) {
-			termination = check.termination;
-			break;
-		}
-		let lowestPriority = Number.POSITIVE_INFINITY;
-		let activeFrontier = -1;
-		for (let i = 0; i < numFrontiers; i++) {
-			const queue = queues[i];
-			if (queue !== void 0 && !queue.isEmpty()) {
-				const peek = queue.peek();
-				if (peek !== void 0 && peek.priority < lowestPriority) {
-					lowestPriority = peek.priority;
-					activeFrontier = i;
-				}
-			}
-		}
-		if (activeFrontier < 0) {
-			termination = "exhausted";
-			break;
-		}
-		const queue = queues[activeFrontier];
-		if (queue === void 0) break;
-		const entry = queue.pop();
-		if (entry === void 0) break;
-		const { nodeId, predecessor } = entry.item;
-		const frontierVisited = visitedByFrontier[activeFrontier];
-		if (frontierVisited === void 0 || frontierVisited.has(nodeId)) continue;
-		frontierVisited.set(nodeId, activeFrontier);
-		combinedVisited.set(nodeId, activeFrontier);
-		if (predecessor !== null) {
-			const predMap = predecessors[activeFrontier];
-			if (predMap !== void 0) predMap.set(nodeId, predecessor);
-		}
-		allVisited.add(nodeId);
-		if (debug) console.log(`[BASE] Iteration ${String(iterations)}: Frontier ${String(activeFrontier)} visiting ${nodeId}`);
-		for (let otherFrontier = 0; otherFrontier < numFrontiers; otherFrontier++) {
-			if (otherFrontier === activeFrontier) continue;
-			const otherVisited = visitedByFrontier[otherFrontier];
-			if (otherVisited === void 0) continue;
-			if (otherVisited.has(nodeId)) {
-				const path = reconstructPath$1(nodeId, activeFrontier, otherFrontier, predecessors, seeds);
-				if (path !== null) {
-					discoveredPaths.push(path);
-					if (debug) console.log(`[BASE] Path found: ${path.nodes.join(" -> ")}`);
-				}
-			}
-		}
-		const neighbours = yield* require_async.opNeighbours(nodeId);
-		for (const neighbour of neighbours) {
-			edgesTraversed++;
-			const [s, t] = nodeId < neighbour ? [nodeId, neighbour] : [neighbour, nodeId];
-			let targets = sampledEdgeMap.get(s);
-			if (targets === void 0) {
-				targets = /* @__PURE__ */ new Set();
-				sampledEdgeMap.set(s, targets);
-			}
-			targets.add(t);
-			const fv = visitedByFrontier[activeFrontier];
-			if (fv === void 0 || fv.has(neighbour)) continue;
-			const neighbourDegree = yield* require_async.opDegree(neighbour);
-			const neighbourPriority = priority(neighbour, buildPriorityContext(neighbour, activeFrontier, combinedVisited, allVisited, discoveredPaths, iterations + 1, neighbourDegree, graphRef));
-			queue.push({
-				nodeId: neighbour,
-				frontierIndex: activeFrontier,
-				predecessor: nodeId
-			}, neighbourPriority);
-		}
-		iterations++;
-	}
-	const endTime = performance.now();
-	const visitedPerFrontier = visitedByFrontier.map((m) => new Set(m.keys()));
-	const edgeTuples = /* @__PURE__ */ new Set();
-	for (const [source, targets] of sampledEdgeMap) for (const target of targets) edgeTuples.add([source, target]);
-	return {
-		paths: discoveredPaths,
-		sampledNodes: allVisited,
-		sampledEdges: edgeTuples,
-		visitedPerFrontier,
-		stats: {
-			iterations,
-			nodesVisited: allVisited.size,
-			edgesTraversed,
-			pathsFound: discoveredPaths.length,
-			durationMs: endTime - startTime,
-			algorithm: "base",
-			termination
-		}
-	};
-}
-/**
-* Create a sentinel ReadableGraph that throws if any member is accessed.
-*
-* Used in async mode when no graphRef is provided. Gives a clear error
-* message rather than silently returning incorrect results if a priority
-* function attempts to access `context.graph` before Phase 4b introduces
-* a real async proxy.
-*/
-function makeNoGraphSentinel() {
-	const msg = "Priority function accessed context.graph in async mode without a graph proxy. Pass a graphRef or use a priority function that does not access context.graph.";
-	const fail = () => {
-		throw new Error(msg);
-	};
-	return {
-		get directed() {
-			return fail();
-		},
-		get nodeCount() {
-			return fail();
-		},
-		get edgeCount() {
-			return fail();
-		},
-		hasNode: fail,
-		getNode: fail,
-		nodeIds: fail,
-		neighbours: fail,
-		degree: fail,
-		getEdge: fail,
-		edges: fail
-	};
-}
-/**
-* Build a PriorityContext for a node using a pre-fetched degree.
-*
-* When `graphRef` is provided (sync mode), it is used as `context.graph` so
-* priority functions can access the graph directly. When it is absent (async
-* mode), a Proxy is used in its place that throws a clear error if any
-* property is accessed — this prevents silent failures until Phase 4b
-* introduces a real async proxy graph.
-*/
-function buildPriorityContext(_nodeId, frontierIndex, combinedVisited, allVisited, discoveredPaths, iteration, degree, graphRef) {
-	return {
-		graph: graphRef ?? makeNoGraphSentinel(),
-		degree,
-		frontierIndex,
-		visitedByFrontier: combinedVisited,
-		allVisited,
-		discoveredPaths,
-		iteration
-	};
-}
-//#endregion
-//#region src/expansion/base.ts
-/**
-* Run BASE expansion synchronously.
-*
-* Delegates to baseCore + runSync. Behaviour is identical to the previous
-* direct implementation — all existing callers are unaffected.
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function base(graph, seeds, config) {
-	return require_async.runSync(baseCore({
-		directed: graph.directed,
-		nodeCount: graph.nodeCount,
-		edgeCount: graph.edgeCount
-	}, seeds, config, graph), graph);
-}
-/**
-* Run BASE expansion asynchronously.
-*
-* Delegates to baseCore + runAsync. Supports:
-* - Cancellation via AbortSignal (config.signal)
-* - Progress callbacks (config.onProgress)
-* - Custom cooperative yield strategies (config.yieldStrategy)
-*
-* Note: priority functions that access `context.graph` are not supported in
-* async mode without a graph proxy (Phase 4b). The default degree-based
-* priority (DOME) does not access context.graph and works correctly.
-*
-* @param graph - Async source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion and async runner configuration
-* @returns Promise resolving to the expansion result
-*/
-async function baseAsync(graph, seeds, config) {
-	const [nodeCount, edgeCount] = await Promise.all([graph.nodeCount, graph.edgeCount]);
-	const gen = baseCore({
-		directed: graph.directed,
-		nodeCount,
-		edgeCount
-	}, seeds, config);
-	const runnerOptions = {};
-	if (config?.signal !== void 0) runnerOptions.signal = config.signal;
-	if (config?.onProgress !== void 0) runnerOptions.onProgress = config.onProgress;
-	if (config?.yieldStrategy !== void 0) runnerOptions.yieldStrategy = config.yieldStrategy;
-	return require_async.runAsync(gen, graph, runnerOptions);
-}
-//#endregion
-//#region src/expansion/dome.ts
-/**
-* DOME priority: lower degree is expanded first.
-*/
-function domePriority(_nodeId, context) {
-	return context.degree;
-}
-/**
-* DOME high-degree priority: negate degree to prioritise high-degree nodes.
-*/
-function domeHighDegreePriority(_nodeId, context) {
-	return -context.degree;
-}
-/**
-* Run DOME expansion (degree-ordered).
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function dome(graph, seeds, config) {
-	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) {
-	return base(graph, seeds, {
-		...config,
-		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
-//#region src/expansion/hae.ts
-var EPSILON = 1e-10;
-/**
-* Default type mapper - uses node.type property.
-*/
-function defaultTypeMapper$1(node) {
-	return node.type ?? "default";
-}
-/**
-* Create a priority function using the given type mapper.
-*/
-function createHAEPriority(typeMapper) {
-	return function haePriority(nodeId, context) {
-		const graph = context.graph;
-		const neighbours = graph.neighbours(nodeId);
-		const neighbourTypes = [];
-		for (const neighbour of neighbours) {
-			const node = graph.getNode(neighbour);
-			if (node !== void 0) neighbourTypes.push(typeMapper(node));
-		}
-		return 1 / (require_utils.localTypeEntropy(neighbourTypes) + EPSILON) * Math.log(context.degree + 1);
-	};
-}
-/**
-* Run HAE expansion (Heterogeneity-Aware Expansion).
-*
-* Discovers paths by prioritising nodes with diverse neighbour types,
-* using a custom type mapper for flexible type extraction.
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - HAE configuration with optional typeMapper
-* @returns Expansion result with discovered paths
-*/
-function hae(graph, seeds, config) {
-	const typeMapper = config?.typeMapper ?? defaultTypeMapper$1;
-	return base(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". */
-var defaultTypeMapper = (n) => typeof n.type === "string" ? n.type : "default";
-/**
-* Run EDGE expansion (Entropy-Driven Graph Expansion).
-*
-* Discovers paths by prioritising nodes with diverse neighbour types,
-* deferring nodes with homogeneous neighbourhoods.
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function edge(graph, seeds, config) {
-	return hae(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
-/**
-* Priority function using path potential.
-* Lower values = higher priority (expanded first).
-*
-* Path potential measures how many of a node's neighbours have been
-* visited by OTHER frontiers (not the current frontier).
-*/
-function pipePriority(nodeId, context) {
-	const neighbours = context.graph.neighbours(nodeId);
-	let pathPotential = 0;
-	for (const neighbour of neighbours) {
-		const visitedBy = context.visitedByFrontier.get(neighbour);
-		if (visitedBy !== void 0 && visitedBy !== context.frontierIndex) pathPotential++;
-	}
-	return context.degree / (1 + pathPotential);
-}
-/**
-* Run PIPE expansion (Path-Potential Informed Priority Expansion).
-*
-* Discovers paths by prioritising nodes that bridge multiple frontiers,
-* identifying connecting points between seed regions.
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function pipe(graph, seeds, config) {
-	return base(graph, seeds, {
-		...config,
-		priority: pipePriority
-	});
-}
-/**
-* 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
-/**
-* Compute the average mutual information between a node and all visited
-* nodes in the same frontier.
-*
-* Returns a value in [0, 1] — higher means the node is more similar
-* (on average) to already-visited same-frontier nodes.
-*
-* @param graph - Source graph
-* @param nodeId - Node being prioritised
-* @param context - Current priority context
-* @param mi - MI function to use for pairwise scoring
-* @returns Average MI score, or 0 if no same-frontier visited nodes exist
-*/
-function avgFrontierMI(graph, nodeId, context, mi) {
-	const { frontierIndex, visitedByFrontier } = context;
-	let total = 0;
-	let count = 0;
-	for (const [visitedId, idx] of visitedByFrontier) if (idx === frontierIndex && visitedId !== nodeId) {
-		total += mi(graph, visitedId, nodeId);
-		count++;
-	}
-	return count > 0 ? total / count : 0;
-}
-/**
-* Count the number of a node's neighbours that have been visited by
-* frontiers other than the node's own frontier.
-*
-* A higher count indicates this node is likely to bridge two frontiers,
-* making it a strong candidate for path completion.
-*
-* @param graph - Source graph
-* @param nodeId - Node being evaluated
-* @param context - Current priority context
-* @returns Number of neighbours visited by other frontiers
-*/
-function countCrossFrontierNeighbours(graph, nodeId, context) {
-	const { frontierIndex, visitedByFrontier } = context;
-	const nodeNeighbours = new Set(graph.neighbours(nodeId));
-	let count = 0;
-	for (const [visitedId, idx] of visitedByFrontier) if (idx !== frontierIndex && nodeNeighbours.has(visitedId)) count++;
-	return count;
-}
-/**
-* Incrementally update salience counts for paths discovered since the
-* last update.
-*
-* Iterates only over paths from `fromIndex` onwards, avoiding redundant
-* re-processing of already-counted paths.
-*
-* @param salienceCounts - Mutable map of node ID to salience count (mutated in place)
-* @param paths - Full list of discovered paths
-* @param fromIndex - Index to start counting from (exclusive of earlier paths)
-* @returns The new `fromIndex` value (i.e. `paths.length` after update)
-*/
-function updateSalienceCounts(salienceCounts, paths, fromIndex) {
-	for (let i = fromIndex; i < paths.length; i++) {
-		const path = paths[i];
-		if (path !== void 0) for (const node of path.nodes) salienceCounts.set(node, (salienceCounts.get(node) ?? 0) + 1);
-	}
-	return paths.length;
-}
-//#endregion
-//#region src/expansion/sage.ts
-/**
-* Run SAGE expansion algorithm.
-*
-* Salience-aware multi-frontier expansion with two phases:
-* - Phase 1: Degree-based priority (early exploration)
-* - Phase 2: Salience feedback (path-aware frontier steering)
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function sage(graph, seeds, config) {
-	const salienceCounts = /* @__PURE__ */ new Map();
-	let inPhase2 = false;
-	let lastPathCount = 0;
-	/**
-	* SAGE priority function with phase transition logic.
-	*/
-	function sagePriority(nodeId, context) {
-		const pathCount = context.discoveredPaths.length;
-		if (pathCount > 0 && !inPhase2) inPhase2 = true;
-		if (pathCount > lastPathCount) lastPathCount = updateSalienceCounts(salienceCounts, context.discoveredPaths, lastPathCount);
-		if (!inPhase2) return Math.log(context.degree + 1);
-		return -((salienceCounts.get(nodeId) ?? 0) * 1e3 - context.degree);
-	}
-	return base(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
-/**
-* Compute Jaccard similarity between neighbourhoods of two nodes.
-*
-* @param graph - Source graph
-* @param source - Source node ID
-* @param target - Target node ID
-* @param config - Optional configuration
-* @returns Jaccard coefficient in [0, 1]
-*/
-function jaccard(graph, source, target, config) {
-	const { epsilon = 1e-10 } = config ?? {};
-	const { jaccard: jaccardScore, sourceNeighbours, targetNeighbours } = require_utils.computeJaccard(graph, source, target);
-	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
-/**
-* Run REACH expansion algorithm.
-*
-* Mutual information-aware multi-frontier expansion with two phases:
-* - Phase 1: Degree-based priority (early exploration)
-* - Phase 2: Structural similarity feedback (MI-guided frontier steering)
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function reach(graph, seeds, config) {
-	let inPhase2 = false;
-	const jaccardCache = /* @__PURE__ */ new Map();
-	/**
-	* Compute Jaccard similarity with caching.
-	*
-	* Exploits symmetry of Jaccard (J(A,B) = J(B,A)) to reduce
-	* duplicate computations when the same pair appears in multiple
-	* discovered paths. Key format ensures consistent ordering.
-	*/
-	function cachedJaccard(source, target) {
-		const key = source < target ? `${source}::${target}` : `${target}::${source}`;
-		let score = jaccardCache.get(key);
-		if (score === void 0) {
-			score = jaccard(graph, source, target);
-			jaccardCache.set(key, score);
-		}
-		return score;
-	}
-	/**
-	* REACH priority function with MI estimation.
-	*/
-	function reachPriority(nodeId, context) {
-		if (context.discoveredPaths.length > 0 && !inPhase2) inPhase2 = true;
-		if (!inPhase2) return Math.log(context.degree + 1);
-		let totalMI = 0;
-		let endpointCount = 0;
-		for (const path of context.discoveredPaths) {
-			const fromNodeId = path.fromSeed.id;
-			const toNodeId = path.toSeed.id;
-			totalMI += cachedJaccard(nodeId, fromNodeId);
-			totalMI += cachedJaccard(nodeId, toNodeId);
-			endpointCount += 2;
-		}
-		const miHat = endpointCount > 0 ? totalMI / endpointCount : 0;
-		return Math.log(context.degree + 1) * (1 - miHat);
-	}
-	return base(graph, seeds, {
-		...config,
-		priority: reachPriority
-	});
-}
-/**
-* 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) */
-var DEFAULT_PHASE2_THRESHOLD = 1;
-/** Salience weighting factor */
-var SALIENCE_WEIGHT = 1e3;
-/**
-* Run MAZE expansion algorithm.
-*
-* Multi-phase expansion combining path potential and salience with
-* adaptive frontier steering.
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function maze(graph, seeds, config) {
-	const salienceCounts = /* @__PURE__ */ new Map();
-	let inPhase2 = false;
-	let lastPathCount = 0;
-	/**
-	* MAZE priority function with path potential and salience feedback.
-	*/
-	function mazePriority(nodeId, context) {
-		const pathCount = context.discoveredPaths.length;
-		if (pathCount >= DEFAULT_PHASE2_THRESHOLD && !inPhase2) {
-			inPhase2 = true;
-			updateSalienceCounts(salienceCounts, context.discoveredPaths, 0);
-		}
-		if (inPhase2 && pathCount > lastPathCount) lastPathCount = updateSalienceCounts(salienceCounts, context.discoveredPaths, lastPathCount);
-		const nodeNeighbours = graph.neighbours(nodeId);
-		let pathPotential = 0;
-		for (const neighbour of nodeNeighbours) {
-			const visitedBy = context.visitedByFrontier.get(neighbour);
-			if (visitedBy !== void 0 && visitedBy !== context.frontierIndex) pathPotential++;
-		}
-		if (!inPhase2) return context.degree / (1 + pathPotential);
-		const salience = salienceCounts.get(nodeId) ?? 0;
-		return context.degree / (1 + pathPotential) * (1 / (1 + SALIENCE_WEIGHT * salience));
-	}
-	return base(graph, seeds, {
-		...config,
-		priority: mazePriority
-	});
-}
-/**
-* 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
-/**
-* TIDE priority function.
-*
-* Priority = degree(source) + degree(target)
-* Lower values = higher priority (explored first)
-*/
-function tidePriority(nodeId, context) {
-	const graph = context.graph;
-	let totalDegree = context.degree;
-	for (const neighbour of graph.neighbours(nodeId)) totalDegree += graph.degree(neighbour);
-	return totalDegree;
-}
-/**
-* Run TIDE expansion algorithm.
-*
-* Expands from seeds prioritising low-degree edges first.
-* Useful for avoiding hubs and exploring sparse regions.
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function tide(graph, seeds, config) {
-	return base(graph, seeds, {
-		...config,
-		priority: tidePriority
-	});
-}
-/**
-* 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
-/**
-* LACE priority function.
-*
-* Priority = 1 - avgMI(node, same-frontier visited nodes)
-* Higher average MI = lower priority value = explored first
-*/
-function lacePriority(nodeId, context, mi) {
-	return 1 - avgFrontierMI(context.graph, nodeId, context, mi);
-}
-/**
-* Run LACE expansion algorithm.
-*
-* Expands from seeds prioritising high-MI edges.
-* Useful for finding paths with strong semantic associations.
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration with MI function
-* @returns Expansion result with discovered paths
-*/
-function lace(graph, seeds, config) {
-	const { mi = jaccard, ...restConfig } = config ?? {};
-	const priority = (nodeId, context) => lacePriority(nodeId, context, mi);
-	return base(graph, seeds, {
-		...restConfig,
-		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
-/**
-* WARP priority function.
-*
-* Priority = 1 / (1 + bridge_score)
-* Bridge score = cross-frontier neighbour count plus bonus for nodes
-* already on discovered paths.
-* Higher bridge score = more likely to complete paths = explored first.
-*/
-function warpPriority(nodeId, context) {
-	let bridgeScore = countCrossFrontierNeighbours(context.graph, nodeId, context);
-	for (const path of context.discoveredPaths) if (path.nodes.includes(nodeId)) bridgeScore += 2;
-	return 1 / (1 + bridgeScore);
-}
-/**
-* Run WARP expansion algorithm.
-*
-* Expands from seeds prioritising bridge nodes.
-* Useful for finding paths through structurally important nodes.
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function warp(graph, seeds, config) {
-	return base(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
-/**
-* FUSE priority function.
-*
-* Combines degree with average frontier MI as a salience proxy:
-* Priority = (1 - w) * degree + w * (1 - avgMI)
-* Lower values = higher priority; high salience lowers priority
-*/
-function fusePriority(nodeId, context, mi, salienceWeight) {
-	const avgSalience = avgFrontierMI(context.graph, nodeId, context, mi);
-	return (1 - salienceWeight) * context.degree + salienceWeight * (1 - avgSalience);
-}
-/**
-* Run FUSE expansion algorithm.
-*
-* Combines structural exploration with semantic salience.
-* Useful for finding paths that are both short and semantically meaningful.
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration with MI function
-* @returns Expansion result with discovered paths
-*/
-function fuse(graph, seeds, config) {
-	const { mi = jaccard, salienceWeight = .5, ...restConfig } = config ?? {};
-	const priority = (nodeId, context) => fusePriority(nodeId, context, mi, salienceWeight);
-	return base(graph, seeds, {
-		...restConfig,
-		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
-/**
-* REACH (SIFT) priority function.
-*
-* Prioritises nodes with average frontier MI above the threshold;
-* falls back to degree-based ordering for those below it.
-*/
-function siftPriority(nodeId, context, mi, miThreshold) {
-	const avgMi = avgFrontierMI(context.graph, nodeId, context, mi);
-	if (avgMi >= miThreshold) return 1 - avgMi;
-	else return context.degree + 100;
-}
-/**
-* Run SIFT expansion algorithm.
-*
-* Two-phase adaptive expansion that learns MI thresholds
-* from initial sampling, then uses them for guided expansion.
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function sift(graph, seeds, config) {
-	const { mi = jaccard, miThreshold = .25, ...restConfig } = config ?? {};
-	const priority = (nodeId, context) => siftPriority(nodeId, context, mi, miThreshold);
-	return base(graph, seeds, {
-		...restConfig,
-		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
-/**
-* Compute local density around a node.
-*/
-function localDensity(graph, nodeId) {
-	const neighbours = Array.from(graph.neighbours(nodeId));
-	const degree = neighbours.length;
-	if (degree < 2) return 0;
-	let edges = 0;
-	for (let i = 0; i < neighbours.length; i++) for (let j = i + 1; j < neighbours.length; j++) {
-		const ni = neighbours[i];
-		const nj = neighbours[j];
-		if (ni !== void 0 && nj !== void 0 && graph.getEdge(ni, nj) !== void 0) edges++;
-	}
-	const maxEdges = degree * (degree - 1) / 2;
-	return edges / maxEdges;
-}
-/**
-* MAZE adaptive priority function.
-*
-* Switches strategies based on local conditions:
-* - High density + low bridge: EDGE mode
-* - Low density + low bridge: DOME mode
-* - High bridge score: PIPE mode
-*/
-function fluxPriority(nodeId, context, densityThreshold, bridgeThreshold) {
-	const graph = context.graph;
-	const degree = context.degree;
-	const density = localDensity(graph, nodeId);
-	const bridge = countCrossFrontierNeighbours(graph, nodeId, context);
-	const numFrontiers = new Set(context.visitedByFrontier.values()).size;
-	if ((numFrontiers > 0 ? bridge / numFrontiers : 0) >= bridgeThreshold) return 1 / (1 + bridge);
-	else if (density >= densityThreshold) return 1 / (degree + 1);
-	else return degree;
-}
-/**
-* Run FLUX expansion algorithm.
-*
-* Adaptively switches between expansion strategies based on
-* local graph structure. Useful for heterogeneous graphs
-* with varying density.
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function flux(graph, seeds, config) {
-	const { densityThreshold = .5, bridgeThreshold = .3, ...restConfig } = config ?? {};
-	const priority = (nodeId, context) => fluxPriority(nodeId, context, densityThreshold, bridgeThreshold);
-	return base(graph, seeds, {
-		...restConfig,
-		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
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function standardBfs(graph, seeds, config) {
-	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
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function frontierBalanced(graph, seeds, config) {
-	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
-/**
-* Deterministic seeded random number generator.
-* Uses FNV-1a-like hash for input → [0, 1] output.
-*
-* @param input - String to hash
-* @param seed - Random seed for reproducibility
-* @returns Deterministic random value in [0, 1]
-*/
-function seededRandom$1(input, seed = 0) {
-	let h = seed;
-	for (let i = 0; i < input.length; i++) {
-		h = Math.imul(h ^ input.charCodeAt(i), 2654435769);
-		h ^= h >>> 16;
-	}
-	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
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function randomPriority(graph, seeds, config) {
-	const { seed = 0 } = config ?? {};
-	return base(graph, seeds, {
-		...config,
-		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
-//#region src/expansion/dfs-priority.ts
-/**
-* DFS priority function: negative iteration produces LIFO ordering.
-*
-* Lower priority values are expanded first, so negating the iteration
-* counter ensures the most recently enqueued node is always next.
-*/
-function dfsPriorityFn(_nodeId, context) {
-	return -context.iteration;
-}
-/**
-* Run DFS-priority expansion (LIFO discovery order).
-*
-* Uses the BASE framework with a negative-iteration priority function,
-* which causes the most recently discovered node to be expanded first —
-* equivalent to depth-first search behaviour.
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Expansion configuration
-* @returns Expansion result with discovered paths
-*/
-function dfsPriority(graph, seeds, config) {
-	return base(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
-/**
-* Run k-hop expansion (fixed-depth BFS).
-*
-* Explores all nodes reachable within exactly k hops of any seed using
-* breadth-first search. Paths between seeds are detected when a node
-* is reached by frontiers from two different seeds.
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - K-hop configuration (k defaults to 2)
-* @returns Expansion result with discovered paths
-*/
-function kHop(graph, seeds, config) {
-	const startTime = performance.now();
-	const { k = 2 } = config ?? {};
-	if (seeds.length === 0) return emptyResult$1(startTime);
-	const visitedByFrontier = seeds.map(() => /* @__PURE__ */ new Map());
-	const firstVisitedBy = /* @__PURE__ */ new Map();
-	const allVisited = /* @__PURE__ */ new Set();
-	const sampledEdgeMap = /* @__PURE__ */ new Map();
-	const discoveredPaths = [];
-	let iterations = 0;
-	let edgesTraversed = 0;
-	for (let i = 0; i < seeds.length; i++) {
-		const seed = seeds[i];
-		if (seed === void 0) continue;
-		if (!graph.hasNode(seed.id)) continue;
-		visitedByFrontier[i]?.set(seed.id, null);
-		allVisited.add(seed.id);
-		if (!firstVisitedBy.has(seed.id)) firstVisitedBy.set(seed.id, i);
-		else {
-			const otherIdx = firstVisitedBy.get(seed.id) ?? -1;
-			if (otherIdx < 0) continue;
-			const fromSeed = seeds[otherIdx];
-			const toSeed = seeds[i];
-			if (fromSeed !== void 0 && toSeed !== void 0) discoveredPaths.push({
-				fromSeed,
-				toSeed,
-				nodes: [seed.id]
-			});
-		}
-	}
-	let currentLevel = seeds.map((s, i) => {
-		const frontier = visitedByFrontier[i];
-		if (frontier === void 0) return [];
-		return frontier.has(s.id) ? [s.id] : [];
-	});
-	for (let hop = 0; hop < k; hop++) {
-		const nextLevel = seeds.map(() => []);
-		for (let i = 0; i < seeds.length; i++) {
-			const level = currentLevel[i];
-			if (level === void 0) continue;
-			const frontierVisited = visitedByFrontier[i];
-			if (frontierVisited === void 0) continue;
-			for (const nodeId of level) {
-				iterations++;
-				for (const neighbour of graph.neighbours(nodeId)) {
-					edgesTraversed++;
-					const [s, t] = nodeId < neighbour ? [nodeId, neighbour] : [neighbour, nodeId];
-					let targets = sampledEdgeMap.get(s);
-					if (targets === void 0) {
-						targets = /* @__PURE__ */ new Set();
-						sampledEdgeMap.set(s, targets);
-					}
-					targets.add(t);
-					if (frontierVisited.has(neighbour)) continue;
-					frontierVisited.set(neighbour, nodeId);
-					allVisited.add(neighbour);
-					nextLevel[i]?.push(neighbour);
-					const previousFrontier = firstVisitedBy.get(neighbour);
-					if (previousFrontier !== void 0 && previousFrontier !== i) {
-						const fromSeed = seeds[previousFrontier];
-						const toSeed = seeds[i];
-						if (fromSeed !== void 0 && toSeed !== void 0) {
-							const path = reconstructPath(neighbour, previousFrontier, i, visitedByFrontier, seeds);
-							if (path !== null) {
-								if (!discoveredPaths.some((p) => p.fromSeed.id === fromSeed.id && p.toSeed.id === toSeed.id || p.fromSeed.id === toSeed.id && p.toSeed.id === fromSeed.id)) discoveredPaths.push(path);
-							}
-						}
-					}
-					if (!firstVisitedBy.has(neighbour)) firstVisitedBy.set(neighbour, i);
-				}
-			}
-		}
-		currentLevel = nextLevel;
-		if (currentLevel.every((level) => level.length === 0)) break;
-	}
-	const endTime = performance.now();
-	const edgeTuples = /* @__PURE__ */ new Set();
-	for (const [source, targets] of sampledEdgeMap) for (const target of targets) edgeTuples.add([source, target]);
-	return {
-		paths: discoveredPaths,
-		sampledNodes: allVisited,
-		sampledEdges: edgeTuples,
-		visitedPerFrontier: visitedByFrontier.map((m) => new Set(m.keys())),
-		stats: {
-			iterations,
-			nodesVisited: allVisited.size,
-			edgesTraversed,
-			pathsFound: discoveredPaths.length,
-			durationMs: endTime - startTime,
-			algorithm: "k-hop",
-			termination: "exhausted"
-		}
-	};
-}
-/**
-* Reconstruct the path between two colliding frontiers.
-*/
-function reconstructPath(collisionNode, frontierA, frontierB, visitedByFrontier, seeds) {
-	const seedA = seeds[frontierA];
-	const seedB = seeds[frontierB];
-	if (seedA === void 0 || seedB === void 0) return null;
-	const pathA = [collisionNode];
-	const predA = visitedByFrontier[frontierA];
-	if (predA !== void 0) {
-		let node = collisionNode;
-		let pred = predA.get(node);
-		while (pred !== null && pred !== void 0) {
-			pathA.unshift(pred);
-			node = pred;
-			pred = predA.get(node);
-		}
-	}
-	const pathB = [];
-	const predB = visitedByFrontier[frontierB];
-	if (predB !== void 0) {
-		let node = collisionNode;
-		let pred = predB.get(node);
-		while (pred !== null && pred !== void 0) {
-			pathB.push(pred);
-			node = pred;
-			pred = predB.get(node);
-		}
-	}
-	return {
-		fromSeed: seedA,
-		toSeed: seedB,
-		nodes: [...pathA, ...pathB]
-	};
-}
-/**
-* Create an empty result for early termination (no seeds).
-*/
-function emptyResult$1(startTime) {
-	return {
-		paths: [],
-		sampledNodes: /* @__PURE__ */ new Set(),
-		sampledEdges: /* @__PURE__ */ new Set(),
-		visitedPerFrontier: [],
-		stats: {
-			iterations: 0,
-			nodesVisited: 0,
-			edgesTraversed: 0,
-			pathsFound: 0,
-			durationMs: performance.now() - startTime,
-			algorithm: "k-hop",
-			termination: "exhausted"
-		}
-	};
-}
-//#endregion
-//#region src/expansion/random-walk.ts
-/**
-* Mulberry32 seeded PRNG — fast, compact, and high-quality for simulation.
-*
-* Returns a closure that yields the next pseudo-random value in [0, 1)
-* on each call.
-*
-* @param seed - 32-bit integer seed
-*/
-function mulberry32(seed) {
-	let s = seed;
-	return () => {
-		s += 1831565813;
-		let t = s;
-		t = Math.imul(t ^ t >>> 15, t | 1);
-		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
-		return ((t ^ t >>> 14) >>> 0) / 4294967296;
-	};
-}
-/**
-* Run random-walk-with-restart expansion.
-*
-* For each seed, performs `walks` independent random walks of up to
-* `walkLength` steps. At each step the walk either restarts (with
-* probability `restartProbability`) or moves to a uniformly sampled
-* neighbour. All visited nodes and traversed edges are collected.
-*
-* Inter-seed paths are detected when a walk reaches a node that was
-* previously reached by a walk originating from a different seed.
-* The recorded path contains only the two seed endpoints rather than
-* the full walk trajectory, consistent with the ExpansionPath contract.
-*
-* @param graph - Source graph
-* @param seeds - Seed nodes for expansion
-* @param config - Random walk configuration
-* @returns Expansion result with discovered paths
-*/
-function randomWalk(graph, seeds, config) {
-	const startTime = performance.now();
-	const { restartProbability = .15, walks = 10, walkLength = 20, seed = 0 } = config ?? {};
-	if (seeds.length === 0) return emptyResult(startTime);
-	const rand = mulberry32(seed);
-	const firstVisitedBySeed = /* @__PURE__ */ new Map();
-	const allVisited = /* @__PURE__ */ new Set();
-	const sampledEdgeMap = /* @__PURE__ */ new Map();
-	const discoveredPaths = [];
-	let iterations = 0;
-	let edgesTraversed = 0;
-	const visitedPerFrontier = seeds.map(() => /* @__PURE__ */ new Set());
-	for (let seedIdx = 0; seedIdx < seeds.length; seedIdx++) {
-		const seed_ = seeds[seedIdx];
-		if (seed_ === void 0) continue;
-		const seedId = seed_.id;
-		if (!graph.hasNode(seedId)) continue;
-		if (!firstVisitedBySeed.has(seedId)) firstVisitedBySeed.set(seedId, seedIdx);
-		allVisited.add(seedId);
-		visitedPerFrontier[seedIdx]?.add(seedId);
-		for (let w = 0; w < walks; w++) {
-			let current = seedId;
-			for (let step = 0; step < walkLength; step++) {
-				iterations++;
-				if (rand() < restartProbability) {
-					current = seedId;
-					continue;
-				}
-				const neighbourList = [];
-				for (const nb of graph.neighbours(current)) neighbourList.push(nb);
-				if (neighbourList.length === 0) {
-					current = seedId;
-					continue;
-				}
-				const next = neighbourList[Math.floor(rand() * neighbourList.length)];
-				if (next === void 0) {
-					current = seedId;
-					continue;
-				}
-				edgesTraversed++;
-				const [s, t] = current < next ? [current, next] : [next, current];
-				let targets = sampledEdgeMap.get(s);
-				if (targets === void 0) {
-					targets = /* @__PURE__ */ new Set();
-					sampledEdgeMap.set(s, targets);
-				}
-				targets.add(t);
-				const previousSeedIdx = firstVisitedBySeed.get(next);
-				if (previousSeedIdx !== void 0 && previousSeedIdx !== seedIdx) {
-					const fromSeed = seeds[previousSeedIdx];
-					const toSeed = seeds[seedIdx];
-					if (fromSeed !== void 0 && toSeed !== void 0) {
-						const path = {
-							fromSeed,
-							toSeed,
-							nodes: [
-								fromSeed.id,
-								next,
-								toSeed.id
-							].filter((n, i, arr) => arr.indexOf(n) === i)
-						};
-						if (!discoveredPaths.some((p) => p.fromSeed.id === fromSeed.id && p.toSeed.id === toSeed.id || p.fromSeed.id === toSeed.id && p.toSeed.id === fromSeed.id)) discoveredPaths.push(path);
-					}
-				}
-				if (!firstVisitedBySeed.has(next)) firstVisitedBySeed.set(next, seedIdx);
-				allVisited.add(next);
-				visitedPerFrontier[seedIdx]?.add(next);
-				current = next;
-			}
-		}
-	}
-	const endTime = performance.now();
-	const edgeTuples = /* @__PURE__ */ new Set();
-	for (const [source, targets] of sampledEdgeMap) for (const target of targets) edgeTuples.add([source, target]);
-	return {
-		paths: discoveredPaths,
-		sampledNodes: allVisited,
-		sampledEdges: edgeTuples,
-		visitedPerFrontier,
-		stats: {
-			iterations,
-			nodesVisited: allVisited.size,
-			edgesTraversed,
-			pathsFound: discoveredPaths.length,
-			durationMs: endTime - startTime,
-			algorithm: "random-walk",
-			termination: "exhausted"
-		}
-	};
-}
-/**
-* Create an empty result for early termination (no seeds).
-*/
-function emptyResult(startTime) {
-	return {
-		paths: [],
-		sampledNodes: /* @__PURE__ */ new Set(),
-		sampledEdges: /* @__PURE__ */ new Set(),
-		visitedPerFrontier: [],
-		stats: {
-			iterations: 0,
-			nodesVisited: 0,
-			edgesTraversed: 0,
-			pathsFound: 0,
-			durationMs: performance.now() - startTime,
-			algorithm: "random-walk",
-			termination: "exhausted"
-		}
-	};
-}
-//#endregion
-//#region src/ranking/parse.ts
-/**
-* Rank paths using PARSE (Path-Aware Ranking via Salience Estimation).
-*
-* Computes geometric mean of edge MI scores for each path,
-* then sorts by salience (highest first).
-*
-* @param graph - Source graph
-* @param paths - Paths to rank
-* @param config - Configuration options
-* @returns Ranked paths with statistics
-*/
-function parse(graph, paths, config) {
-	const startTime = performance.now();
-	const { mi = jaccard, epsilon = 1e-10 } = config ?? {};
-	const rankedPaths = [];
-	for (const path of paths) {
-		const salience = computePathSalience(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
-		}
-	};
-}
-/**
-* 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.
-*/
-function computePathSalience(graph, path, mi, epsilon) {
-	const nodes = path.nodes;
-	if (nodes.length < 2) return epsilon;
-	let productMi = 1;
-	let edgeCount = 0;
-	for (let i = 0; i < nodes.length - 1; i++) {
-		const source = nodes[i];
-		const target = nodes[i + 1];
-		if (source !== void 0 && target !== void 0) {
-			const edgeMi = mi(graph, source, target);
-			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));
-}
-//#endregion
-//#region src/ranking/mi/adamic-adar.ts
-/**
-* Compute Adamic-Adar index between neighbourhoods of two nodes.
-*
-* @param graph - Source graph
-* @param source - Source node ID
-* @param target - Target node ID
-* @param config - Optional configuration
-* @returns Adamic-Adar index (normalised to [0, 1] if configured)
-*/
-function adamicAdar(graph, source, target, config) {
-	const { epsilon = 1e-10, normalise = true } = config ?? {};
-	const commonNeighbours = require_utils.neighbourIntersection(require_utils.neighbourSet(graph, source, target), require_utils.neighbourSet(graph, target, source));
-	let score = 0;
-	for (const neighbour of commonNeighbours) {
-		const degree = graph.degree(neighbour);
-		score += 1 / Math.log(degree + 1);
-	}
-	if (normalise && commonNeighbours.size > 0) {
-		const maxScore = commonNeighbours.size / Math.log(2);
-		score = score / maxScore;
-	}
-	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
-/**
-* Compute cosine similarity between neighbourhoods of two nodes.
-*
-* @param graph - Source graph
-* @param source - Source node ID
-* @param target - Target node ID
-* @param config - Optional configuration
-* @returns Cosine similarity in [0, 1]
-*/
-function cosine(graph, source, target, config) {
-	const { epsilon = 1e-10 } = config ?? {};
-	const sourceNeighbours = require_utils.neighbourSet(graph, source, target);
-	const targetNeighbours = require_utils.neighbourSet(graph, target, source);
-	const { intersection } = require_utils.neighbourOverlap(sourceNeighbours, targetNeighbours);
-	const denominator = Math.sqrt(sourceNeighbours.size) * Math.sqrt(targetNeighbours.size);
-	if (denominator === 0) return 0;
-	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
-/**
-* Compute Sorensen-Dice similarity between neighbourhoods of two nodes.
-*
-* @param graph - Source graph
-* @param source - Source node ID
-* @param target - Target node ID
-* @param config - Optional configuration
-* @returns Sorensen-Dice coefficient in [0, 1]
-*/
-function sorensen(graph, source, target, config) {
-	const { epsilon = 1e-10 } = config ?? {};
-	const sourceNeighbours = require_utils.neighbourSet(graph, source, target);
-	const targetNeighbours = require_utils.neighbourSet(graph, target, source);
-	const { intersection } = require_utils.neighbourOverlap(sourceNeighbours, targetNeighbours);
-	const denominator = sourceNeighbours.size + targetNeighbours.size;
-	if (denominator === 0) return 0;
-	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
-/**
-* Compute Resource Allocation index between neighbourhoods of two nodes.
-*
-* @param graph - Source graph
-* @param source - Source node ID
-* @param target - Target node ID
-* @param config - Optional configuration
-* @returns Resource Allocation index (normalised to [0, 1] if configured)
-*/
-function resourceAllocation(graph, source, target, config) {
-	const { epsilon = 1e-10, normalise = true } = config ?? {};
-	const commonNeighbours = require_utils.neighbourIntersection(require_utils.neighbourSet(graph, source, target), require_utils.neighbourSet(graph, target, source));
-	let score = 0;
-	for (const neighbour of commonNeighbours) {
-		const degree = graph.degree(neighbour);
-		if (degree > 0) score += 1 / degree;
-	}
-	if (normalise && commonNeighbours.size > 0) {
-		const maxScore = commonNeighbours.size;
-		score = score / maxScore;
-	}
-	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
-/**
-* Compute Overlap Coefficient between neighbourhoods of two nodes.
-*
-* @param graph - Source graph
-* @param source - Source node ID
-* @param target - Target node ID
-* @param config - Optional configuration
-* @returns Overlap Coefficient in [0, 1]
-*/
-function overlapCoefficient(graph, source, target, config) {
-	const { epsilon = 1e-10 } = config ?? {};
-	const sourceNeighbours = require_utils.neighbourSet(graph, source, target);
-	const targetNeighbours = require_utils.neighbourSet(graph, target, source);
-	const { intersection } = require_utils.neighbourOverlap(sourceNeighbours, targetNeighbours);
-	const denominator = Math.min(sourceNeighbours.size, targetNeighbours.size);
-	if (denominator === 0) return 0;
-	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
-/**
-* Compute Hub Promoted index between neighbourhoods of two nodes.
-*
-* @param graph - Source graph
-* @param source - Source node ID
-* @param target - Target node ID
-* @param config - Optional configuration
-* @returns Hub Promoted index in [0, 1]
-*/
-function hubPromoted(graph, source, target, config) {
-	const { epsilon = 1e-10 } = config ?? {};
-	const { intersection } = require_utils.neighbourOverlap(require_utils.neighbourSet(graph, source, target), require_utils.neighbourSet(graph, target, source));
-	const sourceDegree = graph.degree(source);
-	const targetDegree = graph.degree(target);
-	const denominator = Math.min(sourceDegree, targetDegree);
-	if (denominator === 0) return 0;
-	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
-/**
-* Compute SCALE MI between two nodes.
-*/
-function scale(graph, source, target, config) {
-	const { epsilon = 1e-10 } = config ?? {};
-	const { jaccard: jaccardScore } = require_utils.computeJaccard(graph, source, target);
-	const n = graph.nodeCount;
-	const m = graph.edgeCount;
-	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);
-}
-/**
-* 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
-/**
-* Compute SKEW MI between two nodes.
-*/
-function skew(graph, source, target, config) {
-	const { epsilon = 1e-10 } = config ?? {};
-	const { jaccard: jaccardScore } = require_utils.computeJaccard(graph, source, target);
-	const N = graph.nodeCount;
-	const sourceDegree = graph.degree(source);
-	const targetDegree = graph.degree(target);
-	const sourceIdf = Math.log(N / (sourceDegree + 1));
-	const targetIdf = Math.log(N / (targetDegree + 1));
-	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
-/**
-* Compute SPAN MI between two nodes.
-*/
-function span(graph, source, target, config) {
-	const { epsilon = 1e-10 } = config ?? {};
-	const { jaccard: jaccardScore } = require_utils.computeJaccard(graph, source, target);
-	const sourceCc = require_utils.localClusteringCoefficient(graph, source);
-	const targetCc = require_utils.localClusteringCoefficient(graph, target);
-	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
-/**
-* Compute ETCH MI between two nodes.
-*/
-function etch(graph, source, target, config) {
-	const { epsilon = 1e-10 } = config ?? {};
-	const { jaccard: jaccardScore } = require_utils.computeJaccard(graph, source, target);
-	const edge = graph.getEdge(source, target);
-	if (edge?.type === void 0) return Math.max(epsilon, jaccardScore);
-	const edgeTypeCount = require_utils.countEdgesOfType(graph, edge.type);
-	if (edgeTypeCount === 0) return Math.max(epsilon, jaccardScore);
-	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
-/**
-* Compute NOTCH MI between two nodes.
-*/
-function notch(graph, source, target, config) {
-	const { epsilon = 1e-10 } = config ?? {};
-	const { jaccard: jaccardScore } = require_utils.computeJaccard(graph, source, target);
-	const sourceNode = graph.getNode(source);
-	const targetNode = graph.getNode(target);
-	if (sourceNode?.type === void 0 || targetNode?.type === void 0) return Math.max(epsilon, jaccardScore);
-	const sourceTypeCount = require_utils.countNodesOfType(graph, sourceNode.type);
-	const targetTypeCount = require_utils.countNodesOfType(graph, targetNode.type);
-	if (sourceTypeCount === 0 || targetTypeCount === 0) return Math.max(epsilon, jaccardScore);
-	const sourceRarity = Math.log(graph.nodeCount / sourceTypeCount);
-	const targetRarity = Math.log(graph.nodeCount / targetTypeCount);
-	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
-/**
-* Compute unified adaptive MI between two connected nodes.
-*
-* Combines structural, degree, and overlap signals with
-* configurable weighting.
-*
-* @param graph - Source graph
-* @param source - Source node ID
-* @param target - Target node ID
-* @param config - Optional configuration with component weights
-* @returns Adaptive MI score in [0, 1]
-*/
-function adaptive(graph, source, target, config) {
-	const { epsilon = 1e-10, structuralWeight = .4, degreeWeight = .3, overlapWeight = .3 } = config ?? {};
-	const { jaccard: jaccardScore, sourceNeighbours, targetNeighbours } = require_utils.computeJaccard(graph, source, target);
-	const structural = sourceNeighbours.size === 0 && targetNeighbours.size === 0 ? 0 : Math.max(epsilon, jaccardScore);
-	const degreeComponent = adamicAdar(graph, source, target, {
-		epsilon,
-		normalise: true
-	});
-	let overlap;
-	if (sourceNeighbours.size > 0 && targetNeighbours.size > 0) {
-		const { intersection } = require_utils.neighbourOverlap(sourceNeighbours, targetNeighbours);
-		const minDegree = Math.min(sourceNeighbours.size, targetNeighbours.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));
-}
-/**
-* 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
-/**
-* Normalise a set of scored paths and return them sorted highest-first.
-*
-* All scores are normalised relative to the maximum observed score.
-* When `includeScores` is false, raw (un-normalised) scores are preserved.
-* Handles degenerate cases: empty input and all-zero scores.
-*
-* @param paths - Original paths in input order
-* @param scored - Paths paired with their computed scores
-* @param method - Method name to embed in the result
-* @param includeScores - When true, normalise scores to [0, 1]; when false, keep raw scores
-* @returns BaselineResult with ranked paths
-*/
-function normaliseAndRank(paths, scored, method, includeScores) {
-	if (scored.length === 0) return {
-		paths: [],
-		method
-	};
-	const maxScore = Math.max(...scored.map((s) => s.score));
-	if (maxScore === 0) return {
-		paths: paths.map((path) => ({
-			...path,
-			score: 0
-		})),
-		method
-	};
-	return {
-		paths: scored.map(({ path, score }) => ({
-			...path,
-			score: includeScores ? score / maxScore : score
-		})).sort((a, b) => b.score - a.score),
-		method
-	};
-}
-//#endregion
-//#region src/ranking/baselines/shortest.ts
-/**
-* Rank paths by length (shortest first).
-*
-* Score = 1 / path_length, normalised to [0, 1].
-*
-* @param _graph - Source graph (unused for length ranking)
-* @param paths - Paths to rank
-* @param config - Configuration options
-* @returns Ranked paths (shortest first)
-*/
-function shortest(_graph, paths, config) {
-	const { includeScores = true } = config ?? {};
-	if (paths.length === 0) return {
-		paths: [],
-		method: "shortest"
-	};
-	return normaliseAndRank(paths, paths.map((path) => ({
-		path,
-		score: 1 / path.nodes.length
-	})), "shortest", includeScores);
-}
-//#endregion
-//#region src/ranking/baselines/degree-sum.ts
-/**
-* Rank paths by sum of node degrees.
-*
-* @param graph - Source graph
-* @param paths - Paths to rank
-* @param config - Configuration options
-* @returns Ranked paths (highest degree-sum first)
-*/
-function degreeSum(graph, paths, config) {
-	const { includeScores = true } = config ?? {};
-	if (paths.length === 0) return {
-		paths: [],
-		method: "degree-sum"
-	};
-	return normaliseAndRank(paths, paths.map((path) => {
-		let degreeSum = 0;
-		for (const nodeId of path.nodes) degreeSum += graph.degree(nodeId);
-		return {
-			path,
-			score: degreeSum
-		};
-	}), "degree-sum", includeScores);
-}
-//#endregion
-//#region src/ranking/baselines/widest-path.ts
-/**
-* Rank paths by widest bottleneck (minimum edge similarity).
-*
-* @param graph - Source graph
-* @param paths - Paths to rank
-* @param config - Configuration options
-* @returns Ranked paths (highest bottleneck first)
-*/
-function widestPath(graph, paths, config) {
-	const { includeScores = true } = config ?? {};
-	if (paths.length === 0) return {
-		paths: [],
-		method: "widest-path"
-	};
-	return normaliseAndRank(paths, paths.map((path) => {
-		if (path.nodes.length < 2) return {
-			path,
-			score: 1
-		};
-		let minSimilarity = Number.POSITIVE_INFINITY;
-		for (let i = 0; i < path.nodes.length - 1; i++) {
-			const source = path.nodes[i];
-			const target = path.nodes[i + 1];
-			if (source === void 0 || target === void 0) continue;
-			const edgeSimilarity = jaccard(graph, source, target);
-			minSimilarity = Math.min(minSimilarity, edgeSimilarity);
-		}
-		return {
-			path,
-			score: minSimilarity === Number.POSITIVE_INFINITY ? 1 : minSimilarity
-		};
-	}), "widest-path", includeScores);
-}
-//#endregion
-//#region src/ranking/baselines/jaccard-arithmetic.ts
-/**
-* Rank paths by arithmetic mean of edge Jaccard similarities.
-*
-* @param graph - Source graph
-* @param paths - Paths to rank
-* @param config - Configuration options
-* @returns Ranked paths (highest arithmetic mean first)
-*/
-function jaccardArithmetic(graph, paths, config) {
-	const { includeScores = true } = config ?? {};
-	if (paths.length === 0) return {
-		paths: [],
-		method: "jaccard-arithmetic"
-	};
-	return normaliseAndRank(paths, paths.map((path) => {
-		if (path.nodes.length < 2) return {
-			path,
-			score: 1
-		};
-		let similaritySum = 0;
-		let edgeCount = 0;
-		for (let i = 0; i < path.nodes.length - 1; i++) {
-			const source = path.nodes[i];
-			const target = path.nodes[i + 1];
-			if (source === void 0 || target === void 0) continue;
-			const edgeSimilarity = jaccard(graph, source, target);
-			similaritySum += edgeSimilarity;
-			edgeCount++;
-		}
-		return {
-			path,
-			score: edgeCount > 0 ? similaritySum / edgeCount : 1
-		};
-	}), "jaccard-arithmetic", includeScores);
-}
-//#endregion
-//#region src/ranking/baselines/pagerank.ts
-/**
-* Compute PageRank centrality for all nodes using power iteration.
-*
-* @param graph - Source graph
-* @param damping - Damping factor (default 0.85)
-* @param tolerance - Convergence tolerance (default 1e-6)
-* @param maxIterations - Maximum iterations (default 100)
-* @returns Map of node ID to PageRank value
-*/
-function computePageRank(graph, damping = .85, tolerance = 1e-6, maxIterations = 100) {
-	const nodes = Array.from(graph.nodeIds());
-	const n = nodes.length;
-	if (n === 0) return /* @__PURE__ */ new Map();
-	const ranks = /* @__PURE__ */ new Map();
-	const newRanks = /* @__PURE__ */ new Map();
-	for (const nodeId of nodes) {
-		ranks.set(nodeId, 1 / n);
-		newRanks.set(nodeId, 0);
-	}
-	let isCurrentRanks = true;
-	for (let iteration = 0; iteration < maxIterations; iteration++) {
-		let maxChange = 0;
-		const currMap = isCurrentRanks ? ranks : newRanks;
-		const nextMap = isCurrentRanks ? newRanks : ranks;
-		for (const nodeId of nodes) {
-			let incomingSum = 0;
-			for (const incomingId of graph.neighbours(nodeId, "in")) {
-				const incomingRank = currMap.get(incomingId) ?? 0;
-				const outDegree = graph.degree(incomingId);
-				if (outDegree > 0) incomingSum += incomingRank / outDegree;
-			}
-			const newRank = (1 - damping) / n + damping * incomingSum;
-			nextMap.set(nodeId, newRank);
-			const oldRank = currMap.get(nodeId) ?? 0;
-			maxChange = Math.max(maxChange, Math.abs(newRank - oldRank));
-		}
-		if (maxChange < tolerance) break;
-		isCurrentRanks = !isCurrentRanks;
-		currMap.clear();
-	}
-	return isCurrentRanks ? ranks : newRanks;
-}
-/**
-* Rank paths by sum of PageRank scores.
-*
-* @param graph - Source graph
-* @param paths - Paths to rank
-* @param config - Configuration options
-* @returns Ranked paths (highest PageRank sum first)
-*/
-function pagerank(graph, paths, config) {
-	const { includeScores = true } = config ?? {};
-	if (paths.length === 0) return {
-		paths: [],
-		method: "pagerank"
-	};
-	const ranks = computePageRank(graph);
-	return normaliseAndRank(paths, paths.map((path) => {
-		let prSum = 0;
-		for (const nodeId of path.nodes) prSum += ranks.get(nodeId) ?? 0;
-		return {
-			path,
-			score: prSum
-		};
-	}), "pagerank", includeScores);
-}
-//#endregion
-//#region src/ranking/baselines/betweenness.ts
-/**
-* Compute betweenness centrality for all nodes using Brandes algorithm.
-*
-* @param graph - Source graph
-* @returns Map of node ID to betweenness value
-*/
-function computeBetweenness(graph) {
-	const nodes = Array.from(graph.nodeIds());
-	const betweenness = /* @__PURE__ */ new Map();
-	for (const nodeId of nodes) betweenness.set(nodeId, 0);
-	for (const source of nodes) {
-		const predecessors = /* @__PURE__ */ new Map();
-		const distance = /* @__PURE__ */ new Map();
-		const sigma = /* @__PURE__ */ new Map();
-		const queue = [];
-		for (const nodeId of nodes) {
-			predecessors.set(nodeId, []);
-			distance.set(nodeId, -1);
-			sigma.set(nodeId, 0);
-		}
-		distance.set(source, 0);
-		sigma.set(source, 1);
-		queue.push(source);
-		for (const v of queue) {
-			const vDist = distance.get(v) ?? -1;
-			const neighbours = graph.neighbours(v);
-			for (const w of neighbours) {
-				const wDist = distance.get(w) ?? -1;
-				if (wDist < 0) {
-					distance.set(w, vDist + 1);
-					queue.push(w);
-				}
-				if (wDist === vDist + 1) {
-					const wSigma = sigma.get(w) ?? 0;
-					const vSigma = sigma.get(v) ?? 0;
-					sigma.set(w, wSigma + vSigma);
-					const wPred = predecessors.get(w) ?? [];
-					wPred.push(v);
-					predecessors.set(w, wPred);
-				}
-			}
-		}
-		const delta = /* @__PURE__ */ new Map();
-		for (const nodeId of nodes) delta.set(nodeId, 0);
-		const sorted = [...nodes].sort((a, b) => {
-			const aD = distance.get(a) ?? -1;
-			return (distance.get(b) ?? -1) - aD;
-		});
-		for (const w of sorted) {
-			if (w === source) continue;
-			const wDelta = delta.get(w) ?? 0;
-			const wSigma = sigma.get(w) ?? 0;
-			const wPred = predecessors.get(w) ?? [];
-			for (const v of wPred) {
-				const vSigma = sigma.get(v) ?? 0;
-				const vDelta = delta.get(v) ?? 0;
-				if (wSigma > 0) delta.set(v, vDelta + vSigma / wSigma * (1 + wDelta));
-			}
-			if (w !== source) {
-				const current = betweenness.get(w) ?? 0;
-				betweenness.set(w, current + wDelta);
-			}
-		}
-	}
-	return betweenness;
-}
-/**
-* Rank paths by sum of betweenness scores.
-*
-* @param graph - Source graph
-* @param paths - Paths to rank
-* @param config - Configuration options
-* @returns Ranked paths (highest betweenness sum first)
-*/
-function betweenness(graph, paths, config) {
-	const { includeScores = true } = config ?? {};
-	if (paths.length === 0) return {
-		paths: [],
-		method: "betweenness"
-	};
-	const bcMap = computeBetweenness(graph);
-	return normaliseAndRank(paths, paths.map((path) => {
-		let bcSum = 0;
-		for (const nodeId of path.nodes) bcSum += bcMap.get(nodeId) ?? 0;
-		return {
-			path,
-			score: bcSum
-		};
-	}), "betweenness", includeScores);
-}
-//#endregion
-//#region src/ranking/baselines/katz.ts
-/**
-* Compute truncated Katz centrality between two nodes.
-*
-* Uses iterative matrix-vector products to avoid full matrix powers.
-* score(s,t) = sum_{k=1}^{K} beta^k * walks_k(s,t)
-*
-* @param graph - Source graph
-* @param source - Source node ID
-* @param target - Target node ID
-* @param k - Truncation depth (default 5)
-* @param beta - Attenuation factor (default 0.005)
-* @returns Katz score
-*/
-function computeKatz(graph, source, target, k = 5, beta = .005) {
-	const nodes = Array.from(graph.nodeIds());
-	const nodeToIdx = /* @__PURE__ */ new Map();
-	nodes.forEach((nodeId, idx) => {
-		nodeToIdx.set(nodeId, idx);
-	});
-	const n = nodes.length;
-	if (n === 0) return 0;
-	const sourceIdx = nodeToIdx.get(source);
-	const targetIdx = nodeToIdx.get(target);
-	if (sourceIdx === void 0 || targetIdx === void 0) return 0;
-	let walks = new Float64Array(n);
-	walks[targetIdx] = 1;
-	let katzScore = 0;
-	for (let depth = 1; depth <= k; depth++) {
-		const walksNext = new Float64Array(n);
-		for (const sourceNode of nodes) {
-			const srcIdx = nodeToIdx.get(sourceNode);
-			if (srcIdx === void 0) continue;
-			const neighbours = graph.neighbours(sourceNode);
-			for (const neighbourId of neighbours) {
-				const nIdx = nodeToIdx.get(neighbourId);
-				if (nIdx === void 0) continue;
-				walksNext[srcIdx] = (walksNext[srcIdx] ?? 0) + (walks[nIdx] ?? 0);
-			}
-		}
-		const walkCount = walksNext[sourceIdx] ?? 0;
-		katzScore += Math.pow(beta, depth) * walkCount;
-		walks = walksNext;
-	}
-	return katzScore;
-}
-/**
-* Rank paths by Katz centrality between endpoints.
-*
-* @param graph - Source graph
-* @param paths - Paths to rank
-* @param config - Configuration options
-* @returns Ranked paths (highest Katz score first)
-*/
-function katz(graph, paths, config) {
-	const { includeScores = true } = config ?? {};
-	if (paths.length === 0) return {
-		paths: [],
-		method: "katz"
-	};
-	return normaliseAndRank(paths, paths.map((path) => {
-		const source = path.nodes[0];
-		const target = path.nodes[path.nodes.length - 1];
-		if (source === void 0 || target === void 0) return {
-			path,
-			score: 0
-		};
-		return {
-			path,
-			score: computeKatz(graph, source, target)
-		};
-	}), "katz", includeScores);
-}
-//#endregion
-//#region src/ranking/baselines/communicability.ts
-/**
-* Compute truncated communicability between two nodes.
-*
-* Uses Taylor series expansion: (e^A)_{s,t} ≈ sum_{k=0}^{K} A^k_{s,t} / k!
-*
-* @param graph - Source graph
-* @param source - Source node ID
-* @param target - Target node ID
-* @param k - Truncation depth (default 15)
-* @returns Communicability score
-*/
-function computeCommunicability(graph, source, target, k = 15) {
-	const nodes = Array.from(graph.nodeIds());
-	const nodeToIdx = /* @__PURE__ */ new Map();
-	nodes.forEach((nodeId, idx) => {
-		nodeToIdx.set(nodeId, idx);
-	});
-	const n = nodes.length;
-	if (n === 0) return 0;
-	const sourceIdx = nodeToIdx.get(source);
-	const targetIdx = nodeToIdx.get(target);
-	if (sourceIdx === void 0 || targetIdx === void 0) return 0;
-	let walks = new Float64Array(n);
-	walks[targetIdx] = 1;
-	let commScore = walks[sourceIdx] ?? 0;
-	let factorial = 1;
-	for (let depth = 1; depth <= k; depth++) {
-		const walksNext = new Float64Array(n);
-		for (const fromNode of nodes) {
-			const fromIdx = nodeToIdx.get(fromNode);
-			if (fromIdx === void 0) continue;
-			const neighbours = graph.neighbours(fromNode);
-			for (const toNodeId of neighbours) {
-				const toIdx = nodeToIdx.get(toNodeId);
-				if (toIdx === void 0) continue;
-				walksNext[fromIdx] = (walksNext[fromIdx] ?? 0) + (walks[toIdx] ?? 0);
-			}
-		}
-		factorial *= depth;
-		commScore += (walksNext[sourceIdx] ?? 0) / factorial;
-		walks = walksNext;
-	}
-	return commScore;
-}
-/**
-* Rank paths by communicability between endpoints.
-*
-* @param graph - Source graph
-* @param paths - Paths to rank
-* @param config - Configuration options
-* @returns Ranked paths (highest communicability first)
-*/
-function communicability(graph, paths, config) {
-	const { includeScores = true } = config ?? {};
-	if (paths.length === 0) return {
-		paths: [],
-		method: "communicability"
-	};
-	return normaliseAndRank(paths, paths.map((path) => {
-		const source = path.nodes[0];
-		const target = path.nodes[path.nodes.length - 1];
-		if (source === void 0 || target === void 0) return {
-			path,
-			score: 0
-		};
-		return {
-			path,
-			score: computeCommunicability(graph, source, target)
-		};
-	}), "communicability", includeScores);
-}
-//#endregion
-//#region src/ranking/baselines/resistance-distance.ts
-/**
-* Compute effective resistance between two nodes via Laplacian pseudoinverse.
-*
-* Resistance = L^+_{s,s} + L^+_{t,t} - 2*L^+_{s,t}
-* where L^+ is the pseudoinverse of the Laplacian matrix.
-*
-* @param graph - Source graph
-* @param source - Source node ID
-* @param target - Target node ID
-* @returns Effective resistance
-*/
-function computeResistance(graph, source, target) {
-	const nodes = Array.from(graph.nodeIds());
-	const nodeToIdx = /* @__PURE__ */ new Map();
-	nodes.forEach((nodeId, idx) => {
-		nodeToIdx.set(nodeId, idx);
-	});
-	const n = nodes.length;
-	if (n === 0 || n > 5e3) throw new Error(`Cannot compute resistance distance: graph too large (${String(n)} nodes). Maximum 5000.`);
-	const sourceIdx = nodeToIdx.get(source);
-	const targetIdx = nodeToIdx.get(target);
-	if (sourceIdx === void 0 || targetIdx === void 0) return 0;
-	const L = Array.from({ length: n }, () => Array.from({ length: n }, () => 0));
-	for (let i = 0; i < n; i++) {
-		const nodeId = nodes[i];
-		if (nodeId === void 0) continue;
-		const degree = graph.degree(nodeId);
-		const row = L[i];
-		if (row !== void 0) row[i] = degree;
-		const neighbours = graph.neighbours(nodeId);
-		for (const neighbourId of neighbours) {
-			const j = nodeToIdx.get(neighbourId);
-			if (j !== void 0 && row !== void 0) row[j] = -1;
-		}
-	}
-	const Lpinv = pinv(L);
-	const resistance = (Lpinv[sourceIdx]?.[sourceIdx] ?? 0) + (Lpinv[targetIdx]?.[targetIdx] ?? 0) - 2 * (Lpinv[sourceIdx]?.[targetIdx] ?? 0);
-	return Math.max(resistance, 1e-10);
-}
-/**
-* Compute Moore-Penrose pseudoinverse of a matrix.
-* Simplified implementation for small dense matrices.
-*
-* @param A - Square matrix
-* @returns Pseudoinverse A^+
-*/
-function pinv(A) {
-	const n = A.length;
-	if (n === 0) return [];
-	const M = A.map((row) => [...row]);
-	const epsilon = 1e-10;
-	for (let i = 0; i < n; i++) {
-		const row = M[i];
-		if (row !== void 0) row[i] = (row[i] ?? 0) + epsilon;
-	}
-	return gaussianInverse(M);
-}
-/**
-* Compute matrix inverse using Gaussian elimination with partial pivoting.
-*
-* @param A - Matrix to invert
-* @returns Inverted matrix
-*/
-function gaussianInverse(A) {
-	const n = A.length;
-	const aug = A.map((row, i) => {
-		const identity = Array.from({ length: n }, (_, j) => i === j ? 1 : 0);
-		return [...row, ...identity];
-	});
-	for (let col = 0; col < n; col++) {
-		let maxRow = col;
-		for (let row = col + 1; row < n; row++) {
-			const currentRow = aug[row];
-			const maxRowRef = aug[maxRow];
-			if (currentRow !== void 0 && maxRowRef !== void 0 && Math.abs(currentRow[col] ?? 0) > Math.abs(maxRowRef[col] ?? 0)) maxRow = row;
-		}
-		const currentCol = aug[col];
-		const maxRowAug = aug[maxRow];
-		if (currentCol !== void 0 && maxRowAug !== void 0) {
-			aug[col] = maxRowAug;
-			aug[maxRow] = currentCol;
-		}
-		const pivotRow = aug[col];
-		const pivot = pivotRow?.[col];
-		if (pivot === void 0 || Math.abs(pivot) < 1e-12) continue;
-		if (pivotRow !== void 0) for (let j = col; j < 2 * n; j++) pivotRow[j] = (pivotRow[j] ?? 0) / pivot;
-		for (let row = 0; row < n; row++) {
-			if (row === col) continue;
-			const eliminationRow = aug[row];
-			const factor = eliminationRow?.[col] ?? 0;
-			if (eliminationRow !== void 0 && pivotRow !== void 0) for (let j = col; j < 2 * n; j++) eliminationRow[j] = (eliminationRow[j] ?? 0) - factor * (pivotRow[j] ?? 0);
-		}
-	}
-	const Ainv = [];
-	for (let i = 0; i < n; i++) Ainv[i] = (aug[i]?.slice(n) ?? []).map((v) => v);
-	return Ainv;
-}
-/**
-* Rank paths by reciprocal of resistance distance between endpoints.
-*
-* @param graph - Source graph
-* @param paths - Paths to rank
-* @param config - Configuration options
-* @returns Ranked paths (highest conductance first)
-*/
-function resistanceDistance(graph, paths, config) {
-	const { includeScores = true } = config ?? {};
-	if (paths.length === 0) return {
-		paths: [],
-		method: "resistance-distance"
-	};
-	const nodeCount = Array.from(graph.nodeIds()).length;
-	if (nodeCount > 5e3) throw new Error(`Cannot rank paths: graph too large (${String(nodeCount)} nodes). Resistance distance requires O(n^3) computation; maximum 5000 nodes.`);
-	return normaliseAndRank(paths, paths.map((path) => {
-		const source = path.nodes[0];
-		const target = path.nodes[path.nodes.length - 1];
-		if (source === void 0 || target === void 0) return {
-			path,
-			score: 0
-		};
-		return {
-			path,
-			score: 1 / computeResistance(graph, source, target)
-		};
-	}), "resistance-distance", includeScores);
-}
-//#endregion
-//#region src/ranking/baselines/random-ranking.ts
-/**
-* Deterministic seeded random number generator.
-* Uses FNV-1a-like hash for input → [0, 1] output.
-*
-* @param input - String to hash
-* @param seed - Random seed for reproducibility
-* @returns Deterministic random value in [0, 1]
-*/
-function seededRandom(input, seed = 0) {
-	let h = seed;
-	for (let i = 0; i < input.length; i++) {
-		h = Math.imul(h ^ input.charCodeAt(i), 2654435769);
-		h ^= h >>> 16;
-	}
-	return (h >>> 0) / 4294967295;
-}
-/**
-* Rank paths randomly (null hypothesis baseline).
-*
-* @param _graph - Source graph (unused)
-* @param paths - Paths to rank
-* @param config - Configuration options
-* @returns Ranked paths (randomly ordered)
-*/
-function randomRanking(_graph, paths, config) {
-	const { includeScores = true, seed = 0 } = config ?? {};
-	if (paths.length === 0) return {
-		paths: [],
-		method: "random"
-	};
-	return normaliseAndRank(paths, paths.map((path) => {
-		return {
-			path,
-			score: seededRandom(path.nodes.join(","), seed)
-		};
-	}), "random", includeScores);
-}
-//#endregion
-//#region src/ranking/baselines/hitting-time.ts
-/**
-* Seeded deterministic random number generator (LCG).
-* Suitable for reproducible random walk simulation.
-*/
-var SeededRNG = class {
-	state;
-	constructor(seed) {
-		this.state = seed;
-	}
-	/**
-	* Generate next pseudorandom value in [0, 1).
-	*/
-	next() {
-		this.state = this.state * 1103515245 + 12345 & 2147483647;
-		return this.state / 2147483647;
-	}
-};
-/**
-* Compute hitting time via Monte Carlo random walk simulation.
-*
-* @param graph - Source graph
-* @param source - Source node ID
-* @param target - Target node ID
-* @param walks - Number of walks to simulate
-* @param maxSteps - Maximum steps per walk
-* @param rng - Seeded RNG instance
-* @returns Average hitting time across walks
-*/
-function computeHittingTimeApproximate(graph, source, target, walks, maxSteps, rng) {
-	if (source === target) return 0;
-	let totalSteps = 0;
-	let successfulWalks = 0;
-	for (let w = 0; w < walks; w++) {
-		let current = source;
-		let steps = 0;
-		while (current !== target && steps < maxSteps) {
-			const neighbours = Array.from(graph.neighbours(current));
-			if (neighbours.length === 0) break;
-			const nextNode = neighbours[Math.floor(rng.next() * neighbours.length)];
-			if (nextNode === void 0) break;
-			current = nextNode;
-			steps++;
-		}
-		if (current === target) {
-			totalSteps += steps;
-			successfulWalks++;
-		}
-	}
-	if (successfulWalks > 0) return totalSteps / successfulWalks;
-	return maxSteps;
-}
-/**
-* Compute hitting time via exact fundamental matrix method.
-*
-* For small graphs, computes exact expected hitting times using
-* the fundamental matrix of the random walk.
-*
-* @param graph - Source graph
-* @param source - Source node ID
-* @param target - Target node ID
-* @returns Exact hitting time (or approximation if convergence fails)
-*/
-function computeHittingTimeExact(graph, source, target) {
-	if (source === target) return 0;
-	const nodes = Array.from(graph.nodeIds());
-	const nodeToIdx = /* @__PURE__ */ new Map();
-	nodes.forEach((nodeId, idx) => {
-		nodeToIdx.set(nodeId, idx);
-	});
-	const n = nodes.length;
-	const sourceIdx = nodeToIdx.get(source);
-	const targetIdx = nodeToIdx.get(target);
-	if (sourceIdx === void 0 || targetIdx === void 0) return 0;
-	const P = [];
-	for (let i = 0; i < n; i++) {
-		const row = [];
-		for (let j = 0; j < n; j++) row[j] = 0;
-		P[i] = row;
-	}
-	for (const nodeId of nodes) {
-		const idx = nodeToIdx.get(nodeId);
-		if (idx === void 0) continue;
-		const pRow = P[idx];
-		if (pRow === void 0) continue;
-		if (idx === targetIdx) pRow[idx] = 1;
-		else {
-			const neighbours = Array.from(graph.neighbours(nodeId));
-			const degree = neighbours.length;
-			if (degree > 0) for (const neighbourId of neighbours) {
-				const nIdx = nodeToIdx.get(neighbourId);
-				if (nIdx !== void 0) pRow[nIdx] = 1 / degree;
-			}
-		}
-	}
-	const transientIndices = [];
-	for (let i = 0; i < n; i++) if (i !== targetIdx) transientIndices.push(i);
-	const m = transientIndices.length;
-	const Q = [];
-	for (let i = 0; i < m; i++) {
-		const row = [];
-		for (let j = 0; j < m; j++) row[j] = 0;
-		Q[i] = row;
-	}
-	for (let i = 0; i < m; i++) {
-		const qRow = Q[i];
-		if (qRow === void 0) continue;
-		const origI = transientIndices[i];
-		if (origI === void 0) continue;
-		const pRow = P[origI];
-		if (pRow === void 0) continue;
-		for (let j = 0; j < m; j++) {
-			const origJ = transientIndices[j];
-			if (origJ === void 0) continue;
-			qRow[j] = pRow[origJ] ?? 0;
-		}
-	}
-	const IMQ = [];
-	for (let i = 0; i < m; i++) {
-		const row = [];
-		for (let j = 0; j < m; j++) row[j] = i === j ? 1 : 0;
-		IMQ[i] = row;
-	}
-	for (let i = 0; i < m; i++) {
-		const imqRow = IMQ[i];
-		if (imqRow === void 0) continue;
-		const qRow = Q[i];
-		for (let j = 0; j < m; j++) {
-			const qVal = qRow?.[j] ?? 0;
-			imqRow[j] = (i === j ? 1 : 0) - qVal;
-		}
-	}
-	const N = invertMatrix(IMQ);
-	if (N === null) return 1;
-	const sourceTransientIdx = transientIndices.indexOf(sourceIdx);
-	if (sourceTransientIdx < 0) return 0;
-	let hittingTime = 0;
-	const row = N[sourceTransientIdx];
-	if (row !== void 0) for (const val of row) hittingTime += val;
-	return hittingTime;
-}
-/**
-* Invert a square matrix using Gaussian elimination with partial pivoting.
-*
-* @param matrix - Input matrix (n × n)
-* @returns Inverted matrix, or null if singular
-*/
-function invertMatrix(matrix) {
-	const n = matrix.length;
-	const aug = [];
-	for (let i = 0; i < n; i++) {
-		const row = [];
-		const matRow = matrix[i];
-		for (let j = 0; j < n; j++) row[j] = matRow?.[j] ?? 0;
-		for (let j = 0; j < n; j++) row[n + j] = i === j ? 1 : 0;
-		aug[i] = row;
-	}
-	for (let col = 0; col < n; col++) {
-		let pivotRow = col;
-		const pivotCol = aug[pivotRow];
-		if (pivotCol === void 0) return null;
-		for (let row = col + 1; row < n; row++) {
-			const currRowVal = aug[row]?.[col] ?? 0;
-			const pivotRowVal = pivotCol[col] ?? 0;
-			if (Math.abs(currRowVal) > Math.abs(pivotRowVal)) pivotRow = row;
-		}
-		const augPivot = aug[pivotRow];
-		if (augPivot === void 0 || Math.abs(augPivot[col] ?? 0) < 1e-10) return null;
-		[aug[col], aug[pivotRow]] = [aug[pivotRow] ?? [], aug[col] ?? []];
-		const scaledPivotRow = aug[col];
-		if (scaledPivotRow === void 0) return null;
-		const pivot = scaledPivotRow[col] ?? 1;
-		for (let j = 0; j < 2 * n; j++) scaledPivotRow[j] = (scaledPivotRow[j] ?? 0) / pivot;
-		for (let row = col + 1; row < n; row++) {
-			const currRow = aug[row];
-			if (currRow === void 0) continue;
-			const factor = currRow[col] ?? 0;
-			for (let j = 0; j < 2 * n; j++) currRow[j] = (currRow[j] ?? 0) - factor * (scaledPivotRow[j] ?? 0);
-		}
-	}
-	for (let col = n - 1; col > 0; col--) {
-		const colRow = aug[col];
-		if (colRow === void 0) return null;
-		for (let row = col - 1; row >= 0; row--) {
-			const currRow = aug[row];
-			if (currRow === void 0) continue;
-			const factor = currRow[col] ?? 0;
-			for (let j = 0; j < 2 * n; j++) currRow[j] = (currRow[j] ?? 0) - factor * (colRow[j] ?? 0);
-		}
-	}
-	const inv = [];
-	for (let i = 0; i < n; i++) {
-		const row = [];
-		for (let j = 0; j < n; j++) row[j] = 0;
-		inv[i] = row;
-	}
-	for (let i = 0; i < n; i++) {
-		const invRow = inv[i];
-		if (invRow === void 0) continue;
-		const augRow = aug[i];
-		if (augRow === void 0) continue;
-		for (let j = 0; j < n; j++) invRow[j] = augRow[n + j] ?? 0;
-	}
-	return inv;
-}
-/**
-* Rank paths by inverse hitting time between endpoints.
-*
-* @param graph - Source graph
-* @param paths - Paths to rank
-* @param config - Configuration options
-* @returns Ranked paths (highest inverse hitting time first)
-*/
-function hittingTime(graph, paths, config) {
-	const { includeScores = true, mode = "auto", walks = 1e3, maxSteps = 1e4, seed = 42 } = config ?? {};
-	if (paths.length === 0) return {
-		paths: [],
-		method: "hitting-time"
-	};
-	const nodeCount = Array.from(graph.nodeIds()).length;
-	const actualMode = mode === "auto" ? nodeCount < 100 ? "exact" : "approximate" : mode;
-	const rng = new SeededRNG(seed);
-	const scored = paths.map((path) => {
-		const source = path.nodes[0];
-		const target = path.nodes[path.nodes.length - 1];
-		if (source === void 0 || target === void 0) return {
-			path,
-			score: 0
-		};
-		const ht = actualMode === "exact" ? computeHittingTimeExact(graph, source, target) : computeHittingTimeApproximate(graph, source, target, walks, maxSteps, rng);
-		return {
-			path,
-			score: ht > 0 ? 1 / ht : 0
-		};
-	});
-	const maxScore = Math.max(...scored.map((s) => s.score));
-	if (!Number.isFinite(maxScore)) return {
-		paths: paths.map((path) => ({
-			...path,
-			score: 0
-		})),
-		method: "hitting-time"
-	};
-	return normaliseAndRank(paths, scored, "hitting-time", includeScores);
-}
-//#endregion
-//#region src/extraction/ego-network.ts
-/**
-* Extract the ego-network (k-hop neighbourhood) of a centre node.
-*
-* The ego-network includes all nodes reachable within k hops from the
-* centre node, plus all edges between those nodes (induced subgraph).
-*
-* For directed graphs, the search follows outgoing edges by default.
-* To include incoming edges, use direction 'both' in the underlying traversal.
-*
-* @param graph - The source graph
-* @param centre - The centre node ID
-* @param options - Extraction options
-* @returns An induced subgraph of the k-hop neighbourhood
-* @throws Error if the centre node does not exist in the graph
-*
-* @example
-* ```typescript
-* // 2-hop neighbourhood
-* const ego = extractEgoNetwork(graph, 'A', { hops: 2 });
-* ```
-*/
-function extractEgoNetwork(graph, centre, options) {
-	const hops = options?.hops ?? 1;
-	if (!graph.hasNode(centre)) throw new Error(`Centre node '${centre}' does not exist in the graph`);
-	if (hops < 0) throw new Error(`Hops must be non-negative, got ${String(hops)}`);
-	const nodesInEgoNetwork = new Set([centre]);
-	if (hops > 0) {
-		const visited = new Set([centre]);
-		const queue = [[centre, 0]];
-		while (queue.length > 0) {
-			const entry = queue.shift();
-			if (entry === void 0) break;
-			const [current, distance] = entry;
-			if (distance < hops) {
-				for (const neighbour of graph.neighbours(current)) if (!visited.has(neighbour)) {
-					visited.add(neighbour);
-					nodesInEgoNetwork.add(neighbour);
-					queue.push([neighbour, distance + 1]);
-				}
-			}
-		}
-	}
-	const result = graph.directed ? require_graph.AdjacencyMapGraph.directed() : require_graph.AdjacencyMapGraph.undirected();
-	for (const nodeId of nodesInEgoNetwork) {
-		const nodeData = graph.getNode(nodeId);
-		if (nodeData !== void 0) result.addNode(nodeData);
-	}
-	for (const edge of graph.edges()) if (nodesInEgoNetwork.has(edge.source) && nodesInEgoNetwork.has(edge.target)) result.addEdge(edge);
-	return result;
-}
-//#endregion
-//#region src/extraction/k-core.ts
-/**
-* Extract the k-core of a graph.
-*
-* The k-core is the maximal connected subgraph where every node has
-* degree at least k. This is computed using a peeling algorithm that
-* iteratively removes nodes with degree less than k.
-*
-* For undirected graphs, degree counts all adjacent nodes.
-* For directed graphs, degree counts both in- and out-neighbours.
-*
-* @param graph - The source graph
-* @param k - The minimum degree threshold
-* @returns A new graph containing the k-core (may be empty)
-*
-* @example
-* ```typescript
-* // Extract the 3-core (nodes with at least 3 neighbours)
-* const core3 = extractKCore(graph, 3);
-* ```
-*/
-function extractKCore(graph, k) {
-	if (k < 0) throw new Error(`k must be non-negative, got ${String(k)}`);
-	const remaining = /* @__PURE__ */ new Set();
-	const degrees = /* @__PURE__ */ new Map();
-	for (const nodeId of graph.nodeIds()) {
-		remaining.add(nodeId);
-		const deg = graph.directed ? graph.degree(nodeId, "both") : graph.degree(nodeId);
-		degrees.set(nodeId, deg);
-	}
-	const toRemove = [];
-	for (const [nodeId, deg] of degrees) if (deg < k) toRemove.push(nodeId);
-	while (toRemove.length > 0) {
-		const nodeId = toRemove.shift();
-		if (nodeId === void 0) break;
-		if (!remaining.has(nodeId)) continue;
-		remaining.delete(nodeId);
-		const neighbours = graph.directed ? graph.neighbours(nodeId, "both") : graph.neighbours(nodeId);
-		for (const neighbour of neighbours) if (remaining.has(neighbour)) {
-			const newDeg = (degrees.get(neighbour) ?? 0) - 1;
-			degrees.set(neighbour, newDeg);
-			if (newDeg < k && newDeg === k - 1) toRemove.push(neighbour);
-		}
-	}
-	const result = graph.directed ? require_graph.AdjacencyMapGraph.directed() : require_graph.AdjacencyMapGraph.undirected();
-	for (const nodeId of remaining) {
-		const nodeData = graph.getNode(nodeId);
-		if (nodeData !== void 0) result.addNode(nodeData);
-	}
-	for (const edge of graph.edges()) if (remaining.has(edge.source) && remaining.has(edge.target)) result.addEdge(edge);
-	return result;
-}
-//#endregion
-//#region src/extraction/truss.ts
-/**
-* Count triangles involving a given edge.
-*
-* For an edge (u, v), count common neighbours of u and v.
-* Each common neighbour w forms a triangle u-v-w.
-*
-* @param graph - The graph
-* @param u - First endpoint
-* @param v - Second endpoint
-* @returns Number of triangles containing the edge (u, v)
-*/
-function countEdgeTriangles(graph, u, v) {
-	const uNeighbours = new Set(graph.neighbours(u));
-	let count = 0;
-	for (const w of graph.neighbours(v)) if (w !== u && uNeighbours.has(w)) count++;
-	return count;
-}
-/**
-* Extract the k-truss of a graph.
-*
-* The k-truss is the maximal subgraph where every edge participates in
-* at least k-2 triangles. This is computed by iteratively removing edges
-* with fewer than k-2 triangles, then removing isolated nodes.
-*
-* Note: K-truss is typically defined for undirected graphs. For directed
-* graphs, this treats the graph as undirected for triangle counting.
-*
-* @param graph - The source graph
-* @param k - The minimum triangle count threshold (edge must be in >= k-2 triangles)
-* @returns A new graph containing the k-truss (may be empty)
-*
-* @example
-* ```typescript
-* // Extract the 3-truss (edges in at least 1 triangle)
-* const truss3 = extractKTruss(graph, 3);
-* ```
-*/
-function extractKTruss(graph, k) {
-	if (k < 2) throw new Error(`k must be at least 2, got ${String(k)}`);
-	const minTriangles = k - 2;
-	const adjacency = /* @__PURE__ */ new Map();
-	const edgeData = /* @__PURE__ */ new Map();
-	const remainingEdges = /* @__PURE__ */ new Set();
-	for (const nodeId of graph.nodeIds()) adjacency.set(nodeId, /* @__PURE__ */ new Set());
-	for (const edge of graph.edges()) {
-		const { source, target } = edge;
-		adjacency.get(source)?.add(target);
-		adjacency.get(target)?.add(source);
-		const key = source < target ? `${source}::${target}` : `${target}::${source}`;
-		edgeData.set(key, edge);
-		remainingEdges.add(key);
-	}
-	const triangleCounts = /* @__PURE__ */ new Map();
-	const edgesToRemove = [];
-	for (const key of remainingEdges) {
-		const edge = edgeData.get(key);
-		if (edge !== void 0) {
-			const count = countEdgeTriangles(graph, edge.source, edge.target);
-			triangleCounts.set(key, count);
-			if (count < minTriangles) edgesToRemove.push(key);
-		}
-	}
-	while (edgesToRemove.length > 0) {
-		const edgeKey = edgesToRemove.shift();
-		if (edgeKey === void 0) break;
-		if (!remainingEdges.has(edgeKey)) continue;
-		remainingEdges.delete(edgeKey);
-		const edge = edgeData.get(edgeKey);
-		if (edge === void 0) continue;
-		const { source, target } = edge;
-		adjacency.get(source)?.delete(target);
-		adjacency.get(target)?.delete(source);
-		const sourceNeighbours = adjacency.get(source);
-		if (sourceNeighbours !== void 0) {
-			for (const w of adjacency.get(target) ?? []) if (sourceNeighbours.has(w)) {
-				const keySw = source < w ? `${source}::${w}` : `${w}::${source}`;
-				const keyTw = target < w ? `${target}::${w}` : `${w}::${target}`;
-				for (const keyToUpdate of [keySw, keyTw]) if (remainingEdges.has(keyToUpdate)) {
-					const newCount = (triangleCounts.get(keyToUpdate) ?? 0) - 1;
-					triangleCounts.set(keyToUpdate, newCount);
-					if (newCount < minTriangles && newCount === minTriangles - 1) edgesToRemove.push(keyToUpdate);
-				}
-			}
-		}
-	}
-	const nodesWithEdges = /* @__PURE__ */ new Set();
-	for (const key of remainingEdges) {
-		const edge = edgeData.get(key);
-		if (edge !== void 0) {
-			nodesWithEdges.add(edge.source);
-			nodesWithEdges.add(edge.target);
-		}
-	}
-	const result = graph.directed ? require_graph.AdjacencyMapGraph.directed() : require_graph.AdjacencyMapGraph.undirected();
-	for (const nodeId of nodesWithEdges) {
-		const nodeData = graph.getNode(nodeId);
-		if (nodeData !== void 0) result.addNode(nodeData);
-	}
-	for (const key of remainingEdges) {
-		const edge = edgeData.get(key);
-		if (edge !== void 0 && result.hasNode(edge.source) && result.hasNode(edge.target)) result.addEdge(edge);
-	}
-	return result;
-}
-/**
-* Compute the truss number for each edge.
-*
-* The truss number of an edge is the largest k such that the edge
-* belongs to the k-truss.
-*
-* @param graph - The source graph
-* @returns Map from edge key (canonical "u::v") to truss number
-*
-* @example
-* ```typescript
-* const trussNumbers = computeTrussNumbers(graph);
-* const edgeKey = 'A::B'; // where A < B lexicographically
-* console.log(`Edge A-B is in the ${trussNumbers.get(edgeKey)}-truss`);
-* ```
-*/
-function computeTrussNumbers(graph) {
-	const adjacency = /* @__PURE__ */ new Map();
-	const edgeData = /* @__PURE__ */ new Map();
-	const remainingEdges = /* @__PURE__ */ new Set();
-	for (const nodeId of graph.nodeIds()) adjacency.set(nodeId, /* @__PURE__ */ new Set());
-	for (const edge of graph.edges()) {
-		const { source, target } = edge;
-		adjacency.get(source)?.add(target);
-		adjacency.get(target)?.add(source);
-		const key = source < target ? `${source}::${target}` : `${target}::${source}`;
-		edgeData.set(key, edge);
-		remainingEdges.add(key);
-	}
-	const triangleCounts = /* @__PURE__ */ new Map();
-	for (const key of remainingEdges) {
-		const edge = edgeData.get(key);
-		if (edge !== void 0) triangleCounts.set(key, countEdgeTriangles(graph, edge.source, edge.target));
-	}
-	const trussNumbers = /* @__PURE__ */ new Map();
-	const edgesByTriangleCount = /* @__PURE__ */ new Map();
-	for (const [key, count] of triangleCounts) {
-		if (!edgesByTriangleCount.has(count)) edgesByTriangleCount.set(count, /* @__PURE__ */ new Set());
-		edgesByTriangleCount.get(count)?.add(key);
-	}
-	const sortedCounts = [...edgesByTriangleCount.keys()].sort((a, b) => a - b);
-	for (const currentCount of sortedCounts) {
-		const bucket = edgesByTriangleCount.get(currentCount);
-		if (bucket === void 0) continue;
-		while (bucket.size > 0) {
-			const edgeKey = bucket.values().next().value;
-			if (edgeKey === void 0) break;
-			bucket.delete(edgeKey);
-			if (!remainingEdges.has(edgeKey)) continue;
-			const trussNumber = currentCount + 2;
-			trussNumbers.set(edgeKey, trussNumber);
-			remainingEdges.delete(edgeKey);
-			const edge = edgeData.get(edgeKey);
-			if (edge === void 0) continue;
-			const { source, target } = edge;
-			adjacency.get(source)?.delete(target);
-			adjacency.get(target)?.delete(source);
-			const sourceNeighbours = adjacency.get(source);
-			if (sourceNeighbours !== void 0) {
-				for (const w of adjacency.get(target) ?? []) if (sourceNeighbours.has(w)) {
-					const keySw = source < w ? `${source}::${w}` : `${w}::${source}`;
-					const keyTw = target < w ? `${target}::${w}` : `${w}::${target}`;
-					for (const keyToUpdate of [keySw, keyTw]) if (remainingEdges.has(keyToUpdate)) {
-						const oldCount = triangleCounts.get(keyToUpdate) ?? 0;
-						const newCount = oldCount - 1;
-						triangleCounts.set(keyToUpdate, newCount);
-						edgesByTriangleCount.get(oldCount)?.delete(keyToUpdate);
-						if (!edgesByTriangleCount.has(newCount)) edgesByTriangleCount.set(newCount, /* @__PURE__ */ new Set());
-						edgesByTriangleCount.get(newCount)?.add(keyToUpdate);
-					}
-				}
-			}
-		}
-	}
-	return trussNumbers;
-}
-//#endregion
-//#region src/extraction/motif.ts
-/**
-* Canonicalise an edge pattern for hashing.
-*
-* Returns a canonical string representation of a small graph pattern.
-*/
-function canonicalisePattern(nodeCount, edges) {
-	const permutations = getPermutations(nodeCount);
-	let minPattern = null;
-	for (const perm of permutations) {
-		const transformedEdges = edges.map(([u, v]) => {
-			const pu = perm[u] ?? -1;
-			const pv = perm[v] ?? -1;
-			if (pu < 0 || pv < 0) return;
-			return pu < pv ? `${String(pu)}-${String(pv)}` : `${String(pv)}-${String(pu)}`;
-		}).filter((edge) => edge !== void 0).sort().join(",");
-		if (minPattern === null || transformedEdges < minPattern) minPattern = transformedEdges;
-	}
-	return minPattern ?? "";
-}
-/**
-* Generate all permutations of [0, n-1].
-*/
-function getPermutations(n) {
-	if (n === 0) return [[]];
-	if (n === 1) return [[0]];
-	const result = [];
-	const arr = Array.from({ length: n }, (_, i) => i);
-	function permute(start) {
-		if (start === n - 1) {
-			result.push([...arr]);
-			return;
-		}
-		for (let i = start; i < n; i++) {
-			const startVal = arr[start];
-			const iVal = arr[i];
-			if (startVal === void 0 || iVal === void 0) continue;
-			arr[start] = iVal;
-			arr[i] = startVal;
-			permute(start + 1);
-			arr[start] = startVal;
-			arr[i] = iVal;
-		}
-	}
-	permute(0);
-	return result;
-}
-/**
-* Enumerate all 3-node motifs in the graph.
-*
-* A 3-node motif (triad) can be one of 4 isomorphism classes for undirected graphs:
-* - Empty: no edges
-* - 1-edge: single edge
-* - 2-star: two edges sharing a node (path of length 2)
-* - Triangle: three edges (complete graph K3)
-*
-* For directed graphs, there are 16 isomorphism classes.
-*
-* @param graph - The source graph
-* @param includeInstances - Whether to include node instances in the result
-* @returns Motif census with counts and optionally instances
-*/
-function enumerate3NodeMotifs(graph, includeInstances) {
-	const counts = /* @__PURE__ */ new Map();
-	const instances = includeInstances ? /* @__PURE__ */ new Map() : void 0;
-	const nodeList = [...graph.nodeIds()];
-	const n = nodeList.length;
-	for (let i = 0; i < n; i++) {
-		const ni = nodeList[i];
-		if (ni === void 0) continue;
-		for (let j = i + 1; j < n; j++) {
-			const nj = nodeList[j];
-			if (nj === void 0) continue;
-			for (let k = j + 1; k < n; k++) {
-				const nk = nodeList[k];
-				if (nk === void 0) continue;
-				const nodes = [
-					ni,
-					nj,
-					nk
-				];
-				const edges = [];
-				for (const [u, v] of [
-					[0, 1],
-					[0, 2],
-					[1, 2]
-				]) {
-					const nu = nodes[u];
-					const nv = nodes[v];
-					if (nu === void 0 || nv === void 0) continue;
-					if (graph.getEdge(nu, nv) !== void 0) edges.push([u, v]);
-					else if (!graph.directed && graph.getEdge(nv, nu) !== void 0) edges.push([u, v]);
-					else if (graph.directed && graph.getEdge(nv, nu) !== void 0) edges.push([v, u]);
-				}
-				const pattern = canonicalisePattern(3, edges);
-				const count = counts.get(pattern) ?? 0;
-				counts.set(pattern, count + 1);
-				if (includeInstances && instances !== void 0) {
-					if (!instances.has(pattern)) instances.set(pattern, []);
-					const patternInstances = instances.get(pattern);
-					if (patternInstances !== void 0) patternInstances.push([
-						ni,
-						nj,
-						nk
-					]);
-				}
-			}
-		}
-	}
-	if (instances !== void 0) return {
-		counts,
-		instances
-	};
-	return { counts };
-}
-/**
-* Enumerate all 4-node motifs in the graph.
-*
-* A 4-node motif can be one of 11 isomorphism classes for undirected graphs
-* (ranging from empty to complete K4), or many more for directed graphs.
-*
-* @param graph - The source graph
-* @param includeInstances - Whether to include node instances in the result
-* @returns Motif census with counts and optionally instances
-*/
-function enumerate4NodeMotifs(graph, includeInstances) {
-	const counts = /* @__PURE__ */ new Map();
-	const instances = includeInstances ? /* @__PURE__ */ new Map() : void 0;
-	const nodeList = [...graph.nodeIds()];
-	const n = nodeList.length;
-	for (let i = 0; i < n; i++) {
-		const ni = nodeList[i];
-		if (ni === void 0) continue;
-		for (let j = i + 1; j < n; j++) {
-			const nj = nodeList[j];
-			if (nj === void 0) continue;
-			for (let k = j + 1; k < n; k++) {
-				const nk = nodeList[k];
-				if (nk === void 0) continue;
-				for (let l = k + 1; l < n; l++) {
-					const nl = nodeList[l];
-					if (nl === void 0) continue;
-					const nodes = [
-						ni,
-						nj,
-						nk,
-						nl
-					];
-					const edges = [];
-					for (const [u, v] of [
-						[0, 1],
-						[0, 2],
-						[0, 3],
-						[1, 2],
-						[1, 3],
-						[2, 3]
-					]) {
-						const nu = nodes[u];
-						const nv = nodes[v];
-						if (nu === void 0 || nv === void 0) continue;
-						if (graph.getEdge(nu, nv) !== void 0) edges.push([u, v]);
-						else if (!graph.directed && graph.getEdge(nv, nu) !== void 0) edges.push([u, v]);
-						else if (graph.directed && graph.getEdge(nv, nu) !== void 0) edges.push([v, u]);
-					}
-					const pattern = canonicalisePattern(4, edges);
-					const count = counts.get(pattern) ?? 0;
-					counts.set(pattern, count + 1);
-					if (includeInstances && instances !== void 0) {
-						if (!instances.has(pattern)) instances.set(pattern, []);
-						const patternInstances = instances.get(pattern);
-						if (patternInstances !== void 0) patternInstances.push([
-							ni,
-							nj,
-							nk,
-							nl
-						]);
-					}
-				}
-			}
-		}
-	}
-	if (instances !== void 0) return {
-		counts,
-		instances
-	};
-	return { counts };
-}
-/**
-* Human-readable names for common 3-node motifs.
-*/
-var MOTIF_3_NAMES = new Map([
-	["", "empty"],
-	["0-1", "1-edge"],
-	["0-1,0-2", "2-star"],
-	["0-1,1-2", "path-3"],
-	["0-1,0-2,1-2", "triangle"]
-]);
-/**
-* Human-readable names for common 4-node motifs.
-*/
-var MOTIF_4_NAMES = new Map([
-	["", "empty"],
-	["0-1", "1-edge"],
-	["0-1,0-2", "2-star"],
-	["0-1,0-2,0-3", "3-star"],
-	["0-1,0-2,1-2", "triangle"],
-	["0-1,0-2,1-2,2-3", "paw"],
-	["0-1,0-2,2-3", "path-4"],
-	["0-1,0-2,1-3,2-3", "4-cycle"],
-	["0-1,0-2,1-2,0-3,1-3", "diamond"],
-	["0-1,0-2,0-3,1-2,1-3,2-3", "K4"]
-]);
-/**
-* Enumerate motifs of a given size in the graph.
-*
-* This function counts all occurrences of each distinct motif type
-* (isomorphism class) in the graph. For graphs with many nodes,
-* 4-motif enumeration can be expensive (O(n^4) worst case).
-*
-* @param graph - The source graph
-* @param size - Motif size (3 or 4 nodes)
-* @returns Motif census with counts per motif type
-*
-* @example
-* ```typescript
-* // Count all triangles and other 3-node patterns
-* const census3 = enumerateMotifs(graph, 3);
-* console.log(`Triangles: ${census3.counts.get('0-1,0-2,1-2')}`);
-*
-* // Count 4-node patterns
-* const census4 = enumerateMotifs(graph, 4);
-* ```
-*/
-function enumerateMotifs(graph, size) {
-	return size === 3 ? enumerate3NodeMotifs(graph, false) : enumerate4NodeMotifs(graph, false);
-}
-/**
-* Enumerate motifs with optional instance tracking.
-*
-* @param graph - The source graph
-* @param size - Motif size (3 or 4 nodes)
-* @param includeInstances - Whether to include node instances
-* @returns Motif census with counts and optionally instances
-*/
-function enumerateMotifsWithInstances(graph, size, includeInstances) {
-	return size === 3 ? enumerate3NodeMotifs(graph, includeInstances) : enumerate4NodeMotifs(graph, includeInstances);
-}
-/**
-* Get a human-readable name for a motif pattern.
-*
-* @param pattern - The canonical pattern string
-* @param size - Motif size (3 or 4 nodes)
-* @returns A human-readable name, or the pattern itself if unknown
-*/
-function getMotifName(pattern, size) {
-	return (size === 3 ? MOTIF_3_NAMES : MOTIF_4_NAMES).get(pattern) ?? pattern;
-}
-//#endregion
-//#region src/extraction/induced-subgraph.ts
-/**
-* Extract the induced subgraph containing exactly the specified nodes.
-*
-* The induced subgraph includes all nodes from the input set that exist
-* in the original graph, plus all edges where both endpoints are in the set.
-*
-* @param graph - The source graph
-* @param nodes - Set of node IDs to include in the subgraph
-* @returns A new graph containing the induced subgraph
-*
-* @example
-* ```typescript
-* const subgraph = extractInducedSubgraph(graph, new Set(['A', 'B', 'C']));
-* ```
-*/
-function extractInducedSubgraph(graph, nodes) {
-	const result = graph.directed ? require_graph.AdjacencyMapGraph.directed() : require_graph.AdjacencyMapGraph.undirected();
-	for (const nodeId of nodes) {
-		const nodeData = graph.getNode(nodeId);
-		if (nodeData !== void 0) result.addNode(nodeData);
-	}
-	for (const edge of graph.edges()) if (result.hasNode(edge.source) && result.hasNode(edge.target)) result.addEdge(edge);
-	return result;
-}
-//#endregion
-//#region src/extraction/node-filter.ts
-/**
-* Extract a filtered subgraph based on node and edge predicates.
-*
-* Nodes are first filtered by the node predicate (if provided).
-* Edges are then filtered by the edge predicate (if provided), and only
-* retained if both endpoints pass the node predicate.
-*
-* @param graph - The source graph
-* @param options - Filter options specifying node/edge predicates
-* @returns A new graph containing only nodes and edges that pass the predicates
-*
-* @example
-* ```typescript
-* // Extract subgraph of high-weight nodes
-* const filtered = filterSubgraph(graph, {
-*   nodePredicate: (node) => (node.weight ?? 0) > 0.5,
-*   removeIsolated: true
-* });
-* ```
-*/
-function filterSubgraph(graph, options) {
-	const { nodePredicate, edgePredicate, removeIsolated = false } = options ?? {};
-	const result = graph.directed ? require_graph.AdjacencyMapGraph.directed() : require_graph.AdjacencyMapGraph.undirected();
-	const includedNodes = /* @__PURE__ */ new Set();
-	for (const nodeId of graph.nodeIds()) {
-		const nodeData = graph.getNode(nodeId);
-		if (nodeData !== void 0) {
-			if (nodePredicate === void 0 || nodePredicate(nodeData)) {
-				result.addNode(nodeData);
-				includedNodes.add(nodeId);
-			}
-		}
-	}
-	for (const edge of graph.edges()) {
-		if (!includedNodes.has(edge.source) || !includedNodes.has(edge.target)) continue;
-		if (edgePredicate === void 0 || edgePredicate(edge)) result.addEdge(edge);
-	}
-	if (removeIsolated) {
-		const isolatedNodes = [];
-		for (const nodeId of result.nodeIds()) if (result.degree(nodeId) === 0) isolatedNodes.push(nodeId);
-		for (const nodeId of isolatedNodes) result.removeNode(nodeId);
-	}
-	return result;
-}
-//#endregion
-exports.AdjacencyMapGraph = require_graph.AdjacencyMapGraph;
-exports.GPUContext = require_gpu.GPUContext;
+const require_extraction = require("../extraction/index.cjs");
+require("../async/index.cjs");
+exports.AdjacencyMapGraph = require_adjacency_map.AdjacencyMapGraph;
 exports.GPUNotAvailableError = require_gpu.GPUNotAvailableError;
-exports.PriorityQueue = require_structures.PriorityQueue;
+exports.PriorityQueue = require_priority_queue.PriorityQueue;
 exports._computeMean = require_kmeans._computeMean;
-exports.adamicAdar = adamicAdar;
-exports.adamicAdarAsync = adamicAdarAsync;
-exports.adaptive = adaptive;
-exports.adaptiveAsync = adaptiveAsync;
-exports.approximateClusteringCoefficient = require_utils.approximateClusteringCoefficient;
+exports.adamicAdar = require_ranking_mi.adamicAdar;
+exports.adamicAdarAsync = require_ranking_mi.adamicAdarAsync;
+exports.adaptive = require_ranking_mi.adaptive;
+exports.adaptiveAsync = require_ranking_mi.adaptiveAsync;
+exports.approximateClusteringCoefficient = require_utils$1.approximateClusteringCoefficient;
 exports.assertWebGPUAvailable = require_gpu.assertWebGPUAvailable;
-exports.base = base;
-exports.baseAsync = baseAsync;
-exports.batchClusteringCoefficients = require_utils.batchClusteringCoefficients;
-exports.betweenness = betweenness;
+exports.base = require_expansion.base;
+exports.baseAsync = require_expansion.baseAsync;
+exports.batchClusteringCoefficients = require_utils$1.batchClusteringCoefficients;
+exports.betweenness = require_ranking.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.collectAsyncIterable = require_utils.collectAsyncIterable;
+exports.communicability = require_ranking.communicability;
+exports.computeJaccard = require_utils$1.computeJaccard;
+exports.computeTrussNumbers = require_extraction.computeTrussNumbers;
+exports.cosine = require_ranking_mi.cosine;
+exports.cosineAsync = require_ranking_mi.cosineAsync;
+exports.countEdgesOfType = require_utils$1.countEdgesOfType;
+exports.countNodesOfType = require_utils$1.countNodesOfType;
+exports.csrToTypedBuffers = require_gpu.csrToTypedBuffers;
+exports.defaultYieldStrategy = require_utils.defaultYieldStrategy;
+exports.degreeSum = require_ranking.degreeSum;
 exports.detectWebGPU = require_gpu.detectWebGPU;
 exports.dfs = require_traversal.dfs;
-exports.dfsPriority = dfsPriority;
-exports.dfsPriorityAsync = dfsPriorityAsync;
-exports.dfsPriorityFn = dfsPriorityFn;
+exports.dfsPriority = require_expansion.dfsPriority;
+exports.dfsPriorityAsync = require_expansion.dfsPriorityAsync;
+exports.dfsPriorityFn = require_expansion.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.dome = require_expansion.dome;
+exports.domeAsync = require_expansion.domeAsync;
+exports.domeHighDegree = require_expansion.domeHighDegree;
+exports.domeHighDegreeAsync = require_expansion.domeHighDegreeAsync;
+exports.edge = require_expansion.edge;
+exports.edgeAsync = require_expansion.edgeAsync;
+exports.entropyFromCounts = require_utils$1.entropyFromCounts;
+exports.enumerateMotifs = require_extraction.enumerateMotifs;
+exports.enumerateMotifsWithInstances = require_extraction.enumerateMotifsWithInstances;
+exports.etch = require_ranking_mi.etch;
+exports.etchAsync = require_ranking_mi.etchAsync;
+exports.extractEgoNetwork = require_extraction.extractEgoNetwork;
+exports.extractInducedSubgraph = require_extraction.extractInducedSubgraph;
+exports.extractKCore = require_extraction.extractKCore;
+exports.extractKTruss = require_extraction.extractKTruss;
+exports.filterSubgraph = require_extraction.filterSubgraph;
+exports.flux = require_expansion.flux;
+exports.fluxAsync = require_expansion.fluxAsync;
+exports.frontierBalanced = require_expansion.frontierBalanced;
+exports.frontierBalancedAsync = require_expansion.frontierBalancedAsync;
+exports.fuse = require_expansion.fuse;
+exports.fuseAsync = require_expansion.fuseAsync;
+exports.getMotifName = require_extraction.getMotifName;
+exports.gpuBfsLevels = require_gpu.gpuBfsLevels;
+exports.gpuDegreeHistogram = require_gpu.gpuDegreeHistogram;
+exports.gpuJaccardBatch = require_gpu.gpuJaccardBatch;
+exports.gpuPageRank = require_gpu.gpuPageRank;
+exports.gpuSpmv = require_gpu.gpuSpmv;
 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.hae = require_expansion.hae;
+exports.haeAsync = require_expansion.haeAsync;
+exports.hittingTime = require_ranking.hittingTime;
+exports.hubPromoted = require_ranking_mi.hubPromoted;
+exports.hubPromotedAsync = require_ranking_mi.hubPromotedAsync;
+exports.initGPU = require_gpu.initGPU;
+exports.initGPUFromDevice = require_gpu.initGPUFromDevice;
 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.jaccard = require_jaccard.jaccard;
+exports.jaccardArithmetic = require_ranking.jaccardArithmetic;
+exports.jaccardAsync = require_jaccard.jaccardAsync;
+exports.kHop = require_expansion.kHop;
+exports.katz = require_ranking.katz;
+exports.lace = require_expansion.lace;
+exports.laceAsync = require_expansion.laceAsync;
+exports.localClusteringCoefficient = require_utils$1.localClusteringCoefficient;
+exports.localTypeEntropy = require_utils$1.localTypeEntropy;
+exports.maze = require_expansion.maze;
+exports.mazeAsync = require_expansion.mazeAsync;
 exports.miniBatchKMeans = require_kmeans.miniBatchKMeans;
-exports.neighbourIntersection = require_utils.neighbourIntersection;
-exports.neighbourOverlap = require_utils.neighbourOverlap;
-exports.neighbourSet = require_utils.neighbourSet;
+exports.neighbourIntersection = require_utils$1.neighbourIntersection;
+exports.neighbourOverlap = require_utils$1.neighbourOverlap;
+exports.neighbourSet = require_utils$1.neighbourSet;
 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.normalisedEntropy = require_utils$1.normalisedEntropy;
+exports.notch = require_ranking_mi.notch;
+exports.notchAsync = require_ranking_mi.notchAsync;
+exports.opDegree = require_ops.opDegree;
+exports.opGetEdge = require_ops.opGetEdge;
+exports.opGetNode = require_ops.opGetNode;
+exports.opHasNode = require_ops.opHasNode;
+exports.opNeighbours = require_ops.opNeighbours;
+exports.opProgress = require_ops.opProgress;
+exports.opYield = require_ops.opYield;
+exports.overlapCoefficient = require_ranking_mi.overlapCoefficient;
+exports.overlapCoefficientAsync = require_ranking_mi.overlapCoefficientAsync;
+exports.pagerank = require_ranking.pagerank;
+exports.parse = require_ranking.parse;
+exports.parseAsync = require_ranking.parseAsync;
+exports.pipe = require_expansion.pipe;
+exports.pipeAsync = require_expansion.pipeAsync;
+exports.randomPriority = require_expansion.randomPriority;
+exports.randomPriorityAsync = require_expansion.randomPriorityAsync;
+exports.randomRanking = require_ranking.randomRanking;
+exports.randomWalk = require_expansion.randomWalk;
+exports.reach = require_expansion.reach;
+exports.reachAsync = require_expansion.reachAsync;
+exports.resistanceDistance = require_ranking.resistanceDistance;
+exports.resolveAsyncOp = require_ops.resolveAsyncOp;
+exports.resolveSyncOp = require_ops.resolveSyncOp;
+exports.resourceAllocation = require_ranking_mi.resourceAllocation;
+exports.resourceAllocationAsync = require_ranking_mi.resourceAllocationAsync;
+exports.runAsync = require_ops.runAsync;
+exports.runSync = require_ops.runSync;
+exports.sage = require_expansion.sage;
+exports.sageAsync = require_expansion.sageAsync;
+exports.scale = require_ranking_mi.scale;
+exports.scaleAsync = require_ranking_mi.scaleAsync;
+exports.shannonEntropy = require_utils$1.shannonEntropy;
+exports.shortest = require_ranking.shortest;
+exports.sift = require_expansion.sift;
+exports.siftAsync = require_expansion.siftAsync;
+exports.skew = require_ranking_mi.skew;
+exports.skewAsync = require_ranking_mi.skewAsync;
+exports.sorensen = require_ranking_mi.sorensen;
+exports.sorensenAsync = require_ranking_mi.sorensenAsync;
+exports.span = require_ranking_mi.span;
+exports.spanAsync = require_ranking_mi.spanAsync;
+exports.standardBfs = require_expansion.standardBfs;
+exports.standardBfsAsync = require_expansion.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
+exports.tide = require_expansion.tide;
+exports.tideAsync = require_expansion.tideAsync;
+exports.warp = require_expansion.warp;
+exports.warpAsync = require_expansion.warpAsync;
+exports.widestPath = require_ranking.widestPath;
+exports.withBackend = require_gpu.withBackend;