graphwise 1.8.0 → 1.8.1

package/dist/expansion-FkmEYlrQ.cjs

@@ -0,0 +1,1949 @@
+const require_priority_queue = require("./priority-queue-ChVLoG6T.cjs");
+const require_ops = require("./ops-4nmI-pwk.cjs");
+const require_utils = require("./utils/index.cjs");
+const require_jaccard = require("./jaccard-Bmd1IEFO.cjs");
+//#region src/expansion/base-helpers.ts
+/**
+* Check whether expansion should continue given current progress.
+*
+* Returns shouldContinue=false as soon as any configured limit is reached,
+* along with the appropriate termination reason.
+*
+* @param iterations - Number of iterations completed so far
+* @param nodesVisited - Number of distinct nodes visited so far
+* @param pathsFound - Number of paths discovered so far
+* @param limits - Configured expansion limits (0 = unlimited)
+* @returns Whether to continue and the termination reason if stopping
+*/
+function continueExpansion(iterations, nodesVisited, pathsFound, limits) {
+	if (limits.maxIterations > 0 && iterations >= limits.maxIterations) return {
+		shouldContinue: false,
+		termination: "limit"
+	};
+	if (limits.maxNodes > 0 && nodesVisited >= limits.maxNodes) return {
+		shouldContinue: false,
+		termination: "limit"
+	};
+	if (limits.maxPaths > 0 && pathsFound >= limits.maxPaths) return {
+		shouldContinue: false,
+		termination: "limit"
+	};
+	return {
+		shouldContinue: true,
+		termination: "exhausted"
+	};
+}
+/**
+* Reconstruct path from collision point.
+*
+* Traces backwards through the predecessor maps of both frontiers from the
+* collision node, then concatenates the two halves to form the full path.
+*
+* @param collisionNode - The node where the two frontiers met
+* @param frontierA - Index of the first frontier
+* @param frontierB - Index of the second frontier
+* @param predecessors - Predecessor maps, one per frontier
+* @param seeds - Seed nodes, one per frontier
+* @returns The reconstructed path, or null if seeds are missing
+*/
+function reconstructPath$1(collisionNode, frontierA, frontierB, predecessors, seeds) {
+	const pathA = [collisionNode];
+	const predA = predecessors[frontierA];
+	if (predA !== void 0) {
+		let node = collisionNode;
+		let next = predA.get(node);
+		while (next !== null && next !== void 0) {
+			node = next;
+			pathA.unshift(node);
+			next = predA.get(node);
+		}
+	}
+	const pathB = [];
+	const predB = predecessors[frontierB];
+	if (predB !== void 0) {
+		let node = collisionNode;
+		let next = predB.get(node);
+		while (next !== null && next !== void 0) {
+			node = next;
+			pathB.push(node);
+			next = predB.get(node);
+		}
+	}
+	const fullPath = [...pathA, ...pathB];
+	const seedA = seeds[frontierA];
+	const seedB = seeds[frontierB];
+	if (seedA === void 0 || seedB === void 0) return null;
+	return {
+		fromSeed: seedA,
+		toSeed: seedB,
+		nodes: fullPath
+	};
+}
+/**
+* Create an empty expansion result for early termination (e.g. no seeds given).
+*
+* @param algorithm - Name of the algorithm producing this result
+* @param startTime - performance.now() timestamp taken before the algorithm began
+* @returns An ExpansionResult with zero paths and zero stats
+*/
+function emptyResult$2(algorithm, startTime) {
+	return {
+		paths: [],
+		sampledNodes: /* @__PURE__ */ new Set(),
+		sampledEdges: /* @__PURE__ */ new Set(),
+		visitedPerFrontier: [],
+		stats: {
+			iterations: 0,
+			nodesVisited: 0,
+			edgesTraversed: 0,
+			pathsFound: 0,
+			durationMs: performance.now() - startTime,
+			algorithm,
+			termination: "exhausted"
+		}
+	};
+}
+//#endregion
+//#region src/expansion/base-core.ts
+/**
+* Default priority function — degree-ordered (DOME).
+*
+* Lower degree = higher priority, so sparse nodes are explored before hubs.
+*/
+function degreePriority(_nodeId, context) {
+	return context.degree;
+}
+/**
+* Generator core of the BASE expansion algorithm.
+*
+* Yields GraphOp objects to request graph data, allowing the caller to
+* provide a sync or async runner. The optional `graphRef` parameter is
+* required when the priority function accesses `context.graph` — it is
+* populated in sync mode by `base()`. In async mode (Phase 4+), a proxy
+* graph may be supplied instead.
+*
+* @param graphMeta - Immutable graph metadata (directed, nodeCount, edgeCount)
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration (priority, limits, debug)
+* @param graphRef - Optional real graph reference for context.graph in priority functions
+* @returns An ExpansionResult with all discovered paths and statistics
+*/
+function* baseCore(graphMeta, seeds, config, graphRef) {
+	const startTime = performance.now();
+	const { maxNodes = 0, maxIterations = 0, maxPaths = 0, priority = degreePriority, debug = false } = config ?? {};
+	if (seeds.length === 0) return emptyResult$2("base", startTime);
+	const numFrontiers = seeds.length;
+	const allVisited = /* @__PURE__ */ new Set();
+	const combinedVisited = /* @__PURE__ */ new Map();
+	const visitedByFrontier = [];
+	const predecessors = [];
+	const queues = [];
+	for (let i = 0; i < numFrontiers; i++) {
+		visitedByFrontier.push(/* @__PURE__ */ new Map());
+		predecessors.push(/* @__PURE__ */ new Map());
+		queues.push(new require_priority_queue.PriorityQueue());
+		const seed = seeds[i];
+		if (seed === void 0) continue;
+		const seedNode = seed.id;
+		predecessors[i]?.set(seedNode, null);
+		combinedVisited.set(seedNode, i);
+		allVisited.add(seedNode);
+		const seedDegree = yield* require_ops.opDegree(seedNode);
+		const seedPriority = priority(seedNode, buildPriorityContext(seedNode, i, combinedVisited, allVisited, [], 0, seedDegree, graphRef));
+		queues[i]?.push({
+			nodeId: seedNode,
+			frontierIndex: i,
+			predecessor: null
+		}, seedPriority);
+	}
+	const sampledEdgeMap = /* @__PURE__ */ new Map();
+	const discoveredPaths = [];
+	let iterations = 0;
+	let edgesTraversed = 0;
+	let termination = "exhausted";
+	const limits = {
+		maxIterations,
+		maxNodes,
+		maxPaths
+	};
+	for (;;) {
+		const check = continueExpansion(iterations, allVisited.size, discoveredPaths.length, limits);
+		if (!check.shouldContinue) {
+			termination = check.termination;
+			break;
+		}
+		let lowestPriority = Number.POSITIVE_INFINITY;
+		let activeFrontier = -1;
+		for (let i = 0; i < numFrontiers; i++) {
+			const queue = queues[i];
+			if (queue !== void 0 && !queue.isEmpty()) {
+				const peek = queue.peek();
+				if (peek !== void 0 && peek.priority < lowestPriority) {
+					lowestPriority = peek.priority;
+					activeFrontier = i;
+				}
+			}
+		}
+		if (activeFrontier < 0) {
+			termination = "exhausted";
+			break;
+		}
+		const queue = queues[activeFrontier];
+		if (queue === void 0) break;
+		const entry = queue.pop();
+		if (entry === void 0) break;
+		const { nodeId, predecessor } = entry.item;
+		const frontierVisited = visitedByFrontier[activeFrontier];
+		if (frontierVisited === void 0 || frontierVisited.has(nodeId)) continue;
+		frontierVisited.set(nodeId, activeFrontier);
+		combinedVisited.set(nodeId, activeFrontier);
+		if (predecessor !== null) {
+			const predMap = predecessors[activeFrontier];
+			if (predMap !== void 0) predMap.set(nodeId, predecessor);
+		}
+		allVisited.add(nodeId);
+		if (debug) console.log(`[BASE] Iteration ${String(iterations)}: Frontier ${String(activeFrontier)} visiting ${nodeId}`);
+		for (let otherFrontier = 0; otherFrontier < numFrontiers; otherFrontier++) {
+			if (otherFrontier === activeFrontier) continue;
+			const otherVisited = visitedByFrontier[otherFrontier];
+			if (otherVisited === void 0) continue;
+			if (otherVisited.has(nodeId)) {
+				const path = reconstructPath$1(nodeId, activeFrontier, otherFrontier, predecessors, seeds);
+				if (path !== null) {
+					discoveredPaths.push(path);
+					if (debug) console.log(`[BASE] Path found: ${path.nodes.join(" -> ")}`);
+				}
+			}
+		}
+		const neighbours = yield* require_ops.opNeighbours(nodeId);
+		for (const neighbour of neighbours) {
+			edgesTraversed++;
+			const [s, t] = nodeId < neighbour ? [nodeId, neighbour] : [neighbour, nodeId];
+			let targets = sampledEdgeMap.get(s);
+			if (targets === void 0) {
+				targets = /* @__PURE__ */ new Set();
+				sampledEdgeMap.set(s, targets);
+			}
+			targets.add(t);
+			const fv = visitedByFrontier[activeFrontier];
+			if (fv === void 0 || fv.has(neighbour)) continue;
+			const neighbourDegree = yield* require_ops.opDegree(neighbour);
+			const neighbourPriority = priority(neighbour, buildPriorityContext(neighbour, activeFrontier, combinedVisited, allVisited, discoveredPaths, iterations + 1, neighbourDegree, graphRef));
+			queue.push({
+				nodeId: neighbour,
+				frontierIndex: activeFrontier,
+				predecessor: nodeId
+			}, neighbourPriority);
+		}
+		iterations++;
+	}
+	const endTime = performance.now();
+	const visitedPerFrontier = visitedByFrontier.map((m) => new Set(m.keys()));
+	const edgeTuples = /* @__PURE__ */ new Set();
+	for (const [source, targets] of sampledEdgeMap) for (const target of targets) edgeTuples.add([source, target]);
+	return {
+		paths: discoveredPaths,
+		sampledNodes: allVisited,
+		sampledEdges: edgeTuples,
+		visitedPerFrontier,
+		stats: {
+			iterations,
+			nodesVisited: allVisited.size,
+			edgesTraversed,
+			pathsFound: discoveredPaths.length,
+			durationMs: endTime - startTime,
+			algorithm: "base",
+			termination
+		}
+	};
+}
+/**
+* Create a sentinel ReadableGraph that throws if any member is accessed.
+*
+* Used in async mode when no graphRef is provided. Gives a clear error
+* message rather than silently returning incorrect results if a priority
+* function attempts to access `context.graph` before Phase 4b introduces
+* a real async proxy.
+*/
+function makeNoGraphSentinel() {
+	const msg = "Priority function accessed context.graph in async mode without a graph proxy. Pass a graphRef or use a priority function that does not access context.graph.";
+	const fail = () => {
+		throw new Error(msg);
+	};
+	return {
+		get directed() {
+			return fail();
+		},
+		get nodeCount() {
+			return fail();
+		},
+		get edgeCount() {
+			return fail();
+		},
+		hasNode: fail,
+		getNode: fail,
+		nodeIds: fail,
+		neighbours: fail,
+		degree: fail,
+		getEdge: fail,
+		edges: fail
+	};
+}
+/**
+* Build a PriorityContext for a node using a pre-fetched degree.
+*
+* When `graphRef` is provided (sync mode), it is used as `context.graph` so
+* priority functions can access the graph directly. When it is absent (async
+* mode), a Proxy is used in its place that throws a clear error if any
+* property is accessed — this prevents silent failures until Phase 4b
+* introduces a real async proxy graph.
+*/
+function buildPriorityContext(_nodeId, frontierIndex, combinedVisited, allVisited, discoveredPaths, iteration, degree, graphRef) {
+	return {
+		graph: graphRef ?? makeNoGraphSentinel(),
+		degree,
+		frontierIndex,
+		visitedByFrontier: combinedVisited,
+		allVisited,
+		discoveredPaths,
+		iteration
+	};
+}
+//#endregion
+//#region src/expansion/base.ts
+/**
+* Run BASE expansion synchronously.
+*
+* Delegates to baseCore + runSync. Behaviour is identical to the previous
+* direct implementation — all existing callers are unaffected.
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration
+* @returns Expansion result with discovered paths
+*/
+function base(graph, seeds, config) {
+	return require_ops.runSync(baseCore({
+		directed: graph.directed,
+		nodeCount: graph.nodeCount,
+		edgeCount: graph.edgeCount
+	}, seeds, config, graph), graph);
+}
+/**
+* Run BASE expansion asynchronously.
+*
+* Delegates to baseCore + runAsync. Supports:
+* - Cancellation via AbortSignal (config.signal)
+* - Progress callbacks (config.onProgress)
+* - Custom cooperative yield strategies (config.yieldStrategy)
+*
+* Note: priority functions that access `context.graph` are not supported in
+* async mode without a graph proxy (Phase 4b). The default degree-based
+* priority (DOME) does not access context.graph and works correctly.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function baseAsync(graph, seeds, config) {
+	const [nodeCount, edgeCount] = await Promise.all([graph.nodeCount, graph.edgeCount]);
+	const gen = baseCore({
+		directed: graph.directed,
+		nodeCount,
+		edgeCount
+	}, seeds, config);
+	const runnerOptions = {};
+	if (config?.signal !== void 0) runnerOptions.signal = config.signal;
+	if (config?.onProgress !== void 0) runnerOptions.onProgress = config.onProgress;
+	if (config?.yieldStrategy !== void 0) runnerOptions.yieldStrategy = config.yieldStrategy;
+	return require_ops.runAsync(gen, graph, runnerOptions);
+}
+//#endregion
+//#region src/expansion/dome.ts
+/**
+* DOME priority: lower degree is expanded first.
+*/
+function domePriority(_nodeId, context) {
+	return context.degree;
+}
+/**
+* DOME high-degree priority: negate degree to prioritise high-degree nodes.
+*/
+function domeHighDegreePriority(_nodeId, context) {
+	return -context.degree;
+}
+/**
+* Run DOME expansion (degree-ordered).
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration
+* @returns Expansion result with discovered paths
+*/
+function dome(graph, seeds, config) {
+	return base(graph, seeds, {
+		...config,
+		priority: domePriority
+	});
+}
+/**
+* Run DOME expansion asynchronously (degree-ordered).
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function domeAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: domePriority
+	});
+}
+/**
+* DOME with reverse priority (high degree first).
+*/
+function domeHighDegree(graph, seeds, config) {
+	return base(graph, seeds, {
+		...config,
+		priority: domeHighDegreePriority
+	});
+}
+/**
+* Run DOME high-degree expansion asynchronously (high degree first).
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function domeHighDegreeAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: domeHighDegreePriority
+	});
+}
+//#endregion
+//#region src/expansion/hae.ts
+var EPSILON = 1e-10;
+/**
+* Default type mapper - uses node.type property.
+*/
+function defaultTypeMapper$1(node) {
+	return node.type ?? "default";
+}
+/**
+* Create a priority function using the given type mapper.
+*/
+function createHAEPriority(typeMapper) {
+	return function haePriority(nodeId, context) {
+		const graph = context.graph;
+		const neighbours = graph.neighbours(nodeId);
+		const neighbourTypes = [];
+		for (const neighbour of neighbours) {
+			const node = graph.getNode(neighbour);
+			if (node !== void 0) neighbourTypes.push(typeMapper(node));
+		}
+		return 1 / (require_utils.localTypeEntropy(neighbourTypes) + EPSILON) * Math.log(context.degree + 1);
+	};
+}
+/**
+* Run HAE expansion (Heterogeneity-Aware Expansion).
+*
+* Discovers paths by prioritising nodes with diverse neighbour types,
+* using a custom type mapper for flexible type extraction.
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - HAE configuration with optional typeMapper
+* @returns Expansion result with discovered paths
+*/
+function hae(graph, seeds, config) {
+	const typeMapper = config?.typeMapper ?? defaultTypeMapper$1;
+	return base(graph, seeds, {
+		...config,
+		priority: createHAEPriority(typeMapper)
+	});
+}
+/**
+* Run HAE expansion asynchronously.
+*
+* Note: the HAE priority function accesses `context.graph` to retrieve
+* neighbour types. Full async equivalence requires PriorityContext
+* refactoring (Phase 4b deferred). This export establishes the async API
+* surface; use with a `wrapAsync`-wrapped sync graph for testing.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - HAE configuration combined with async runner options
+* @returns Promise resolving to the expansion result
+*/
+async function haeAsync(graph, seeds, config) {
+	const typeMapper = config?.typeMapper ?? defaultTypeMapper$1;
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: createHAEPriority(typeMapper)
+	});
+}
+//#endregion
+//#region src/expansion/edge.ts
+/** Default type mapper: reads `node.type`, falling back to "default". */
+var defaultTypeMapper = (n) => typeof n.type === "string" ? n.type : "default";
+/**
+* Run EDGE expansion (Entropy-Driven Graph Expansion).
+*
+* Discovers paths by prioritising nodes with diverse neighbour types,
+* deferring nodes with homogeneous neighbourhoods.
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration
+* @returns Expansion result with discovered paths
+*/
+function edge(graph, seeds, config) {
+	return hae(graph, seeds, {
+		...config,
+		typeMapper: defaultTypeMapper
+	});
+}
+/**
+* Run EDGE expansion asynchronously.
+*
+* Delegates to `haeAsync` with the default `node.type` mapper.
+*
+* Note: the HAE priority function accesses `context.graph` to retrieve
+* neighbour types. Full async equivalence requires PriorityContext
+* refactoring (Phase 4b deferred). This export establishes the async API
+* surface; use with a `wrapAsync`-wrapped sync graph for testing.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function edgeAsync(graph, seeds, config) {
+	return haeAsync(graph, seeds, {
+		...config,
+		typeMapper: defaultTypeMapper
+	});
+}
+//#endregion
+//#region src/expansion/pipe.ts
+/**
+* Priority function using path potential.
+* Lower values = higher priority (expanded first).
+*
+* Path potential measures how many of a node's neighbours have been
+* visited by OTHER frontiers (not the current frontier).
+*/
+function pipePriority(nodeId, context) {
+	const neighbours = context.graph.neighbours(nodeId);
+	let pathPotential = 0;
+	for (const neighbour of neighbours) {
+		const visitedBy = context.visitedByFrontier.get(neighbour);
+		if (visitedBy !== void 0 && visitedBy !== context.frontierIndex) pathPotential++;
+	}
+	return context.degree / (1 + pathPotential);
+}
+/**
+* Run PIPE expansion (Path-Potential Informed Priority Expansion).
+*
+* Discovers paths by prioritising nodes that bridge multiple frontiers,
+* identifying connecting points between seed regions.
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration
+* @returns Expansion result with discovered paths
+*/
+function pipe(graph, seeds, config) {
+	return base(graph, seeds, {
+		...config,
+		priority: pipePriority
+	});
+}
+/**
+* Run PIPE expansion asynchronously.
+*
+* Note: the PIPE priority function accesses `context.graph` to retrieve
+* neighbour lists. Full async equivalence requires PriorityContext
+* refactoring (Phase 4b deferred). This export establishes the async API
+* surface; use with a `wrapAsync`-wrapped sync graph for testing.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function pipeAsync(graph, seeds, config) {
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: pipePriority
+	});
+}
+//#endregion
+//#region src/expansion/priority-helpers.ts
+/**
+* Compute the average mutual information between a node and all visited
+* nodes in the same frontier.
+*
+* Returns a value in [0, 1] — higher means the node is more similar
+* (on average) to already-visited same-frontier nodes.
+*
+* @param graph - Source graph
+* @param nodeId - Node being prioritised
+* @param context - Current priority context
+* @param mi - MI function to use for pairwise scoring
+* @returns Average MI score, or 0 if no same-frontier visited nodes exist
+*/
+function avgFrontierMI(graph, nodeId, context, mi) {
+	const { frontierIndex, visitedByFrontier } = context;
+	let total = 0;
+	let count = 0;
+	for (const [visitedId, idx] of visitedByFrontier) if (idx === frontierIndex && visitedId !== nodeId) {
+		total += mi(graph, visitedId, nodeId);
+		count++;
+	}
+	return count > 0 ? total / count : 0;
+}
+/**
+* Count the number of a node's neighbours that have been visited by
+* frontiers other than the node's own frontier.
+*
+* A higher count indicates this node is likely to bridge two frontiers,
+* making it a strong candidate for path completion.
+*
+* @param graph - Source graph
+* @param nodeId - Node being evaluated
+* @param context - Current priority context
+* @returns Number of neighbours visited by other frontiers
+*/
+function countCrossFrontierNeighbours(graph, nodeId, context) {
+	const { frontierIndex, visitedByFrontier } = context;
+	const nodeNeighbours = new Set(graph.neighbours(nodeId));
+	let count = 0;
+	for (const [visitedId, idx] of visitedByFrontier) if (idx !== frontierIndex && nodeNeighbours.has(visitedId)) count++;
+	return count;
+}
+/**
+* Incrementally update salience counts for paths discovered since the
+* last update.
+*
+* Iterates only over paths from `fromIndex` onwards, avoiding redundant
+* re-processing of already-counted paths.
+*
+* @param salienceCounts - Mutable map of node ID to salience count (mutated in place)
+* @param paths - Full list of discovered paths
+* @param fromIndex - Index to start counting from (exclusive of earlier paths)
+* @returns The new `fromIndex` value (i.e. `paths.length` after update)
+*/
+function updateSalienceCounts(salienceCounts, paths, fromIndex) {
+	for (let i = fromIndex; i < paths.length; i++) {
+		const path = paths[i];
+		if (path !== void 0) for (const node of path.nodes) salienceCounts.set(node, (salienceCounts.get(node) ?? 0) + 1);
+	}
+	return paths.length;
+}
+//#endregion
+//#region src/expansion/sage.ts
+/**
+* Run SAGE expansion algorithm.
+*
+* Salience-aware multi-frontier expansion with two phases:
+* - Phase 1: Degree-based priority (early exploration)
+* - Phase 2: Salience feedback (path-aware frontier steering)
+*
+* @param graph - Source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion configuration
+* @returns Expansion result with discovered paths
+*/
+function sage(graph, seeds, config) {
+	const salienceCounts = /* @__PURE__ */ new Map();
+	let inPhase2 = false;
+	let lastPathCount = 0;
+	/**
+	* SAGE priority function with phase transition logic.
+	*/
+	function sagePriority(nodeId, context) {
+		const pathCount = context.discoveredPaths.length;
+		if (pathCount > 0 && !inPhase2) inPhase2 = true;
+		if (pathCount > lastPathCount) lastPathCount = updateSalienceCounts(salienceCounts, context.discoveredPaths, lastPathCount);
+		if (!inPhase2) return Math.log(context.degree + 1);
+		return -((salienceCounts.get(nodeId) ?? 0) * 1e3 - context.degree);
+	}
+	return base(graph, seeds, {
+		...config,
+		priority: sagePriority
+	});
+}
+/**
+* Run SAGE expansion asynchronously.
+*
+* Creates fresh closure state (salienceCounts, phase tracking) for this
+* invocation. The SAGE priority function does not access `context.graph`
+* directly, so it is safe to use in async mode via `baseAsync`.
+*
+* @param graph - Async source graph
+* @param seeds - Seed nodes for expansion
+* @param config - Expansion and async runner configuration
+* @returns Promise resolving to the expansion result
+*/
+async function sageAsync(graph, seeds, config) {
+	const salienceCounts = /* @__PURE__ */ new Map();
+	let inPhase2 = false;
+	let lastPathCount = 0;
+	function sagePriority(nodeId, context) {
+		const pathCount = context.discoveredPaths.length;
+		if (pathCount > 0 && !inPhase2) inPhase2 = true;
+		if (pathCount > lastPathCount) lastPathCount = updateSalienceCounts(salienceCounts, context.discoveredPaths, lastPathCount);
+		if (!inPhase2) return Math.log(context.degree + 1);
+		return -((salienceCounts.get(nodeId) ?? 0) * 1e3 - context.degree);
+	}
+	return baseAsync(graph, seeds, {
+		...config,
+		priority: sagePriority
+	});
+}
+//#endregion
+//#region src/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 = require_jaccard.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 += require_jaccard.jaccard(context.graph, nodeId, path.fromSeed.id);
+			totalMI += require_jaccard.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 = require_jaccard.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 = require_jaccard.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 = require_jaccard.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 = require_jaccard.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 = require_jaccard.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 = require_jaccard.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(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(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
+Object.defineProperty(exports, "base", {
+	enumerable: true,
+	get: function() {
+		return base;
+	}
+});
+Object.defineProperty(exports, "baseAsync", {
+	enumerable: true,
+	get: function() {
+		return baseAsync;
+	}
+});
+Object.defineProperty(exports, "dfsPriority", {
+	enumerable: true,
+	get: function() {
+		return dfsPriority;
+	}
+});
+Object.defineProperty(exports, "dfsPriorityAsync", {
+	enumerable: true,
+	get: function() {
+		return dfsPriorityAsync;
+	}
+});
+Object.defineProperty(exports, "dfsPriorityFn", {
+	enumerable: true,
+	get: function() {
+		return dfsPriorityFn;
+	}
+});
+Object.defineProperty(exports, "dome", {
+	enumerable: true,
+	get: function() {
+		return dome;
+	}
+});
+Object.defineProperty(exports, "domeAsync", {
+	enumerable: true,
+	get: function() {
+		return domeAsync;
+	}
+});
+Object.defineProperty(exports, "domeHighDegree", {
+	enumerable: true,
+	get: function() {
+		return domeHighDegree;
+	}
+});
+Object.defineProperty(exports, "domeHighDegreeAsync", {
+	enumerable: true,
+	get: function() {
+		return domeHighDegreeAsync;
+	}
+});
+Object.defineProperty(exports, "edge", {
+	enumerable: true,
+	get: function() {
+		return edge;
+	}
+});
+Object.defineProperty(exports, "edgeAsync", {
+	enumerable: true,
+	get: function() {
+		return edgeAsync;
+	}
+});
+Object.defineProperty(exports, "flux", {
+	enumerable: true,
+	get: function() {
+		return flux;
+	}
+});
+Object.defineProperty(exports, "fluxAsync", {
+	enumerable: true,
+	get: function() {
+		return fluxAsync;
+	}
+});
+Object.defineProperty(exports, "frontierBalanced", {
+	enumerable: true,
+	get: function() {
+		return frontierBalanced;
+	}
+});
+Object.defineProperty(exports, "frontierBalancedAsync", {
+	enumerable: true,
+	get: function() {
+		return frontierBalancedAsync;
+	}
+});
+Object.defineProperty(exports, "fuse", {
+	enumerable: true,
+	get: function() {
+		return fuse;
+	}
+});
+Object.defineProperty(exports, "fuseAsync", {
+	enumerable: true,
+	get: function() {
+		return fuseAsync;
+	}
+});
+Object.defineProperty(exports, "hae", {
+	enumerable: true,
+	get: function() {
+		return hae;
+	}
+});
+Object.defineProperty(exports, "haeAsync", {
+	enumerable: true,
+	get: function() {
+		return haeAsync;
+	}
+});
+Object.defineProperty(exports, "kHop", {
+	enumerable: true,
+	get: function() {
+		return kHop;
+	}
+});
+Object.defineProperty(exports, "lace", {
+	enumerable: true,
+	get: function() {
+		return lace;
+	}
+});
+Object.defineProperty(exports, "laceAsync", {
+	enumerable: true,
+	get: function() {
+		return laceAsync;
+	}
+});
+Object.defineProperty(exports, "maze", {
+	enumerable: true,
+	get: function() {
+		return maze;
+	}
+});
+Object.defineProperty(exports, "mazeAsync", {
+	enumerable: true,
+	get: function() {
+		return mazeAsync;
+	}
+});
+Object.defineProperty(exports, "pipe", {
+	enumerable: true,
+	get: function() {
+		return pipe;
+	}
+});
+Object.defineProperty(exports, "pipeAsync", {
+	enumerable: true,
+	get: function() {
+		return pipeAsync;
+	}
+});
+Object.defineProperty(exports, "randomPriority", {
+	enumerable: true,
+	get: function() {
+		return randomPriority;
+	}
+});
+Object.defineProperty(exports, "randomPriorityAsync", {
+	enumerable: true,
+	get: function() {
+		return randomPriorityAsync;
+	}
+});
+Object.defineProperty(exports, "randomWalk", {
+	enumerable: true,
+	get: function() {
+		return randomWalk;
+	}
+});
+Object.defineProperty(exports, "reach", {
+	enumerable: true,
+	get: function() {
+		return reach;
+	}
+});
+Object.defineProperty(exports, "reachAsync", {
+	enumerable: true,
+	get: function() {
+		return reachAsync;
+	}
+});
+Object.defineProperty(exports, "sage", {
+	enumerable: true,
+	get: function() {
+		return sage;
+	}
+});
+Object.defineProperty(exports, "sageAsync", {
+	enumerable: true,
+	get: function() {
+		return sageAsync;
+	}
+});
+Object.defineProperty(exports, "sift", {
+	enumerable: true,
+	get: function() {
+		return sift;
+	}
+});
+Object.defineProperty(exports, "siftAsync", {
+	enumerable: true,
+	get: function() {
+		return siftAsync;
+	}
+});
+Object.defineProperty(exports, "standardBfs", {
+	enumerable: true,
+	get: function() {
+		return standardBfs;
+	}
+});
+Object.defineProperty(exports, "standardBfsAsync", {
+	enumerable: true,
+	get: function() {
+		return standardBfsAsync;
+	}
+});
+Object.defineProperty(exports, "tide", {
+	enumerable: true,
+	get: function() {
+		return tide;
+	}
+});
+Object.defineProperty(exports, "tideAsync", {
+	enumerable: true,
+	get: function() {
+		return tideAsync;
+	}
+});
+Object.defineProperty(exports, "warp", {
+	enumerable: true,
+	get: function() {
+		return warp;
+	}
+});
+Object.defineProperty(exports, "warpAsync", {
+	enumerable: true,
+	get: function() {
+		return warpAsync;
+	}
+});
+
+//# sourceMappingURL=expansion-FkmEYlrQ.cjs.map