graphwise 1.0.0 → 1.1.0

package/dist/index/index.js

@@ -0,0 +1,1356 @@
+import { t as AdjacencyMapGraph } from "../graph-DLWiziLB.js";
+import { i as bfsWithPath, n as dfsWithPath, r as bfs, t as dfs } from "../traversal-CQCjUwUJ.js";
+import { t as PriorityQueue } from "../structures-BPfhfqNP.js";
+import { n as normaliseFeatures, t as miniBatchKMeans } from "../kmeans-DgbsOznU.js";
+import { n as grasp, t as stratified } from "../seeds-UNZxqm_U.js";
+import { a as approximateClusteringCoefficient, i as shannonEntropy, n as localTypeEntropy, o as batchClusteringCoefficients, r as normalisedEntropy, s as localClusteringCoefficient, t as entropyFromCounts } from "../utils-Q_akvlMn.js";
+import { i as detectWebGPU, n as graphToCSR, r as GPUContext, t as csrToGPUBuffers } from "../gpu-BveuXugy.js";
+//#region src/expansion/base.ts
+/**
+* Default priority function - degree-ordered (DOME).
+*/
+function degreePriority(_nodeId, context) {
+	return context.degree;
+}
+/**
+* Run BASE expansion algorithm.
+*
+* @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) {
+	const startTime = performance.now();
+	const { maxNodes = 0, maxIterations = 0, maxPaths = 0, priority = degreePriority, debug = false } = config ?? {};
+	if (seeds.length === 0) return emptyResult("base", startTime);
+	const numFrontiers = seeds.length;
+	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);
+		const seedPriority = priority(seedNode, createPriorityContext(graph, seedNode, i, visitedByFrontier, [], 0));
+		queues[i]?.push({
+			nodeId: seedNode,
+			frontierIndex: i,
+			predecessor: null
+		}, seedPriority);
+	}
+	const allVisited = /* @__PURE__ */ new Set();
+	const sampledEdges = /* @__PURE__ */ new Set();
+	const discoveredPaths = [];
+	let iterations = 0;
+	let edgesTraversed = 0;
+	let termination = "exhausted";
+	const continueExpansion = () => {
+		if (maxIterations > 0 && iterations >= maxIterations) {
+			termination = "limit";
+			return false;
+		}
+		if (maxNodes > 0 && allVisited.size >= maxNodes) {
+			termination = "limit";
+			return false;
+		}
+		if (maxPaths > 0 && discoveredPaths.length >= maxPaths) {
+			termination = "limit";
+			return false;
+		}
+		return true;
+	};
+	while (continueExpansion()) {
+		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);
+		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(nodeId, activeFrontier, otherFrontier, predecessors, seeds);
+				if (path !== null) {
+					discoveredPaths.push(path);
+					if (debug) console.log(`[BASE] Path found: ${path.nodes.join(" -> ")}`);
+				}
+			}
+		}
+		const neighbours = graph.neighbours(nodeId);
+		for (const neighbour of neighbours) {
+			edgesTraversed++;
+			const edgeKey = nodeId < neighbour ? `${nodeId}::${neighbour}` : `${neighbour}::${nodeId}`;
+			sampledEdges.add(edgeKey);
+			const frontierVisited = visitedByFrontier[activeFrontier];
+			if (frontierVisited === void 0 || frontierVisited.has(neighbour)) continue;
+			const neighbourPriority = priority(neighbour, createPriorityContext(graph, neighbour, activeFrontier, visitedByFrontier, discoveredPaths, iterations + 1));
+			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 edgeKey of sampledEdges) {
+		const parts = edgeKey.split("::");
+		if (parts.length === 2) {
+			const source = parts[0];
+			const target = parts[1];
+			if (source !== void 0 && target !== void 0) 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 priority context for a node.
+*/
+function createPriorityContext(graph, nodeId, frontierIndex, visitedByFrontier, discoveredPaths, iteration) {
+	const combinedVisited = /* @__PURE__ */ new Map();
+	for (const frontierMap of visitedByFrontier) for (const [id, idx] of frontierMap) combinedVisited.set(id, idx);
+	const allVisited = new Set(combinedVisited.keys());
+	return {
+		graph,
+		degree: graph.degree(nodeId),
+		frontierIndex,
+		visitedByFrontier: combinedVisited,
+		allVisited,
+		discoveredPaths,
+		iteration
+	};
+}
+/**
+* Reconstruct path from collision point.
+*/
+function reconstructPath(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 result for early termination.
+*/
+function emptyResult(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/dome.ts
+/**
+* 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) {
+	const domePriority = (nodeId, context) => {
+		return graph.degree(nodeId);
+	};
+	return base(graph, seeds, {
+		...config,
+		priority: domePriority
+	});
+}
+//#endregion
+//#region src/expansion/edge.ts
+/**
+* EDGE priority function.
+*
+* Priority = degree(source) + degree(target)
+* Lower values = higher priority (explored first)
+*/
+function edgePriority(nodeId, context) {
+	const graph = context.graph;
+	let totalDegree = context.degree;
+	for (const neighbour of graph.neighbours(nodeId)) totalDegree += graph.degree(neighbour);
+	return totalDegree;
+}
+/**
+* Run EDGE 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 edge(graph, seeds, config) {
+	return base(graph, seeds, {
+		...config,
+		priority: edgePriority
+	});
+}
+//#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 sourceNeighbours = new Set(graph.neighbours(source));
+	const targetNeighbours = new Set(graph.neighbours(target));
+	sourceNeighbours.delete(target);
+	targetNeighbours.delete(source);
+	let intersectionSize = 0;
+	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) intersectionSize++;
+	const unionSize = sourceNeighbours.size + targetNeighbours.size - intersectionSize;
+	if (unionSize === 0) return 0;
+	const score = intersectionSize / unionSize;
+	return Math.max(epsilon, score);
+}
+//#endregion
+//#region src/expansion/hae.ts
+/**
+* HAE priority function.
+*
+* Priority = 1 - MI(source, neighbour)
+* Higher MI = lower priority value = explored first
+*/
+function haePriority(nodeId, context, mi) {
+	const graph = context.graph;
+	const frontierIndex = context.frontierIndex;
+	let maxMi = 0;
+	let totalMi = 0;
+	let count = 0;
+	for (const [visitedId, idx] of context.visitedByFrontier) if (idx === frontierIndex && visitedId !== nodeId) {
+		const edgeMi = mi(graph, visitedId, nodeId);
+		totalMi += edgeMi;
+		count++;
+		if (edgeMi > maxMi) maxMi = edgeMi;
+	}
+	return 1 - (count > 0 ? totalMi / count : 0);
+}
+/**
+* Run HAE 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 hae(graph, seeds, config) {
+	const { mi = jaccard, ...restConfig } = config ?? {};
+	const priority = (nodeId, context) => haePriority(nodeId, context, mi);
+	return base(graph, seeds, {
+		...restConfig,
+		priority
+	});
+}
+//#endregion
+//#region src/expansion/pipe.ts
+/**
+* PIPE priority function.
+*
+* Priority = 1 / (1 + bridge_score)
+* Bridge score = neighbourhood overlap with other frontiers
+* Higher bridge score = more likely to be on paths = explored first
+*/
+function pipePriority(nodeId, context) {
+	const graph = context.graph;
+	const currentFrontier = context.frontierIndex;
+	const nodeNeighbours = new Set(graph.neighbours(nodeId));
+	let bridgeScore = 0;
+	for (const [visitedId, frontierIdx] of context.visitedByFrontier) if (frontierIdx !== currentFrontier && nodeNeighbours.has(visitedId)) bridgeScore++;
+	for (const path of context.discoveredPaths) if (path.nodes.includes(nodeId)) bridgeScore += 2;
+	return 1 / (1 + bridgeScore);
+}
+/**
+* Run PIPE 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 pipe(graph, seeds, config) {
+	return base(graph, seeds, {
+		...config,
+		priority: pipePriority
+	});
+}
+//#endregion
+//#region src/expansion/sage.ts
+/**
+* SAGE priority function.
+*
+* Combines degree with salience:
+* Priority = (1 - w) * degree + w * (1 - avg_salience)
+* Lower values = higher priority
+*/
+function sagePriority(nodeId, context, mi, salienceWeight) {
+	const graph = context.graph;
+	const degree = context.degree;
+	const frontierIndex = context.frontierIndex;
+	let totalSalience = 0;
+	let count = 0;
+	for (const [visitedId, idx] of context.visitedByFrontier) if (idx === frontierIndex && visitedId !== nodeId) {
+		totalSalience += mi(graph, visitedId, nodeId);
+		count++;
+	}
+	const avgSalience = count > 0 ? totalSalience / count : 0;
+	return (1 - salienceWeight) * degree + salienceWeight * (1 - avgSalience);
+}
+/**
+* Run SAGE 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 sage(graph, seeds, config) {
+	const { mi = jaccard, salienceWeight = .5, ...restConfig } = config ?? {};
+	const priority = (nodeId, context) => sagePriority(nodeId, context, mi, salienceWeight);
+	return base(graph, seeds, {
+		...restConfig,
+		priority
+	});
+}
+//#endregion
+//#region src/expansion/reach.ts
+/**
+* REACH priority function (phase 2).
+*
+* Uses learned MI threshold to prioritise high-MI edges.
+*/
+function reachPriority(nodeId, context, mi, miThreshold) {
+	const graph = context.graph;
+	const frontierIndex = context.frontierIndex;
+	let totalMi = 0;
+	let count = 0;
+	for (const [visitedId, idx] of context.visitedByFrontier) if (idx === frontierIndex && visitedId !== nodeId) {
+		totalMi += mi(graph, visitedId, nodeId);
+		count++;
+	}
+	const avgMi = count > 0 ? totalMi / count : 0;
+	if (avgMi >= miThreshold) return 1 - avgMi;
+	else return context.degree + 100;
+}
+/**
+* Run REACH 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 reach(graph, seeds, config) {
+	const { mi = jaccard, miThreshold = .25, ...restConfig } = config ?? {};
+	const priority = (nodeId, context) => reachPriority(nodeId, context, mi, miThreshold);
+	return base(graph, seeds, {
+		...restConfig,
+		priority
+	});
+}
+//#endregion
+//#region src/expansion/maze.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;
+}
+/**
+* Compute bridge score (how many other frontiers visit neighbours).
+*/
+function bridgeScore(nodeId, context) {
+	const currentFrontier = context.frontierIndex;
+	const nodeNeighbours = new Set(context.graph.neighbours(nodeId));
+	let score = 0;
+	for (const [visitedId, idx] of context.visitedByFrontier) if (idx !== currentFrontier && nodeNeighbours.has(visitedId)) score++;
+	return score;
+}
+/**
+* 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 mazePriority(nodeId, context, densityThreshold, bridgeThreshold) {
+	const graph = context.graph;
+	const degree = context.degree;
+	const density = localDensity(graph, nodeId);
+	const bridge = bridgeScore(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 -degree;
+	else return degree;
+}
+/**
+* Run MAZE 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 maze(graph, seeds, config) {
+	const { densityThreshold = .5, bridgeThreshold = .3, ...restConfig } = config ?? {};
+	const priority = (nodeId, context) => mazePriority(nodeId, context, densityThreshold, bridgeThreshold);
+	return base(graph, seeds, {
+		...restConfig,
+		priority
+	});
+}
+//#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
+		}
+	};
+}
+/**
+* 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 sourceNeighbours = new Set(graph.neighbours(source));
+	const targetNeighbours = new Set(graph.neighbours(target));
+	sourceNeighbours.delete(target);
+	targetNeighbours.delete(source);
+	let score = 0;
+	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) {
+		const degree = graph.degree(neighbour);
+		if (degree > 1) score += 1 / Math.log(degree);
+	}
+	if (normalise) {
+		const commonCount = sourceNeighbours.size < targetNeighbours.size ? sourceNeighbours.size : targetNeighbours.size;
+		if (commonCount === 0) return 0;
+		const maxScore = commonCount / Math.log(2);
+		score = score / maxScore;
+	}
+	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 sourceNeighbours = new Set(graph.neighbours(source));
+	const targetNeighbours = new Set(graph.neighbours(target));
+	sourceNeighbours.delete(target);
+	targetNeighbours.delete(source);
+	const sourceDegree = sourceNeighbours.size;
+	const targetDegree = targetNeighbours.size;
+	let intersectionSize = 0;
+	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) intersectionSize++;
+	const unionSize = sourceDegree + targetDegree - intersectionSize;
+	const jaccard = unionSize > 0 ? intersectionSize / unionSize : 0;
+	const minDegree = Math.min(sourceDegree, targetDegree);
+	const maxDegree = Math.max(sourceDegree, targetDegree);
+	const degreeRatio = maxDegree > 0 ? minDegree / maxDegree : 0;
+	if (jaccard + degreeRatio === 0) return epsilon;
+	const score = 2 * jaccard * degreeRatio / (jaccard + degreeRatio);
+	return Math.max(epsilon, Math.min(1, 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 sourceNeighbours = new Set(graph.neighbours(source));
+	const targetNeighbours = new Set(graph.neighbours(target));
+	sourceNeighbours.delete(target);
+	targetNeighbours.delete(source);
+	let weightedIntersection = 0;
+	let commonCount = 0;
+	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) {
+		commonCount++;
+		const degree = graph.degree(neighbour);
+		if (degree > 1) weightedIntersection += 1 / Math.log(degree);
+	}
+	if (commonCount === 0) return epsilon;
+	const sourceDegree = sourceNeighbours.size;
+	const targetDegree = targetNeighbours.size;
+	const maxScore = Math.min(sourceDegree, targetDegree) / Math.log(2);
+	const score = weightedIntersection / maxScore;
+	return Math.max(epsilon, Math.min(1, 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 sourceNeighbours = new Set(graph.neighbours(source));
+	const targetNeighbours = new Set(graph.neighbours(target));
+	sourceNeighbours.delete(target);
+	targetNeighbours.delete(source);
+	const sourceDegree = sourceNeighbours.size;
+	const targetDegree = targetNeighbours.size;
+	let intersectionSize = 0;
+	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) intersectionSize++;
+	const unionSize = sourceDegree + targetDegree - intersectionSize;
+	const jaccard = unionSize > 0 ? intersectionSize / unionSize : 0;
+	const maxDegree = Math.max(sourceDegree, targetDegree);
+	const degreeDiff = Math.abs(sourceDegree - targetDegree);
+	const degreeSimilarity = maxDegree > 0 ? 1 - degreeDiff / maxDegree : 1;
+	const score = Math.sqrt(jaccard * degreeSimilarity);
+	return Math.max(epsilon, Math.min(1, 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 sourceNeighbours = new Set(graph.neighbours(source));
+	const targetNeighbours = new Set(graph.neighbours(target));
+	sourceNeighbours.delete(target);
+	targetNeighbours.delete(source);
+	const commonNeighbours = [];
+	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) commonNeighbours.push(neighbour);
+	if (commonNeighbours.length < 2) return epsilon;
+	let jointEdges = 0;
+	for (let i = 0; i < commonNeighbours.length; i++) for (let j = i + 1; j < commonNeighbours.length; j++) {
+		const ni = commonNeighbours[i];
+		const nj = commonNeighbours[j];
+		if (ni !== void 0 && nj !== void 0 && graph.getEdge(ni, nj) !== void 0) jointEdges++;
+	}
+	const maxJointEdges = commonNeighbours.length * (commonNeighbours.length - 1) / 2;
+	const jointDensity = maxJointEdges > 0 ? jointEdges / maxJointEdges : 0;
+	let commonEdges = 0;
+	for (const cn of commonNeighbours) {
+		if (graph.getEdge(source, cn) !== void 0) commonEdges++;
+		if (graph.getEdge(target, cn) !== void 0) commonEdges++;
+	}
+	const maxCommonEdges = commonNeighbours.length * 2;
+	const commonDensity = maxCommonEdges > 0 ? commonEdges / maxCommonEdges : 0;
+	const score = jointDensity * .7 + commonDensity * .3;
+	return Math.max(epsilon, Math.min(1, 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 sourceNeighbours = new Set(graph.neighbours(source));
+	const targetNeighbours = new Set(graph.neighbours(target));
+	sourceNeighbours.delete(target);
+	targetNeighbours.delete(source);
+	const sourceDegree = sourceNeighbours.size;
+	const targetDegree = targetNeighbours.size;
+	let intersectionSize = 0;
+	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) intersectionSize++;
+	const minDegree = Math.min(sourceDegree, targetDegree);
+	const overlap = minDegree > 0 ? intersectionSize / minDegree : 0;
+	const maxDegree = Math.max(sourceDegree, targetDegree);
+	const correlation = maxDegree > 0 ? 1 - Math.abs(sourceDegree - targetDegree) / maxDegree : 1;
+	const score = overlap * .6 + correlation * .4;
+	return Math.max(epsilon, Math.min(1, score));
+}
+//#endregion
+//#region src/ranking/mi/adaptive.ts
+/**
+* Compute unified adaptive MI between two connected nodes.
+*
+* Combines structural, degree, and overlap signals with
+* adaptive weighting based on graph density.
+*
+* @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 structural = jaccard(graph, source, target, { epsilon });
+	const degreeComponent = adamicAdar(graph, source, target, {
+		epsilon,
+		normalise: true
+	});
+	const sourceNeighbours = new Set(graph.neighbours(source));
+	const targetNeighbours = new Set(graph.neighbours(target));
+	sourceNeighbours.delete(target);
+	targetNeighbours.delete(source);
+	const sourceDegree = sourceNeighbours.size;
+	const targetDegree = targetNeighbours.size;
+	let overlap;
+	if (sourceDegree > 0 && targetDegree > 0) {
+		let commonCount = 0;
+		for (const n of sourceNeighbours) if (targetNeighbours.has(n)) commonCount++;
+		overlap = commonCount / Math.min(sourceDegree, targetDegree);
+	} 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/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"
+	};
+	const scored = paths.map((path) => ({
+		path,
+		score: 1 / path.nodes.length
+	}));
+	const maxScore = Math.max(...scored.map((s) => s.score));
+	return {
+		paths: scored.map(({ path, score }) => ({
+			...path,
+			score: includeScores ? score / maxScore : score / maxScore
+		})).sort((a, b) => b.score - a.score),
+		method: "shortest"
+	};
+}
+//#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;
+}
+//#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
+					]);
+				}
+			}
+		}
+	}
+	return {
+		counts,
+		instances
+	};
+}
+/**
+* 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
+						]);
+					}
+				}
+			}
+		}
+	}
+	return {
+		counts,
+		instances
+	};
+}
+/**
+* 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, PriorityQueue, adamicAdar, adaptive, approximateClusteringCoefficient, base, batchClusteringCoefficients, bfs, bfsWithPath, csrToGPUBuffers, detectWebGPU, dfs, dfsWithPath, dome, edge, entropyFromCounts, enumerateMotifs, enumerateMotifsWithInstances, etch, extractEgoNetwork, extractInducedSubgraph, extractKCore, extractKTruss, filterSubgraph, getMotifName, graphToCSR, grasp, hae, jaccard, localClusteringCoefficient, localTypeEntropy, maze, miniBatchKMeans, normaliseFeatures, normaliseFeatures as zScoreNormalise, normalisedEntropy, notch, parse, pipe, reach, sage, scale, shannonEntropy, shortest, skew, span, stratified };
+
+//# sourceMappingURL=index.js.map