graphwise 1.8.0 → 1.9.0

package/dist/index/index.js

@@ -1,3920 +1,18 @@
-import { AdjacencyMapGraph } from "../graph/index.js";
+import { a as gpuSpmv, c as initGPUFromDevice, d as isWebGPUAvailable, f as csrToTypedBuffers, i as gpuPageRank, l as assertWebGPUAvailable, m as GPUNotAvailableError, n as gpuDegreeHistogram, o as withBackend, p as graphToCSR, r as gpuJaccardBatch, s as initGPU, t as gpuBfsLevels, u as detectWebGPU } from "../gpu-CHiCN0wa.js";
+import { t as AdjacencyMapGraph } from "../adjacency-map-BtKzcuJq.js";
+import "../graph/index.js";
 import { bfs, bfsWithPath, dfs, dfsWithPath } from "../traversal/index.js";
-import { PriorityQueue } from "../structures/index.js";
-import { n as miniBatchKMeans, r as normaliseFeatures, t as _computeMean } from "../kmeans-87ExSUNZ.js";
+import { t as PriorityQueue } from "../priority-queue-CFDd5cBg.js";
+import "../structures/index.js";
+import { n as defaultYieldStrategy, t as collectAsyncIterable } from "../utils-BodeE2Mo.js";
+import { a as opNeighbours, c as resolveAsyncOp, d as runSync, i as opHasNode, l as resolveSyncOp, n as opGetEdge, o as opProgress, r as opGetNode, s as opYield, t as opDegree, u as runAsync } from "../ops-upIi6JIi.js";
+import { A as pipe, B as base, C as tideAsync, D as reachAsync, E as reach, F as haeAsync, I as dome, L as domeAsync, M as edge, N as edgeAsync, O as sage, P as hae, R as domeHighDegree, S as tide, T as mazeAsync, V as baseAsync, _ as fuseAsync, a as dfsPriorityFn, b as lace, c as frontierBalanced, d as standardBfsAsync, f as flux, g as fuse, h as siftAsync, i as dfsPriorityAsync, j as pipeAsync, k as sageAsync, l as frontierBalancedAsync, m as sift, n as kHop, o as randomPriority, p as fluxAsync, r as dfsPriority, s as randomPriorityAsync, t as randomWalk, u as standardBfs, v as warp, w as maze, x as laceAsync, y as warpAsync, z as domeHighDegreeAsync } from "../expansion-ClDhlMK8.js";
+import { n as miniBatchKMeans, r as normaliseFeatures, t as _computeMean } from "../kmeans-DKkL9rAN.js";
 import { approximateClusteringCoefficient, batchClusteringCoefficients, computeJaccard, countEdgesOfType, countNodesOfType, entropyFromCounts, localClusteringCoefficient, localTypeEntropy, neighbourIntersection, neighbourOverlap, neighbourSet, normalisedEntropy, shannonEntropy } from "../utils/index.js";
+import { n as jaccardAsync, t as jaccard } from "../jaccard-3rCdilwm.js";
+import { a as katz, c as jaccardArithmetic, d as shortest, f as parse, i as communicability, l as widestPath, n as randomRanking, o as betweenness, p as parseAsync, r as resistanceDistance, s as pagerank, t as hittingTime, u as degreeSum } from "../ranking-3ez5m67U.js";
+import { adamicAdar, adamicAdarAsync, adaptive, adaptiveAsync, cosine, cosineAsync, etch, etchAsync, hubPromoted, hubPromotedAsync, notch, notchAsync, overlapCoefficient, overlapCoefficientAsync, resourceAllocation, resourceAllocationAsync, scale, scaleAsync, skew, skewAsync, sorensen, sorensenAsync, span, spanAsync } from "../ranking/mi/index.js";
 import { grasp, stratified } from "../seeds/index.js";
-import { GPUContext, GPUNotAvailableError, assertWebGPUAvailable, createGPUContext, createResultBuffer, csrToGPUBuffers, detectWebGPU, getGPUContext, graphToCSR, isWebGPUAvailable, readBufferToCPU } from "../gpu/index.js";
-import { collectAsyncIterable, defaultYieldStrategy, opDegree, opGetEdge, opGetNode, opHasNode, opNeighbours, opProgress, opYield, resolveAsyncOp, resolveSyncOp, runAsync, runSync } from "../async/index.js";
-//#region src/expansion/base-helpers.ts
-/**
-* Check whether expansion should continue given current progress.
-*
-* 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 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* 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* 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* 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 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 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 / (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 } = 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([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
-	const srcSet = new Set(sourceNeighboursArr.filter((n) => n !== target));
-	const tgtSet = new Set(targetNeighboursArr.filter((n) => n !== source));
-	if (srcSet.size === 0 && tgtSet.size === 0) return 0;
-	let intersection = 0;
-	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
-	const union = srcSet.size + tgtSet.size - intersection;
-	const jaccardScore = union > 0 ? intersection / union : 0;
-	return Math.max(epsilon, jaccardScore);
-}
-//#endregion
-//#region src/expansion/reach.ts
-/**
-* 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 = neighbourIntersection(neighbourSet(graph, source, target), 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([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
-	const srcSet = new Set(sourceArr.filter((n) => n !== target));
-	const tgtSet = new Set(targetArr.filter((n) => n !== source));
-	const commonNeighbours = [];
-	for (const n of srcSet) if (tgtSet.has(n)) commonNeighbours.push(n);
-	if (commonNeighbours.length === 0) return epsilon;
-	const degrees = await Promise.all(commonNeighbours.map((n) => graph.degree(n)));
-	let score = 0;
-	for (const degree of degrees) score += 1 / Math.log(degree + 1);
-	if (normalise) {
-		const maxScore = commonNeighbours.length / Math.log(2);
-		score = score / maxScore;
-	}
-	return Math.max(epsilon, score);
-}
-//#endregion
-//#region src/ranking/mi/cosine.ts
-/**
-* 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 = neighbourSet(graph, source, target);
-	const targetNeighbours = neighbourSet(graph, target, source);
-	const { intersection } = 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([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
-	const srcSet = new Set(sourceArr.filter((n) => n !== target));
-	const tgtSet = new Set(targetArr.filter((n) => n !== source));
-	let intersection = 0;
-	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
-	const denominator = Math.sqrt(srcSet.size) * Math.sqrt(tgtSet.size);
-	if (denominator === 0) return 0;
-	const score = intersection / denominator;
-	return Math.max(epsilon, score);
-}
-//#endregion
-//#region src/ranking/mi/sorensen.ts
-/**
-* 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 = neighbourSet(graph, source, target);
-	const targetNeighbours = neighbourSet(graph, target, source);
-	const { intersection } = 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([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
-	const srcSet = new Set(sourceArr.filter((n) => n !== target));
-	const tgtSet = new Set(targetArr.filter((n) => n !== source));
-	let intersection = 0;
-	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
-	const denominator = srcSet.size + tgtSet.size;
-	if (denominator === 0) return 0;
-	const score = 2 * intersection / denominator;
-	return Math.max(epsilon, score);
-}
-//#endregion
-//#region src/ranking/mi/resource-allocation.ts
-/**
-* 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 = neighbourIntersection(neighbourSet(graph, source, target), 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([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
-	const srcSet = new Set(sourceArr.filter((n) => n !== target));
-	const tgtSet = new Set(targetArr.filter((n) => n !== source));
-	const commonNeighbours = [];
-	for (const n of srcSet) if (tgtSet.has(n)) commonNeighbours.push(n);
-	if (commonNeighbours.length === 0) return epsilon;
-	const degrees = await Promise.all(commonNeighbours.map((n) => graph.degree(n)));
-	let score = 0;
-	for (const degree of degrees) if (degree > 0) score += 1 / degree;
-	if (normalise) {
-		const maxScore = commonNeighbours.length;
-		score = score / maxScore;
-	}
-	return Math.max(epsilon, score);
-}
-//#endregion
-//#region src/ranking/mi/overlap-coefficient.ts
-/**
-* 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 = neighbourSet(graph, source, target);
-	const targetNeighbours = neighbourSet(graph, target, source);
-	const { intersection } = 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([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
-	const srcSet = new Set(sourceArr.filter((n) => n !== target));
-	const tgtSet = new Set(targetArr.filter((n) => n !== source));
-	let intersection = 0;
-	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
-	const denominator = Math.min(srcSet.size, tgtSet.size);
-	if (denominator === 0) return 0;
-	const score = intersection / denominator;
-	return Math.max(epsilon, score);
-}
-//#endregion
-//#region src/ranking/mi/hub-promoted.ts
-/**
-* 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 } = neighbourOverlap(neighbourSet(graph, source, target), 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([
-		collectAsyncIterable(graph.neighbours(source)),
-		collectAsyncIterable(graph.neighbours(target)),
-		graph.degree(source),
-		graph.degree(target)
-	]);
-	const srcSet = new Set(sourceArr.filter((n) => n !== target));
-	const tgtSet = new Set(targetArr.filter((n) => n !== source));
-	let intersection = 0;
-	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
-	const denominator = Math.min(sourceDegree, targetDegree);
-	if (denominator === 0) return 0;
-	const score = intersection / denominator;
-	return Math.max(epsilon, score);
-}
-//#endregion
-//#region src/ranking/mi/scale.ts
-/**
-* Compute SCALE MI between two nodes.
-*/
-function scale(graph, source, target, config) {
-	const { epsilon = 1e-10 } = config ?? {};
-	const { jaccard: jaccardScore } = 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([
-		collectAsyncIterable(graph.neighbours(source)),
-		collectAsyncIterable(graph.neighbours(target)),
-		graph.nodeCount,
-		graph.edgeCount
-	]);
-	const srcSet = new Set(sourceArr.filter((node) => node !== target));
-	const tgtSet = new Set(targetArr.filter((node) => node !== source));
-	let intersection = 0;
-	for (const node of srcSet) if (tgtSet.has(node)) intersection++;
-	const union = srcSet.size + tgtSet.size - intersection;
-	const jaccardScore = union > 0 ? intersection / union : 0;
-	const possibleEdges = n * (n - 1);
-	const density = possibleEdges > 0 ? (graph.directed ? m : 2 * m) / possibleEdges : 0;
-	if (density === 0) return epsilon;
-	const score = jaccardScore / density;
-	return Math.max(epsilon, score);
-}
-//#endregion
-//#region src/ranking/mi/skew.ts
-/**
-* Compute SKEW MI between two nodes.
-*/
-function skew(graph, source, target, config) {
-	const { epsilon = 1e-10 } = config ?? {};
-	const { jaccard: jaccardScore } = 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([
-		collectAsyncIterable(graph.neighbours(source)),
-		collectAsyncIterable(graph.neighbours(target)),
-		graph.nodeCount,
-		graph.degree(source),
-		graph.degree(target)
-	]);
-	const srcSet = new Set(sourceArr.filter((n) => n !== target));
-	const tgtSet = new Set(targetArr.filter((n) => n !== source));
-	let intersection = 0;
-	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
-	const union = srcSet.size + tgtSet.size - intersection;
-	const jaccardScore = union > 0 ? intersection / union : 0;
-	const sourceIdf = Math.log(N / (sourceDegree + 1));
-	const targetIdf = Math.log(N / (targetDegree + 1));
-	const score = jaccardScore * sourceIdf * targetIdf;
-	return Math.max(epsilon, score);
-}
-//#endregion
-//#region src/ranking/mi/span.ts
-/**
-* Compute SPAN MI between two nodes.
-*/
-function span(graph, source, target, config) {
-	const { epsilon = 1e-10 } = config ?? {};
-	const { jaccard: jaccardScore } = computeJaccard(graph, source, target);
-	const sourceCc = localClusteringCoefficient(graph, source);
-	const targetCc = 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([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
-	const srcSet = new Set(sourceArr.filter((n) => n !== target));
-	const tgtSet = new Set(targetArr.filter((n) => n !== source));
-	let intersection = 0;
-	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
-	const union = srcSet.size + tgtSet.size - intersection;
-	const jaccardScore = union > 0 ? intersection / union : 0;
-	const computeClusteringCoefficient = async (nodeId, neighbourArr) => {
-		const degree = neighbourArr.length;
-		if (degree < 2) return 0;
-		const pairs = [];
-		for (let i = 0; i < neighbourArr.length; i++) for (let j = i + 1; j < neighbourArr.length; j++) {
-			const u = neighbourArr[i];
-			const v = neighbourArr[j];
-			if (u !== void 0 && v !== void 0) pairs.push([u, v]);
-		}
-		const edgeResults = await Promise.all(pairs.flatMap(([u, v]) => [graph.getEdge(u, v), graph.getEdge(v, u)]));
-		let triangleCount = 0;
-		for (let i = 0; i < pairs.length; i++) if (edgeResults[2 * i] !== void 0 || edgeResults[2 * i + 1] !== void 0) triangleCount++;
-		const possibleTriangles = degree * (degree - 1) / 2;
-		return triangleCount / possibleTriangles;
-	};
-	const [sourceCc, targetCc] = await Promise.all([computeClusteringCoefficient(source, sourceArr), computeClusteringCoefficient(target, targetArr)]);
-	const score = jaccardScore * (1 - Math.max(sourceCc, targetCc));
-	return Math.max(epsilon, score);
-}
-//#endregion
-//#region src/ranking/mi/etch.ts
-/**
-* Compute ETCH MI between two nodes.
-*/
-function etch(graph, source, target, config) {
-	const { epsilon = 1e-10 } = config ?? {};
-	const { jaccard: jaccardScore } = computeJaccard(graph, source, target);
-	const edge = graph.getEdge(source, target);
-	if (edge?.type === void 0) return Math.max(epsilon, jaccardScore);
-	const edgeTypeCount = 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([
-		collectAsyncIterable(graph.neighbours(source)),
-		collectAsyncIterable(graph.neighbours(target)),
-		graph.getEdge(source, target)
-	]);
-	const srcSet = new Set(sourceArr.filter((n) => n !== target));
-	const tgtSet = new Set(targetArr.filter((n) => n !== source));
-	let intersection = 0;
-	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
-	const union = srcSet.size + tgtSet.size - intersection;
-	const jaccardScore = union > 0 ? intersection / union : 0;
-	if (edge?.type === void 0) return Math.max(epsilon, jaccardScore);
-	const edgeType = edge.type;
-	let edgeTypeCount = 0;
-	let totalEdges = 0;
-	for await (const e of graph.edges()) {
-		totalEdges++;
-		if (e.type === edgeType) edgeTypeCount++;
-	}
-	if (edgeTypeCount === 0) return Math.max(epsilon, jaccardScore);
-	const score = jaccardScore * Math.log(totalEdges / edgeTypeCount);
-	return Math.max(epsilon, score);
-}
-//#endregion
-//#region src/ranking/mi/notch.ts
-/**
-* Compute NOTCH MI between two nodes.
-*/
-function notch(graph, source, target, config) {
-	const { epsilon = 1e-10 } = config ?? {};
-	const { jaccard: jaccardScore } = 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 = countNodesOfType(graph, sourceNode.type);
-	const targetTypeCount = 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([
-		collectAsyncIterable(graph.neighbours(source)),
-		collectAsyncIterable(graph.neighbours(target)),
-		graph.getNode(source),
-		graph.getNode(target)
-	]);
-	const srcSet = new Set(sourceArr.filter((n) => n !== target));
-	const tgtSet = new Set(targetArr.filter((n) => n !== source));
-	let intersection = 0;
-	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
-	const union = srcSet.size + tgtSet.size - intersection;
-	const jaccardScore = union > 0 ? intersection / union : 0;
-	if (sourceNode?.type === void 0 || targetNode?.type === void 0) return Math.max(epsilon, jaccardScore);
-	const sourceType = sourceNode.type;
-	const targetType = targetNode.type;
-	let totalNodes = 0;
-	let sourceTypeCount = 0;
-	let targetTypeCount = 0;
-	for await (const nodeId of graph.nodeIds()) {
-		totalNodes++;
-		const node = await graph.getNode(nodeId);
-		if (node?.type === sourceType) sourceTypeCount++;
-		if (node?.type === targetType) targetTypeCount++;
-	}
-	if (sourceTypeCount === 0 || targetTypeCount === 0) return Math.max(epsilon, jaccardScore);
-	const sourceRarity = Math.log(totalNodes / sourceTypeCount);
-	const targetRarity = Math.log(totalNodes / targetTypeCount);
-	const score = jaccardScore * sourceRarity * targetRarity;
-	return Math.max(epsilon, score);
-}
-//#endregion
-//#region src/ranking/mi/adaptive.ts
-/**
-* 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 } = 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 } = 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([
-		collectAsyncIterable(graph.neighbours(source)),
-		collectAsyncIterable(graph.neighbours(target)),
-		adamicAdarAsync(graph, source, target, {
-			epsilon,
-			normalise: true
-		})
-	]);
-	const srcSet = new Set(sourceArr.filter((n) => n !== target));
-	const tgtSet = new Set(targetArr.filter((n) => n !== source));
-	let intersection = 0;
-	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
-	const union = srcSet.size + tgtSet.size - intersection;
-	const jaccardScore = union > 0 ? intersection / union : 0;
-	const structural = srcSet.size === 0 && tgtSet.size === 0 ? 0 : Math.max(epsilon, jaccardScore);
-	let overlap;
-	if (srcSet.size > 0 && tgtSet.size > 0) {
-		const minDegree = Math.min(srcSet.size, tgtSet.size);
-		overlap = minDegree > 0 ? intersection / minDegree : epsilon;
-	} else overlap = epsilon;
-	const totalWeight = structuralWeight + degreeWeight + overlapWeight;
-	const score = (structuralWeight * structural + degreeWeight * degreeComponent + overlapWeight * overlap) / totalWeight;
-	return Math.max(epsilon, Math.min(1, score));
-}
-//#endregion
-//#region src/ranking/baselines/utils.ts
-/**
-* 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 ? AdjacencyMapGraph.directed() : 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 ? AdjacencyMapGraph.directed() : 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 ? AdjacencyMapGraph.directed() : 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 ? AdjacencyMapGraph.directed() : 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 ? AdjacencyMapGraph.directed() : 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
-export { AdjacencyMapGraph, GPUContext, GPUNotAvailableError, PriorityQueue, _computeMean, adamicAdar, adamicAdarAsync, adaptive, adaptiveAsync, approximateClusteringCoefficient, assertWebGPUAvailable, base, baseAsync, batchClusteringCoefficients, betweenness, bfs, bfsWithPath, collectAsyncIterable, communicability, computeJaccard, computeTrussNumbers, cosine, cosineAsync, countEdgesOfType, countNodesOfType, createGPUContext, createResultBuffer, csrToGPUBuffers, defaultYieldStrategy, degreeSum, detectWebGPU, dfs, dfsPriority, dfsPriorityAsync, dfsPriorityFn, dfsWithPath, dome, domeAsync, domeHighDegree, domeHighDegreeAsync, edge, edgeAsync, entropyFromCounts, enumerateMotifs, enumerateMotifsWithInstances, etch, etchAsync, extractEgoNetwork, extractInducedSubgraph, extractKCore, extractKTruss, filterSubgraph, flux, fluxAsync, frontierBalanced, frontierBalancedAsync, fuse, fuseAsync, getGPUContext, getMotifName, graphToCSR, grasp, hae, haeAsync, hittingTime, hubPromoted, hubPromotedAsync, isWebGPUAvailable, jaccard, jaccardArithmetic, jaccardAsync, kHop, katz, lace, laceAsync, localClusteringCoefficient, localTypeEntropy, maze, mazeAsync, miniBatchKMeans, neighbourIntersection, neighbourOverlap, neighbourSet, normaliseFeatures, normaliseFeatures as zScoreNormalise, normalisedEntropy, notch, notchAsync, opDegree, opGetEdge, opGetNode, opHasNode, opNeighbours, opProgress, opYield, overlapCoefficient, overlapCoefficientAsync, pagerank, parse, parseAsync, pipe, pipeAsync, randomPriority, randomPriorityAsync, randomRanking, randomWalk, reach, reachAsync, readBufferToCPU, resistanceDistance, resolveAsyncOp, resolveSyncOp, resourceAllocation, resourceAllocationAsync, runAsync, runSync, sage, sageAsync, scale, scaleAsync, shannonEntropy, shortest, sift, siftAsync, skew, skewAsync, sorensen, sorensenAsync, span, spanAsync, standardBfs, standardBfsAsync, stratified, tide, tideAsync, warp, warpAsync, widestPath };
-
-//# sourceMappingURL=index.js.map
+import { computeTrussNumbers, enumerateMotifs, enumerateMotifsWithInstances, extractEgoNetwork, extractInducedSubgraph, extractKCore, extractKTruss, filterSubgraph, getMotifName } from "../extraction/index.js";
+import "../async/index.js";
+export { AdjacencyMapGraph, GPUNotAvailableError, PriorityQueue, _computeMean, adamicAdar, adamicAdarAsync, adaptive, adaptiveAsync, approximateClusteringCoefficient, assertWebGPUAvailable, base, baseAsync, batchClusteringCoefficients, betweenness, bfs, bfsWithPath, collectAsyncIterable, communicability, computeJaccard, computeTrussNumbers, cosine, cosineAsync, countEdgesOfType, countNodesOfType, csrToTypedBuffers, defaultYieldStrategy, degreeSum, detectWebGPU, dfs, dfsPriority, dfsPriorityAsync, dfsPriorityFn, dfsWithPath, dome, domeAsync, domeHighDegree, domeHighDegreeAsync, edge, edgeAsync, entropyFromCounts, enumerateMotifs, enumerateMotifsWithInstances, etch, etchAsync, extractEgoNetwork, extractInducedSubgraph, extractKCore, extractKTruss, filterSubgraph, flux, fluxAsync, frontierBalanced, frontierBalancedAsync, fuse, fuseAsync, getMotifName, gpuBfsLevels, gpuDegreeHistogram, gpuJaccardBatch, gpuPageRank, gpuSpmv, graphToCSR, grasp, hae, haeAsync, hittingTime, hubPromoted, hubPromotedAsync, initGPU, initGPUFromDevice, isWebGPUAvailable, jaccard, jaccardArithmetic, jaccardAsync, kHop, katz, lace, laceAsync, localClusteringCoefficient, localTypeEntropy, maze, mazeAsync, miniBatchKMeans, neighbourIntersection, neighbourOverlap, neighbourSet, normaliseFeatures, normaliseFeatures as zScoreNormalise, normalisedEntropy, notch, notchAsync, opDegree, opGetEdge, opGetNode, opHasNode, opNeighbours, opProgress, opYield, overlapCoefficient, overlapCoefficientAsync, pagerank, parse, parseAsync, pipe, pipeAsync, randomPriority, randomPriorityAsync, randomRanking, randomWalk, reach, reachAsync, resistanceDistance, resolveAsyncOp, resolveSyncOp, resourceAllocation, resourceAllocationAsync, runAsync, runSync, sage, sageAsync, scale, scaleAsync, shannonEntropy, shortest, sift, siftAsync, skew, skewAsync, sorensen, sorensenAsync, span, spanAsync, standardBfs, standardBfsAsync, stratified, tide, tideAsync, warp, warpAsync, widestPath, withBackend };