graphwise 1.11.0 → 1.12.1

package/dist/seeds--fLhoBaG.cjs

@@ -0,0 +1,1762 @@
+const require_kmeans = require("./kmeans-CZ7tJFYw.cjs");
+//#region src/seeds/crest.ts
+/** Default configuration values */
+var DEFAULTS$9 = {
+	nPairs: 100,
+	rngSeed: 42,
+	diversityThreshold: .5,
+	sampleSize: 5e3
+};
+/**
+* Simple seeded pseudo-random number generator using mulberry32.
+*/
+function createRNG$6(seed) {
+	let state = seed >>> 0;
+	return () => {
+		state = state + 1831565813 >>> 0;
+		let t = Math.imul(state ^ state >>> 15, state | 1);
+		t = (t ^ t >>> 7) * (t | 1640531527);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/**
+* Compute community-bridge score for a pair of nodes.
+*
+* High score = pair connects different communities.
+* Ratio = exclusive_neighbours / shared_neighbours.
+*
+* Nodes with many shared neighbours are in the same dense community.
+* Nodes with few shared neighbours relative to exclusive ones span communities.
+*/
+function bridgeScore(aNbrs, bNbrs, bId, aId) {
+	const shared = [...aNbrs].filter((x) => bNbrs.has(x)).length;
+	const exclusive = [...aNbrs].filter((x) => !bNbrs.has(x) && x !== bId).length + [...bNbrs].filter((x) => !aNbrs.has(x) && x !== aId).length;
+	if (shared === 0) return 1 / Math.max(exclusive, 1);
+	return exclusive / shared;
+}
+/**
+* Compute Jaccard similarity between two sets.
+*/
+function jaccard$3(a, b) {
+	const intersection = [...a].filter((x) => b.has(x)).length;
+	const union = new Set([...a, ...b]).size;
+	return union === 0 ? 0 : intersection / union;
+}
+/**
+* CREST — Community-Revealing Edge Sampling Technique.
+*
+* Samples random node pairs and scores them by the ratio of exclusive
+* to shared neighbours. Pairs with high ratios connect different
+* communities (few shared neighbours, many exclusive). Greedy
+* selection with Jaccard diversity ensures selected pairs are
+* spread across different structural regions.
+*
+* @param graph - The graph to sample seeds from
+* @param options - Configuration options
+* @returns Selected seed pairs with bridge score metadata
+*/
+function crest(graph, options = {}) {
+	const config = {
+		...DEFAULTS$9,
+		...options
+	};
+	const rng = createRNG$6(config.rngSeed);
+	const allNodes = [...graph.nodeIds()];
+	if (allNodes.length < 2) return { pairs: [] };
+	const candidates = [];
+	const sampledPairs = /* @__PURE__ */ new Set();
+	const maxAttempts = config.sampleSize * 10;
+	let attempts = 0;
+	while (sampledPairs.size < config.sampleSize && attempts < maxAttempts) {
+		attempts++;
+		const a = allNodes[Math.floor(rng() * allNodes.length)];
+		const b = allNodes[Math.floor(rng() * allNodes.length)];
+		if (a === void 0 || b === void 0 || a === b) continue;
+		const pairKey = a < b ? `${a}|${b}` : `${b}|${a}`;
+		if (sampledPairs.has(pairKey)) continue;
+		sampledPairs.add(pairKey);
+		const score = bridgeScore(new Set(graph.neighbours(a)), new Set(graph.neighbours(b)), b, a);
+		candidates.push({
+			score,
+			a,
+			b
+		});
+	}
+	candidates.sort((x, y) => y.score - x.score);
+	const selected = [];
+	const selectedPairKeys = /* @__PURE__ */ new Set();
+	for (const { score, a, b } of candidates) {
+		if (selected.length >= config.nPairs) break;
+		const pairKey = a < b ? `${a}|${b}` : `${b}|${a}`;
+		if (selectedPairKeys.has(pairKey)) continue;
+		const aNbrs = new Set(graph.neighbours(a));
+		const bNbrs = new Set(graph.neighbours(b));
+		let isDiverse = true;
+		for (const prev of selected) if (jaccard$3(aNbrs, new Set(graph.neighbours(prev.source.id))) >= config.diversityThreshold) {
+			if (jaccard$3(bNbrs, new Set(graph.neighbours(prev.target.id))) >= config.diversityThreshold) {
+				isDiverse = false;
+				break;
+			}
+		}
+		if (!isDiverse) continue;
+		selectedPairKeys.add(pairKey);
+		selected.push({
+			source: { id: a },
+			target: { id: b },
+			bridgeScore: score
+		});
+	}
+	let fillAttempts = 0;
+	while (selected.length < config.nPairs && allNodes.length >= 2 && fillAttempts < config.nPairs * 20) {
+		fillAttempts++;
+		const i1 = Math.floor(rng() * allNodes.length);
+		const i2 = Math.floor(rng() * allNodes.length);
+		const a = allNodes[i1];
+		const b = allNodes[i2];
+		if (a === void 0 || b === void 0 || a === b) continue;
+		const pairKey = a < b ? `${a}|${b}` : `${b}|${a}`;
+		if (selectedPairKeys.has(pairKey)) continue;
+		selectedPairKeys.add(pairKey);
+		selected.push({
+			source: { id: a },
+			target: { id: b },
+			bridgeScore: 0
+		});
+	}
+	return { pairs: selected.slice(0, config.nPairs) };
+}
+//#endregion
+//#region src/seeds/crisp.ts
+/** Default configuration values */
+var DEFAULTS$8 = {
+	nPairs: 100,
+	rngSeed: 42,
+	minDistance: 2,
+	maxDistance: 4,
+	minCommonNeighbours: 2,
+	diversityThreshold: .5,
+	sampleSize: 5e3
+};
+/**
+* Simple seeded pseudo-random number generator using mulberry32.
+*/
+function createRNG$5(seed) {
+	let state = seed >>> 0;
+	return () => {
+		state = state + 1831565813 >>> 0;
+		let t = Math.imul(state ^ state >>> 15, state | 1);
+		t = (t ^ t >>> 7) * (t | 1640531527);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/**
+* Compute shortest-path distance between two nodes via BFS.
+* Returns -1 if no path exists.
+*/
+function bfsDistance(graph, source, target) {
+	if (source === target) return 0;
+	const visited = new Set([source]);
+	const queue = [{
+		node: source,
+		dist: 0
+	}];
+	while (queue.length > 0) {
+		const item = queue.shift();
+		if (!item) break;
+		const { node, dist } = item;
+		for (const neighbour of graph.neighbours(node)) {
+			if (neighbour === target) return dist + 1;
+			if (!visited.has(neighbour)) {
+				visited.add(neighbour);
+				queue.push({
+					node: neighbour,
+					dist: dist + 1
+				});
+			}
+		}
+	}
+	return -1;
+}
+/**
+* Get the 1-hop neighbour set of a node.
+*/
+function neighbourSet(graph, node) {
+	return new Set(graph.neighbours(node));
+}
+/**
+* Count common neighbours between two nodes.
+*/
+function commonNeighbours(graph, a, b) {
+	const na = neighbourSet(graph, a);
+	const nb = neighbourSet(graph, b);
+	let count = 0;
+	for (const n of na) if (nb.has(n)) count++;
+	return count;
+}
+/**
+* Compute Jaccard similarity between two sets.
+*/
+function jaccard$2(a, b) {
+	let intersection = 0;
+	for (const x of a) if (b.has(x)) intersection++;
+	const union = new Set([...a, ...b]).size;
+	return union === 0 ? 0 : intersection / union;
+}
+/**
+* Compute distance score peaking at distance 3.
+* Score ranges from 0 to 1, with maximum at dist=3.
+*/
+function distanceScore(dist) {
+	return 1 - Math.abs(dist - 3) / 3;
+}
+/**
+* CRISP — Connectivity-Rich Informed Seed Pairing.
+*
+* Samples random node pairs and scores them by common neighbour count
+* and BFS distance (preferring 2–4 hops, peaking at 3). Greedy
+* selection with Jaccard diversity ensures selected pairs are
+* spread across different structural regions.
+*
+* @param graph - The graph to sample seeds from
+* @param options - Configuration options
+* @returns Selected seed pairs with connectivity metadata
+*/
+function crisp(graph, options = {}) {
+	const config = {
+		...DEFAULTS$8,
+		...options
+	};
+	const rng = createRNG$5(config.rngSeed);
+	const allNodes = [...graph.nodeIds()];
+	if (allNodes.length < 2) return { pairs: [] };
+	if (allNodes.length < 4) {
+		const a = allNodes[0];
+		const b = allNodes[1];
+		if (a !== void 0 && b !== void 0) return { pairs: [{
+			source: { id: a },
+			target: { id: b },
+			distance: 1,
+			commonNeighbours: 0,
+			score: 0
+		}] };
+		return { pairs: [] };
+	}
+	const candidates = [];
+	const sampledPairs = /* @__PURE__ */ new Set();
+	const maxAttempts = config.sampleSize * 10;
+	let attempts = 0;
+	while (sampledPairs.size < config.sampleSize && attempts < maxAttempts) {
+		attempts++;
+		const a = allNodes[Math.floor(rng() * allNodes.length)];
+		const b = allNodes[Math.floor(rng() * allNodes.length)];
+		if (a === void 0 || b === void 0 || a === b) continue;
+		const pairKey = a < b ? `${a}|${b}` : `${b}|${a}`;
+		if (sampledPairs.has(pairKey)) continue;
+		sampledPairs.add(pairKey);
+		const dist = bfsDistance(graph, a, b);
+		if (dist < config.minDistance || dist > config.maxDistance) continue;
+		const cn = commonNeighbours(graph, a, b);
+		if (cn < config.minCommonNeighbours) continue;
+		const score = cn * (1 + distanceScore(dist));
+		candidates.push({
+			score,
+			distance: dist,
+			commonNeighbours: cn,
+			a,
+			b
+		});
+	}
+	if (candidates.length < config.nPairs) for (const pairKey of sampledPairs) {
+		const parts = pairKey.split("|");
+		if (parts.length !== 2) continue;
+		const a = parts[0];
+		const b = parts[1];
+		if (a === void 0 || b === void 0) continue;
+		const dist = bfsDistance(graph, a, b);
+		if (dist < 1 || dist > 6) continue;
+		const cn = commonNeighbours(graph, a, b);
+		const score = cn + .1;
+		candidates.push({
+			score,
+			distance: dist,
+			commonNeighbours: cn,
+			a,
+			b
+		});
+	}
+	candidates.sort((x, y) => y.score - x.score);
+	const selected = [];
+	const selectedPairKeys = /* @__PURE__ */ new Set();
+	for (const { score, distance, commonNeighbours, a, b } of candidates) {
+		if (selected.length >= config.nPairs) break;
+		const pairKey = a < b ? `${a}|${b}` : `${b}|${a}`;
+		if (selectedPairKeys.has(pairKey)) continue;
+		const aNbrs = neighbourSet(graph, a);
+		const bNbrs = neighbourSet(graph, b);
+		let isDiverse = true;
+		for (const prev of selected) {
+			const paNbrs = neighbourSet(graph, prev.source.id);
+			const pbNbrs = neighbourSet(graph, prev.target.id);
+			if (jaccard$2(aNbrs, paNbrs) >= config.diversityThreshold && jaccard$2(bNbrs, pbNbrs) >= config.diversityThreshold) {
+				isDiverse = false;
+				break;
+			}
+		}
+		if (!isDiverse) continue;
+		selectedPairKeys.add(pairKey);
+		selected.push({
+			source: { id: a },
+			target: { id: b },
+			distance,
+			commonNeighbours,
+			score
+		});
+	}
+	let fillAttempts = 0;
+	while (selected.length < config.nPairs && allNodes.length >= 2 && fillAttempts < config.nPairs * 20) {
+		fillAttempts++;
+		const i1 = Math.floor(rng() * allNodes.length);
+		const i2 = Math.floor(rng() * allNodes.length);
+		const a = allNodes[i1];
+		const b = allNodes[i2];
+		if (a === void 0 || b === void 0 || a === b) continue;
+		const pairKey = a < b ? `${a}|${b}` : `${b}|${a}`;
+		if (selectedPairKeys.has(pairKey)) continue;
+		selectedPairKeys.add(pairKey);
+		selected.push({
+			source: { id: a },
+			target: { id: b },
+			distance: 0,
+			commonNeighbours: 0,
+			score: 0
+		});
+	}
+	return { pairs: selected.slice(0, config.nPairs) };
+}
+//#endregion
+//#region src/seeds/grasp.ts
+/** Default configuration values */
+var DEFAULTS$7 = {
+	nClusters: 100,
+	pairsPerCluster: 10,
+	withinClusterRatio: .5,
+	sampleSize: 2e5,
+	rngSeed: 42,
+	pagerankIterations: 10
+};
+/**
+* Simple seeded pseudo-random number generator using mulberry32.
+*/
+function createRNG$4(seed) {
+	let state = seed >>> 0;
+	return () => {
+		state = state + 1831565813 >>> 0;
+		let t = Math.imul(state ^ state >>> 15, state | 1);
+		t = (t ^ t >>> 7) * (t | 1640531527);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/**
+* Reservoir sampling (Vitter's Algorithm R) for streaming node selection.
+*
+* Maintains a uniform sample of nodes as edges are streamed, without
+* requiring the full graph in memory.
+*/
+function reservoirSample(graph, sampleSize, rng) {
+	const reservoir = [];
+	const neighbourMap = /* @__PURE__ */ new Map();
+	const inReservoir = /* @__PURE__ */ new Set();
+	let nodesSeen = 0;
+	for (const edge of graph.edges()) {
+		const source = edge.source;
+		if (!inReservoir.has(source)) {
+			nodesSeen++;
+			if (reservoir.length < sampleSize) {
+				reservoir.push(source);
+				inReservoir.add(source);
+				neighbourMap.set(source, /* @__PURE__ */ new Set());
+			} else {
+				const j = Math.floor(rng() * nodesSeen);
+				if (j < sampleSize) {
+					const oldNode = reservoir[j];
+					if (oldNode !== void 0) {
+						inReservoir.delete(oldNode);
+						neighbourMap.delete(oldNode);
+					}
+					reservoir[j] = source;
+					inReservoir.add(source);
+					neighbourMap.set(source, /* @__PURE__ */ new Set());
+				}
+			}
+		}
+		const target = edge.target;
+		if (!inReservoir.has(target)) {
+			nodesSeen++;
+			if (reservoir.length < sampleSize) {
+				reservoir.push(target);
+				inReservoir.add(target);
+				neighbourMap.set(target, /* @__PURE__ */ new Set());
+			} else {
+				const j = Math.floor(rng() * nodesSeen);
+				if (j < sampleSize) {
+					const oldNode = reservoir[j];
+					if (oldNode !== void 0) {
+						inReservoir.delete(oldNode);
+						neighbourMap.delete(oldNode);
+					}
+					reservoir[j] = target;
+					inReservoir.add(target);
+					neighbourMap.set(target, /* @__PURE__ */ new Set());
+				}
+			}
+		}
+		if (inReservoir.has(source) && inReservoir.has(target)) {
+			const sourceNeighbours = neighbourMap.get(source);
+			const targetNeighbours = neighbourMap.get(target);
+			sourceNeighbours?.add(target);
+			targetNeighbours?.add(source);
+		}
+	}
+	return {
+		nodeIds: inReservoir,
+		neighbourMap
+	};
+}
+/**
+* Compute approximate PageRank scores using power iteration on the reservoir subgraph.
+*
+* This is an approximation since it only considers the sampled nodes and their
+* connections within the reservoir, not the full graph.
+*/
+function approximatePageRank(nodeIds, neighbourMap, iterations, dampingFactor = .85) {
+	const n = nodeIds.size;
+	if (n === 0) return /* @__PURE__ */ new Map();
+	const nodeIdList = [...nodeIds];
+	const nodeIndex = new Map(nodeIdList.map((id, i) => [id, i]));
+	const scores = new Float64Array(n).fill(1 / n);
+	const newScores = new Float64Array(n);
+	for (let iter = 0; iter < iterations; iter++) {
+		newScores.fill((1 - dampingFactor) / n);
+		for (let i = 0; i < n; i++) {
+			const nodeId = nodeIdList[i];
+			if (nodeId === void 0) continue;
+			const neighbours = neighbourMap.get(nodeId);
+			if (neighbours === void 0) continue;
+			const outDegree = neighbours.size;
+			if (outDegree === 0) continue;
+			const contribution = dampingFactor * (scores[i] ?? 0) / outDegree;
+			for (const neighbour of neighbours) {
+				const neighbourIdx = nodeIndex.get(neighbour);
+				if (neighbourIdx !== void 0) newScores[neighbourIdx] = (newScores[neighbourIdx] ?? 0) + contribution;
+			}
+		}
+		for (let i = 0; i < n; i++) scores[i] = newScores[i] ?? 0;
+	}
+	const result = /* @__PURE__ */ new Map();
+	for (let i = 0; i < n; i++) {
+		const nodeId = nodeIdList[i];
+		const score = scores[i];
+		if (nodeId !== void 0 && score !== void 0) result.set(nodeId, score);
+	}
+	return result;
+}
+/**
+* Compute structural features for sampled nodes.
+*
+* Features:
+* - f1: log(deg(v) + 1) — scale-normalised connectivity
+* - f2: clustering_coefficient(v) — local density
+* - f3: approx_pagerank(v) — positional importance
+*/
+function computeFeatures(graph, nodeIds, neighbourMap, pagerankScores) {
+	const features = [];
+	for (const nodeId of nodeIds) {
+		const degree = graph.degree(nodeId, "both");
+		const neighbours = neighbourMap.get(nodeId);
+		let clusteringCoef = 0;
+		if (neighbours !== void 0 && neighbours.size >= 2) {
+			let triangleCount = 0;
+			const neighbourList = [...neighbours];
+			for (let i = 0; i < neighbourList.length; i++) for (let j = i + 1; j < neighbourList.length; j++) {
+				const u = neighbourList[i];
+				const w = neighbourList[j];
+				if (u !== void 0 && w !== void 0) {
+					if (neighbourMap.get(u)?.has(w) === true) triangleCount++;
+				}
+			}
+			const possibleTriangles = degree * (degree - 1) / 2;
+			clusteringCoef = triangleCount / possibleTriangles;
+		}
+		const pagerank = pagerankScores.get(nodeId) ?? 0;
+		features.push({
+			nodeId,
+			f1: Math.log(degree + 1),
+			f2: clusteringCoef,
+			f3: pagerank
+		});
+	}
+	return features;
+}
+/**
+* Sample seed pairs from clusters.
+*
+* For each cluster, samples a mix of within-cluster and cross-cluster pairs.
+*/
+function samplePairs(features, clusterAssignments, nClusters, pairsPerCluster, withinClusterRatio, rng) {
+	const pairs = [];
+	const clusterNodes = /* @__PURE__ */ new Map();
+	for (const feature of features) {
+		const cluster = clusterAssignments.get(feature.nodeId);
+		if (cluster === void 0) continue;
+		let nodes = clusterNodes.get(cluster);
+		if (nodes === void 0) {
+			nodes = [];
+			clusterNodes.set(cluster, nodes);
+		}
+		nodes.push(feature);
+	}
+	const withinCount = Math.floor(pairsPerCluster * withinClusterRatio);
+	const crossCount = pairsPerCluster - withinCount;
+	for (let clusterIdx = 0; clusterIdx < nClusters; clusterIdx++) {
+		const nodes = clusterNodes.get(clusterIdx);
+		if (nodes === void 0 || nodes.length < 2) continue;
+		for (let i = 0; i < withinCount; i++) {
+			const idx1 = Math.floor(rng() * nodes.length);
+			let idx2 = Math.floor(rng() * nodes.length);
+			while (idx1 === idx2) idx2 = Math.floor(rng() * nodes.length);
+			const source = nodes[idx1];
+			const target = nodes[idx2];
+			if (source === void 0 || target === void 0) continue;
+			const distance = computeFeatureDistance(source, target);
+			pairs.push({
+				source: { id: source.nodeId },
+				target: { id: target.nodeId },
+				featureDistance: distance,
+				sameCluster: true,
+				sourceCluster: clusterIdx,
+				targetCluster: clusterIdx
+			});
+		}
+		for (let i = 0; i < crossCount; i++) {
+			const source = nodes[Math.floor(rng() * nodes.length)];
+			if (source === void 0) continue;
+			const otherClusterIdx = Math.floor(rng() * nClusters);
+			if (otherClusterIdx === clusterIdx) continue;
+			const otherNodes = clusterNodes.get(otherClusterIdx);
+			if (otherNodes === void 0 || otherNodes.length === 0) continue;
+			const target = otherNodes[Math.floor(rng() * otherNodes.length)];
+			if (target === void 0) continue;
+			const distance = computeFeatureDistance(source, target);
+			pairs.push({
+				source: { id: source.nodeId },
+				target: { id: target.nodeId },
+				featureDistance: distance,
+				sameCluster: false,
+				sourceCluster: clusterIdx,
+				targetCluster: otherClusterIdx
+			});
+		}
+	}
+	return pairs;
+}
+/**
+* Compute Euclidean distance between two feature vectors.
+*/
+function computeFeatureDistance(a, b) {
+	const d1 = a.f1 - b.f1;
+	const d2 = a.f2 - b.f2;
+	const d3 = a.f3 - b.f3;
+	return Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3);
+}
+/**
+* GRASP — Graph-agnostic Representative Seed pAir Sampling.
+*
+* Selects structurally representative seed pairs without domain knowledge.
+* The algorithm streams edges, samples nodes via reservoir sampling, computes
+* structural features, clusters nodes, and samples pairs within/across clusters.
+*
+* @param graph - The graph to sample seeds from
+* @param options - Configuration options
+* @returns Sampled seed pairs with structural metadata
+*
+* @example
+* ```typescript
+* const graph = new AdjacencyMapGraph();
+* // ... populate graph ...
+*
+* const result = grasp(graph, {
+*   nClusters: 50,
+*   pairsPerCluster: 20,
+*   sampleSize: 100000,
+* });
+*
+* console.log(`Sampled ${result.pairs.length} pairs from ${result.sampledNodeCount} nodes`);
+* ```
+*/
+function grasp(graph, options = {}) {
+	const config = {
+		...DEFAULTS$7,
+		...options
+	};
+	const rng = createRNG$4(config.rngSeed);
+	const { nodeIds, neighbourMap } = reservoirSample(graph, config.sampleSize, rng);
+	let features = computeFeatures(graph, nodeIds, neighbourMap, approximatePageRank(nodeIds, neighbourMap, config.pagerankIterations));
+	if (features.length > 0) features = require_kmeans.normaliseFeatures(features);
+	const k = Math.min(config.nClusters, features.length);
+	const kmeansResult = require_kmeans.miniBatchKMeans(features, {
+		k,
+		seed: config.rngSeed,
+		maxIterations: 100
+	});
+	return {
+		pairs: samplePairs(features, kmeansResult.assignments, kmeansResult.k, config.pairsPerCluster, config.withinClusterRatio, rng),
+		nClusters: kmeansResult.k,
+		sampledNodeCount: nodeIds.size,
+		features,
+		clusterAssignments: kmeansResult.assignments
+	};
+}
+//#endregion
+//#region src/seeds/hybrid-core.ts
+function createRNG$3(seed) {
+	let state = seed >>> 0;
+	return () => {
+		state = state + 1831565813 >>> 0;
+		let t = Math.imul(state ^ state >>> 15, state | 1);
+		t = (t ^ t >>> 7) * (t | 1640531527);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+function canonicalPair(a, b) {
+	return a < b ? [a, b] : [b, a];
+}
+function pairKey(a, b) {
+	const [x, y] = canonicalPair(a, b);
+	return `${x}|${y}`;
+}
+function bfsDistances(graph, source) {
+	const dist = new Map([[source, 0]]);
+	const queue = [source];
+	while (queue.length > 0) {
+		const node = queue.shift();
+		if (node === void 0) continue;
+		const baseDist = dist.get(node) ?? 0;
+		for (const neighbour of graph.neighbours(node)) if (!dist.has(neighbour)) {
+			dist.set(neighbour, baseDist + 1);
+			queue.push(neighbour);
+		}
+	}
+	return dist;
+}
+function degreeDiversePairs(graph, nPairs, rngSeed) {
+	const rng = createRNG$3(rngSeed);
+	const allNodes = [...graph.nodeIds()];
+	if (allNodes.length < 2 || nPairs <= 0) return [];
+	const byDegree = allNodes.map((id) => ({
+		id,
+		d: graph.degree(id)
+	})).sort((a, b) => a.d - b.d);
+	const n = byDegree.length;
+	const low = byDegree.slice(0, Math.max(1, Math.floor(n / 3))).map((x) => x.id);
+	const high = byDegree.slice(Math.max(0, Math.floor(2 * n / 3))).map((x) => x.id);
+	const mid = byDegree.slice(Math.max(1, Math.floor(n / 3)), Math.max(1, Math.floor(2 * n / 3))).map((x) => x.id);
+	const pairs = [];
+	const seen = /* @__PURE__ */ new Set();
+	const addRandomPair = (aPool, bPool) => {
+		if (aPool.length === 0) return;
+		const right = bPool ?? aPool;
+		if (right.length === 0) return;
+		for (let attempts = 0; attempts < 40; attempts++) {
+			const a = aPool[Math.floor(rng() * aPool.length)];
+			const b = right[Math.floor(rng() * right.length)];
+			if (a === void 0 || b === void 0 || a === b) continue;
+			const key = pairKey(a, b);
+			if (seen.has(key)) continue;
+			seen.add(key);
+			const [x, y] = canonicalPair(a, b);
+			pairs.push({
+				source: { id: x },
+				target: { id: y }
+			});
+			return;
+		}
+	};
+	const lowHighCount = Math.floor(nPairs * .5);
+	const lowLowCount = Math.floor(nPairs * .25);
+	const highHighCount = nPairs - lowHighCount - lowLowCount;
+	for (let i = 0; i < lowHighCount; i++) addRandomPair(low, high);
+	for (let i = 0; i < lowLowCount; i++) addRandomPair(low);
+	for (let i = 0; i < highHighCount; i++) addRandomPair(high);
+	while (pairs.length < nPairs) {
+		if (mid.length > 0) addRandomPair(mid);
+		else addRandomPair(allNodes);
+		if (pairs.length >= Math.min(nPairs, allNodes.length * (allNodes.length - 1) / 2)) break;
+	}
+	return pairs.slice(0, nPairs);
+}
+function maxDistancePairs(graph, nPairs, rngSeed) {
+	const rng = createRNG$3(rngSeed);
+	const nodes = [...graph.nodeIds()];
+	if (nodes.length < 2 || nPairs <= 0) return [];
+	const sourceLimit = Math.min(nodes.length, 64);
+	const shuffled = [...nodes];
+	for (let i = shuffled.length - 1; i > 0; i--) {
+		const j = Math.floor(rng() * (i + 1));
+		const a = shuffled[i];
+		const b = shuffled[j];
+		if (a !== void 0 && b !== void 0) {
+			shuffled[i] = b;
+			shuffled[j] = a;
+		}
+	}
+	const ranked = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const source of shuffled.slice(0, sourceLimit)) {
+		const dist = bfsDistances(graph, source);
+		for (const [target, d] of dist) {
+			if (source === target || d <= 0) continue;
+			const key = pairKey(source, target);
+			if (seen.has(key)) continue;
+			seen.add(key);
+			const [a, b] = canonicalPair(source, target);
+			ranked.push({
+				a,
+				b,
+				d
+			});
+		}
+	}
+	ranked.sort((x, y) => y.d - x.d);
+	return ranked.slice(0, nPairs).map((x) => ({
+		source: { id: x.a },
+		target: { id: x.b }
+	}));
+}
+function labelPropagation(graph, rngSeed, maxIterations = 30) {
+	const rng = createRNG$3(rngSeed);
+	const nodes = [...graph.nodeIds()];
+	const labels = new Map(nodes.map((id, i) => [id, i]));
+	const order = [...nodes];
+	for (let iteration = 0; iteration < maxIterations; iteration++) {
+		let changed = false;
+		for (let i = order.length - 1; i > 0; i--) {
+			const j = Math.floor(rng() * (i + 1));
+			const a = order[i];
+			const b = order[j];
+			if (a !== void 0 && b !== void 0) {
+				order[i] = b;
+				order[j] = a;
+			}
+		}
+		for (const node of order) {
+			const counts = /* @__PURE__ */ new Map();
+			for (const n of graph.neighbours(node)) {
+				const label = labels.get(n);
+				if (label === void 0) continue;
+				counts.set(label, (counts.get(label) ?? 0) + 1);
+			}
+			if (counts.size === 0) continue;
+			let bestLabel = labels.get(node) ?? 0;
+			let bestCount = -1;
+			for (const [label, count] of counts) if (count > bestCount || count === bestCount && rng() < .5) {
+				bestCount = count;
+				bestLabel = label;
+			}
+			if ((labels.get(node) ?? -1) !== bestLabel) {
+				labels.set(node, bestLabel);
+				changed = true;
+			}
+		}
+		if (!changed) break;
+	}
+	return labels;
+}
+function communityBridgePairs(graph, nPairs, rngSeed) {
+	const labels = labelPropagation(graph, rngSeed);
+	const nodes = [...graph.nodeIds()];
+	if (nodes.length < 2 || nPairs <= 0) return [];
+	const size = /* @__PURE__ */ new Map();
+	for (const label of labels.values()) size.set(label, (size.get(label) ?? 0) + 1);
+	const ranked = [];
+	for (let i = 0; i < nodes.length; i++) {
+		const a = nodes[i];
+		if (a === void 0) continue;
+		for (let j = i + 1; j < nodes.length; j++) {
+			const b = nodes[j];
+			if (b === void 0) continue;
+			const la = labels.get(a);
+			const lb = labels.get(b);
+			if (la === void 0 || lb === void 0 || la === lb) continue;
+			const score = (size.get(la) ?? 1) * (size.get(lb) ?? 1);
+			ranked.push({
+				a,
+				b,
+				score
+			});
+		}
+	}
+	ranked.sort((x, y) => y.score - x.score);
+	return ranked.slice(0, nPairs).map((x) => ({
+		source: { id: x.a },
+		target: { id: x.b }
+	}));
+}
+function runEnsemble(graph, components, options) {
+	const nPairs = Math.max(0, options.nPairs);
+	if (nPairs === 0) return [];
+	const rng = createRNG$3(options.rngSeed);
+	const oversampleMultiplier = options.oversampleMultiplier ?? 3;
+	const blindPriorityBias = options.blindPriorityBias ?? 0;
+	const nodeReusePenalty = options.nodeReusePenalty ?? .15;
+	const consensusBonus = options.consensusBonus ?? .05;
+	const oversample = Math.max(nPairs * oversampleMultiplier, 30);
+	const pairMap = /* @__PURE__ */ new Map();
+	components.forEach((component, index) => {
+		let pairs;
+		try {
+			pairs = component.select(graph, oversample, options.rngSeed + (index + 1) * 97);
+		} catch {
+			pairs = [];
+		}
+		const m = pairs.length;
+		if (m === 0) return;
+		for (let rank = 0; rank < m; rank++) {
+			const pair = pairs[rank];
+			if (pair === void 0) continue;
+			const a = pair.source.id;
+			const b = pair.target.id;
+			if (a === b) continue;
+			const [x, y] = canonicalPair(a, b);
+			const key = `${x}|${y}`;
+			const rankWeight = m <= 1 ? 1 : 1 - rank / (m - 1);
+			const componentBonus = component.isBlind ? 1 + blindPriorityBias : 1;
+			const score = component.weight * componentBonus * (.5 + .5 * rankWeight);
+			const existing = pairMap.get(key);
+			if (existing === void 0) pairMap.set(key, {
+				a: x,
+				b: y,
+				score,
+				support: 1,
+				blindVotes: component.isBlind ? 1 : 0,
+				components: new Set([component.id])
+			});
+			else {
+				existing.score += score;
+				existing.support += 1;
+				existing.blindVotes += component.isBlind ? 1 : 0;
+				existing.components.add(component.id);
+			}
+		}
+	});
+	for (const meta of pairMap.values()) meta.score *= 1 + consensusBonus * Math.max(0, meta.support - 1);
+	const selected = [];
+	const nodeUsage = /* @__PURE__ */ new Map();
+	const candidates = [...pairMap.values()];
+	while (candidates.length > 0 && selected.length < nPairs) {
+		let bestIndex = -1;
+		let bestValue = Number.NEGATIVE_INFINITY;
+		for (let i = 0; i < candidates.length; i++) {
+			const candidate = candidates[i];
+			if (candidate === void 0) continue;
+			const usage = (nodeUsage.get(candidate.a) ?? 0) + (nodeUsage.get(candidate.b) ?? 0);
+			const value = candidate.score - nodeReusePenalty * usage;
+			if (value > bestValue) {
+				bestValue = value;
+				bestIndex = i;
+			}
+		}
+		if (bestIndex < 0) break;
+		const [best] = candidates.splice(bestIndex, 1);
+		if (best === void 0) break;
+		nodeUsage.set(best.a, (nodeUsage.get(best.a) ?? 0) + 1);
+		nodeUsage.set(best.b, (nodeUsage.get(best.b) ?? 0) + 1);
+		selected.push({
+			source: { id: best.a },
+			target: { id: best.b },
+			score: best.score,
+			support: best.support,
+			blindVotes: best.blindVotes,
+			components: [...best.components].sort()
+		});
+	}
+	if (selected.length < nPairs) {
+		const allNodes = [...graph.nodeIds()];
+		const seen = new Set(selected.map((p) => pairKey(p.source.id, p.target.id)));
+		const maxAttempts = nPairs * 40;
+		let attempts = 0;
+		while (selected.length < nPairs && allNodes.length >= 2 && attempts < maxAttempts) {
+			attempts++;
+			const a = allNodes[Math.floor(rng() * allNodes.length)];
+			const b = allNodes[Math.floor(rng() * allNodes.length)];
+			if (a === void 0 || b === void 0 || a === b) continue;
+			const [x, y] = canonicalPair(a, b);
+			const key = `${x}|${y}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			selected.push({
+				source: { id: x },
+				target: { id: y },
+				score: 0,
+				support: 0,
+				blindVotes: 0,
+				components: []
+			});
+		}
+	}
+	return selected.slice(0, nPairs);
+}
+//#endregion
+//#region src/seeds/spine.ts
+/** Default configuration values */
+var DEFAULTS$6 = {
+	nPairs: 100,
+	rngSeed: 42,
+	diversityThreshold: .5
+};
+/**
+* Simple seeded pseudo-random number generator using mulberry32.
+*/
+function createRNG$2(seed) {
+	let state = seed >>> 0;
+	return () => {
+		state = state + 1831565813 >>> 0;
+		let t = Math.imul(state ^ state >>> 15, state | 1);
+		t = (t ^ t >>> 7) * (t | 1640531527);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/**
+* Compute skewness of the 2-hop degree distribution for a node.
+*
+* For each neighbour u of node, collect the degree of u.
+* Skewness = E[(X - μ)³] / σ³ where X is the degree distribution.
+*
+* High skewness = neighbour degrees are heavily concentrated at one end.
+* Low skewness = neighbour degrees are relatively uniform.
+*
+* Returns 0.0 for nodes with fewer than 3 neighbours.
+*/
+function degreeSkewness(graph, node) {
+	const neighbours = [...graph.neighbours(node)];
+	if (neighbours.length < 3) return 0;
+	const degrees = neighbours.map((n) => graph.degree(n, "both"));
+	const n = degrees.length;
+	const mean = degrees.reduce((s, d) => s + d, 0) / n;
+	const variance = degrees.reduce((s, d) => s + (d - mean) ** 2, 0) / n;
+	if (variance < 1e-10) return 0;
+	const std = Math.sqrt(variance);
+	return degrees.reduce((s, d) => s + (d - mean) ** 3, 0) / n / std ** 3;
+}
+/**
+* Compute Jaccard similarity between two sets.
+*/
+function jaccard$1(a, b) {
+	const intersection = [...a].filter((x) => b.has(x)).length;
+	const union = new Set([...a, ...b]).size;
+	return union === 0 ? 0 : intersection / union;
+}
+/**
+* SPINE — Structural Position-Informed Node Extraction.
+*
+* Computes 2-hop degree distribution skewness for each node. Nodes with
+* high positive skewness have structurally diverse neighbours (hub-periphery
+* mix), while nodes with low skewness have uniform neighbours. Pairs
+* connecting high-skewness and low-skewness nodes explore structurally
+* varied terrain.
+*
+* @param graph - The graph to sample seeds from
+* @param options - Configuration options
+* @returns Selected seed pairs with skewness metadata
+*/
+function spine(graph, options = {}) {
+	const config = {
+		...DEFAULTS$6,
+		...options
+	};
+	const rng = createRNG$2(config.rngSeed);
+	const allNodes = [...graph.nodeIds()];
+	if (allNodes.length < 2) return {
+		pairs: [],
+		skewness: /* @__PURE__ */ new Map()
+	};
+	const skewnessMap = /* @__PURE__ */ new Map();
+	for (const node of allNodes) skewnessMap.set(node, degreeSkewness(graph, node));
+	const sortedNodes = [...allNodes].sort((a, b) => (skewnessMap.get(a) ?? 0) - (skewnessMap.get(b) ?? 0));
+	const n = sortedNodes.length;
+	const lowSkew = sortedNodes.slice(0, Math.floor(n / 3));
+	const midSkew = sortedNodes.slice(Math.floor(n / 3), Math.floor(2 * n / 3));
+	const highSkew = sortedNodes.slice(Math.floor(2 * n / 3));
+	const candidates = [];
+	const sampleSize = Math.max(config.nPairs * 20, 200);
+	for (let i = 0; i < sampleSize; i++) {
+		if (!highSkew.length || !lowSkew.length) break;
+		const a = highSkew[Math.floor(rng() * highSkew.length)];
+		const b = lowSkew[Math.floor(rng() * lowSkew.length)];
+		if (a === void 0 || b === void 0 || a === b) continue;
+		const skA = skewnessMap.get(a) ?? 0;
+		const skB = skewnessMap.get(b) ?? 0;
+		candidates.push({
+			score: Math.abs(skA - skB),
+			a,
+			b
+		});
+	}
+	const halfSample = Math.floor(sampleSize / 2);
+	for (let i = 0; i < halfSample; i++) {
+		if (midSkew.length && highSkew.length) {
+			const a = highSkew[Math.floor(rng() * highSkew.length)];
+			const b = midSkew[Math.floor(rng() * midSkew.length)];
+			if (a !== void 0 && b !== void 0 && a !== b) {
+				const skA = skewnessMap.get(a) ?? 0;
+				const skB = skewnessMap.get(b) ?? 0;
+				candidates.push({
+					score: Math.abs(skA - skB) * .8,
+					a,
+					b
+				});
+			}
+		}
+		if (midSkew.length && lowSkew.length) {
+			const a = midSkew[Math.floor(rng() * midSkew.length)];
+			const b = lowSkew[Math.floor(rng() * lowSkew.length)];
+			if (a !== void 0 && b !== void 0 && a !== b) {
+				const skA = skewnessMap.get(a) ?? 0;
+				const skB = skewnessMap.get(b) ?? 0;
+				candidates.push({
+					score: Math.abs(skA - skB) * .8,
+					a,
+					b
+				});
+			}
+		}
+	}
+	const quarterSample = Math.floor(sampleSize / 4);
+	for (let i = 0; i < quarterSample; i++) if (highSkew.length >= 2) {
+		const i1 = Math.floor(rng() * highSkew.length);
+		let i2 = Math.floor(rng() * highSkew.length);
+		while (i1 === i2) i2 = Math.floor(rng() * highSkew.length);
+		const a = highSkew[i1];
+		const b = highSkew[i2];
+		if (a !== void 0 && b !== void 0) {
+			const skA = skewnessMap.get(a) ?? 0;
+			const skB = skewnessMap.get(b) ?? 0;
+			candidates.push({
+				score: Math.abs(skA - skB) * .5,
+				a,
+				b
+			});
+		}
+	}
+	candidates.sort((x, y) => y.score - x.score);
+	const selected = [];
+	const selectedPairKeys = /* @__PURE__ */ new Set();
+	for (const { a, b } of candidates) {
+		if (selected.length >= config.nPairs) break;
+		const pairKey = a < b ? `${a}|${b}` : `${b}|${a}`;
+		if (selectedPairKeys.has(pairKey)) continue;
+		const aNbrs = new Set(graph.neighbours(a));
+		const bNbrs = new Set(graph.neighbours(b));
+		let isDiverse = true;
+		for (const prev of selected) if (jaccard$1(aNbrs, new Set(graph.neighbours(prev.source.id))) >= config.diversityThreshold) {
+			if (jaccard$1(bNbrs, new Set(graph.neighbours(prev.target.id))) >= config.diversityThreshold) {
+				isDiverse = false;
+				break;
+			}
+		}
+		if (!isDiverse) continue;
+		selectedPairKeys.add(pairKey);
+		selected.push({
+			source: { id: a },
+			target: { id: b },
+			sourceSkewness: skewnessMap.get(a) ?? 0,
+			targetSkewness: skewnessMap.get(b) ?? 0
+		});
+	}
+	let fillAttempts = 0;
+	while (selected.length < config.nPairs && allNodes.length >= 2 && fillAttempts < config.nPairs * 20) {
+		fillAttempts++;
+		const i1 = Math.floor(rng() * allNodes.length);
+		const i2 = Math.floor(rng() * allNodes.length);
+		const a = allNodes[i1];
+		const b = allNodes[i2];
+		if (a === void 0 || b === void 0 || a === b) continue;
+		const pairKey = a < b ? `${a}|${b}` : `${b}|${a}`;
+		if (selectedPairKeys.has(pairKey)) continue;
+		selectedPairKeys.add(pairKey);
+		selected.push({
+			source: { id: a },
+			target: { id: b },
+			sourceSkewness: skewnessMap.get(a) ?? 0,
+			targetSkewness: skewnessMap.get(b) ?? 0
+		});
+	}
+	return {
+		pairs: selected.slice(0, config.nPairs),
+		skewness: skewnessMap
+	};
+}
+//#endregion
+//#region src/seeds/stride.ts
+/** Default configuration values */
+var DEFAULTS$5 = {
+	nPairs: 100,
+	rngSeed: 42,
+	diversityThreshold: .5
+};
+/**
+* Simple seeded pseudo-random number generator using mulberry32.
+*/
+function createRNG$1(seed) {
+	let state = seed >>> 0;
+	return () => {
+		state = state + 1831565813 >>> 0;
+		let t = Math.imul(state ^ state >>> 15, state | 1);
+		t = (t ^ t >>> 7) * (t | 1640531527);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/**
+* Count closed triads (3-cycles) involving a node.
+*
+* A triad is a triple (node, u, v) where u and v are both neighbours
+* of node AND u-v is an edge.
+*/
+function countTriads(graph, node) {
+	const neighbours = [...graph.neighbours(node)];
+	if (neighbours.length < 2) return 0;
+	const neighbourSet = new Set(neighbours);
+	let count = 0;
+	for (let i = 0; i < neighbours.length; i++) for (let j = i + 1; j < neighbours.length; j++) {
+		const u = neighbours[i];
+		const v = neighbours[j];
+		if (u !== void 0 && v !== void 0) {
+			if (new Set(graph.neighbours(u)).has(v) && neighbourSet.has(v)) count++;
+		}
+	}
+	return count;
+}
+/**
+* Classify a node by triad count into core/bridge/periphery.
+*/
+function triadCategory(triadCount, p33, p66) {
+	if (triadCount <= p33) return "periphery";
+	if (triadCount <= p66) return "bridge";
+	return "core";
+}
+/**
+* Compute Jaccard similarity between two sets.
+*/
+function jaccard(a, b) {
+	const intersection = [...a].filter((x) => b.has(x)).length;
+	const union = new Set([...a, ...b]).size;
+	return union === 0 ? 0 : intersection / union;
+}
+/**
+* STRIDE — Shortest-TRIangle Diversity seed selection.
+*
+* Nodes are categorised by local triad count into core, bridge, and
+* periphery. Pairs spanning different categories capture structural
+* diversity: core-periphery pairs traverse community interiors to
+* boundaries, bridge-bridge pairs span community gaps.
+*
+* @param graph - The graph to sample seeds from
+* @param options - Configuration options
+* @returns Selected seed pairs with triad metadata
+*/
+function stride(graph, options = {}) {
+	const config = {
+		...DEFAULTS$5,
+		...options
+	};
+	const rng = createRNG$1(config.rngSeed);
+	const allNodes = [...graph.nodeIds()];
+	if (allNodes.length < 2) return {
+		pairs: [],
+		triadCounts: /* @__PURE__ */ new Map(),
+		categories: /* @__PURE__ */ new Map()
+	};
+	const triadCounts = /* @__PURE__ */ new Map();
+	for (const node of allNodes) triadCounts.set(node, countTriads(graph, node));
+	const countsSorted = [...triadCounts.values()].sort((a, b) => a - b);
+	const n = countsSorted.length;
+	const p33 = countsSorted[Math.floor(n / 3)] ?? 0;
+	const p66 = countsSorted[Math.floor(2 * n / 3)] ?? 0;
+	const categories = /* @__PURE__ */ new Map();
+	const categoryGroups = /* @__PURE__ */ new Map();
+	for (const [node, tc] of triadCounts) {
+		const cat = triadCategory(tc, p33, p66);
+		categories.set(node, cat);
+		let group = categoryGroups.get(cat);
+		if (group === void 0) {
+			group = [];
+			categoryGroups.set(cat, group);
+		}
+		group.push(node);
+	}
+	const catNames = [
+		"core",
+		"bridge",
+		"periphery"
+	];
+	const candidates = [];
+	for (const catA of catNames) for (const catB of catNames) {
+		const groupA = categoryGroups.get(catA);
+		const groupB = categoryGroups.get(catB);
+		if (groupA === void 0 || groupB === void 0) continue;
+		const aLen = groupA.length;
+		const bLen = groupB.length;
+		if (aLen === 0 || bLen === 0) continue;
+		const crossBonus = catA === catB ? 0 : 1;
+		const sampleSize = Math.max(config.nPairs * 3, 30);
+		for (let s = 0; s < sampleSize; s++) {
+			const a = groupA[Math.floor(rng() * groupA.length)];
+			const b = catA === catB ? groupA[Math.floor(rng() * groupA.length)] : groupB[Math.floor(rng() * groupB.length)];
+			if (a === void 0 || b === void 0 || a === b) continue;
+			const tcA = triadCounts.get(a) ?? 0;
+			const tcB = triadCounts.get(b) ?? 0;
+			const score = Math.abs(tcA - tcB) + crossBonus * Math.max(tcA, tcB, 1);
+			candidates.push({
+				score,
+				a,
+				b
+			});
+		}
+	}
+	candidates.sort((x, y) => y.score - x.score);
+	const selected = [];
+	const selectedPairKeys = /* @__PURE__ */ new Set();
+	for (const candidate of candidates) {
+		const { a, b } = candidate;
+		if (selected.length >= config.nPairs) break;
+		const pairKey = a < b ? `${a}|${b}` : `${b}|${a}`;
+		if (selectedPairKeys.has(pairKey)) continue;
+		const aNbrs = new Set(graph.neighbours(a));
+		const bNbrs = new Set(graph.neighbours(b));
+		let isDiverse = true;
+		for (const prev of selected) if (jaccard(aNbrs, new Set(graph.neighbours(prev.source.id))) >= config.diversityThreshold) {
+			if (jaccard(bNbrs, new Set(graph.neighbours(prev.target.id))) >= config.diversityThreshold) {
+				isDiverse = false;
+				break;
+			}
+		}
+		if (!isDiverse) continue;
+		selectedPairKeys.add(pairKey);
+		selected.push({
+			source: { id: a },
+			target: { id: b },
+			sourceTriads: triadCounts.get(a) ?? 0,
+			targetTriads: triadCounts.get(b) ?? 0,
+			sourceCategory: categories.get(a) ?? "periphery",
+			targetCategory: categories.get(b) ?? "periphery"
+		});
+	}
+	let fillAttempts = 0;
+	while (selected.length < config.nPairs && allNodes.length >= 2 && fillAttempts < config.nPairs * 20) {
+		fillAttempts++;
+		const i1 = Math.floor(rng() * allNodes.length);
+		const i2 = Math.floor(rng() * allNodes.length);
+		const a = allNodes[i1];
+		const b = allNodes[i2];
+		if (a === void 0 || b === void 0 || a === b) continue;
+		const pairKey = a < b ? `${a}|${b}` : `${b}|${a}`;
+		if (selectedPairKeys.has(pairKey)) continue;
+		selectedPairKeys.add(pairKey);
+		selected.push({
+			source: { id: a },
+			target: { id: b },
+			sourceTriads: triadCounts.get(a) ?? 0,
+			targetTriads: triadCounts.get(b) ?? 0,
+			sourceCategory: categories.get(a) ?? "periphery",
+			targetCategory: categories.get(b) ?? "periphery"
+		});
+	}
+	return {
+		pairs: selected.slice(0, config.nPairs),
+		triadCounts,
+		categories
+	};
+}
+//#endregion
+//#region src/seeds/basil.ts
+var DEFAULTS$4 = {
+	nPairs: 100,
+	rngSeed: 42,
+	blindPriorityBias: .2
+};
+function basil(graph, options = {}) {
+	const config = {
+		...DEFAULTS$4,
+		...options
+	};
+	return { pairs: runEnsemble(graph, [
+		{
+			id: "stride",
+			weight: 1,
+			isBlind: true,
+			select: (g, nPairs, rngSeed) => stride(g, {
+				nPairs,
+				rngSeed
+			}).pairs
+		},
+		{
+			id: "crest",
+			weight: 1,
+			isBlind: true,
+			select: (g, nPairs, rngSeed) => crest(g, {
+				nPairs,
+				rngSeed
+			}).pairs
+		},
+		{
+			id: "spine",
+			weight: .95,
+			isBlind: true,
+			select: (g, nPairs, rngSeed) => spine(g, {
+				nPairs,
+				rngSeed
+			}).pairs
+		},
+		{
+			id: "grasp",
+			weight: .85,
+			isBlind: true,
+			select: (g, nPairs, rngSeed) => {
+				const k = Math.min(24, Math.max(8, Math.round(Math.sqrt(g.nodeCount))));
+				return grasp(g, {
+					rngSeed,
+					nClusters: k,
+					pairsPerCluster: Math.max(2, Math.ceil(nPairs / Math.max(1, k))),
+					sampleSize: Math.min(2e4, Math.max(2e3, g.nodeCount * 20))
+				}).pairs;
+			}
+		},
+		{
+			id: "degree_diverse",
+			weight: .6,
+			isBlind: true,
+			select: degreeDiversePairs
+		},
+		{
+			id: "crisp",
+			weight: .25,
+			isBlind: false,
+			select: (g, nPairs, rngSeed) => crisp(g, {
+				nPairs,
+				rngSeed
+			}).pairs
+		}
+	], {
+		nPairs: config.nPairs,
+		rngSeed: config.rngSeed,
+		blindPriorityBias: config.blindPriorityBias
+	}) };
+}
+//#endregion
+//#region src/seeds/brisk.ts
+var DEFAULTS$3 = {
+	nPairs: 100,
+	rngSeed: 42,
+	blindPriorityBias: .1,
+	includeGrasp: true
+};
+function brisk(graph, options = {}) {
+	const config = {
+		...DEFAULTS$3,
+		...options
+	};
+	const components = [
+		{
+			id: "stride",
+			weight: 1,
+			isBlind: true,
+			select: (g, nPairs, rngSeed) => stride(g, {
+				nPairs,
+				rngSeed
+			}).pairs
+		},
+		{
+			id: "crest",
+			weight: 1,
+			isBlind: true,
+			select: (g, nPairs, rngSeed) => crest(g, {
+				nPairs,
+				rngSeed
+			}).pairs
+		},
+		{
+			id: "spine",
+			weight: .95,
+			isBlind: true,
+			select: (g, nPairs, rngSeed) => spine(g, {
+				nPairs,
+				rngSeed
+			}).pairs
+		},
+		{
+			id: "degree_diverse",
+			weight: .6,
+			isBlind: true,
+			select: degreeDiversePairs
+		}
+	];
+	if (config.includeGrasp) components.push({
+		id: "grasp",
+		weight: .8,
+		isBlind: true,
+		select: (g, nPairs, rngSeed) => {
+			const k = Math.min(24, Math.max(8, Math.round(Math.sqrt(g.nodeCount))));
+			return grasp(g, {
+				rngSeed,
+				nClusters: k,
+				pairsPerCluster: Math.max(2, Math.ceil(nPairs / Math.max(1, k))),
+				sampleSize: Math.min(2e4, Math.max(2e3, g.nodeCount * 20))
+			}).pairs;
+		}
+	});
+	return { pairs: runEnsemble(graph, components, {
+		nPairs: config.nPairs,
+		rngSeed: config.rngSeed,
+		blindPriorityBias: config.blindPriorityBias
+	}) };
+}
+//#endregion
+//#region src/seeds/omnia.ts
+var DEFAULTS$2 = {
+	nPairs: 100,
+	rngSeed: 42,
+	blindPriorityBias: .05
+};
+function omnia(graph, options = {}) {
+	const config = {
+		...DEFAULTS$2,
+		...options
+	};
+	return { pairs: runEnsemble(graph, [
+		{
+			id: "stride",
+			weight: 1,
+			isBlind: true,
+			select: (g, nPairs, rngSeed) => stride(g, {
+				nPairs,
+				rngSeed
+			}).pairs
+		},
+		{
+			id: "crest",
+			weight: 1,
+			isBlind: true,
+			select: (g, nPairs, rngSeed) => crest(g, {
+				nPairs,
+				rngSeed
+			}).pairs
+		},
+		{
+			id: "spine",
+			weight: .9,
+			isBlind: true,
+			select: (g, nPairs, rngSeed) => spine(g, {
+				nPairs,
+				rngSeed
+			}).pairs
+		},
+		{
+			id: "grasp",
+			weight: .8,
+			isBlind: true,
+			select: (g, nPairs, rngSeed) => {
+				const k = Math.min(24, Math.max(8, Math.round(Math.sqrt(g.nodeCount))));
+				return grasp(g, {
+					rngSeed,
+					nClusters: k,
+					pairsPerCluster: Math.max(2, Math.ceil(nPairs / Math.max(1, k))),
+					sampleSize: Math.min(2e4, Math.max(2e3, g.nodeCount * 20))
+				}).pairs;
+			}
+		},
+		{
+			id: "degree_diverse",
+			weight: .7,
+			isBlind: true,
+			select: degreeDiversePairs
+		},
+		{
+			id: "crisp",
+			weight: .85,
+			isBlind: false,
+			select: (g, nPairs, rngSeed) => crisp(g, {
+				nPairs,
+				rngSeed
+			}).pairs
+		},
+		{
+			id: "max_distance",
+			weight: .9,
+			isBlind: false,
+			select: maxDistancePairs
+		},
+		{
+			id: "community_bridge",
+			weight: .9,
+			isBlind: false,
+			select: communityBridgePairs
+		}
+	], {
+		nPairs: config.nPairs,
+		rngSeed: config.rngSeed,
+		blindPriorityBias: config.blindPriorityBias
+	}) };
+}
+//#endregion
+//#region src/seeds/prism.ts
+var DEFAULTS$1 = {
+	nPairs: 100,
+	rngSeed: 42,
+	blindPriorityBias: .1
+};
+function prism(graph, options = {}) {
+	const config = {
+		...DEFAULTS$1,
+		...options
+	};
+	return { pairs: runEnsemble(graph, [
+		{
+			id: "stride",
+			weight: 1,
+			isBlind: true,
+			select: (g, nPairs, rngSeed) => stride(g, {
+				nPairs,
+				rngSeed
+			}).pairs
+		},
+		{
+			id: "crest",
+			weight: 1,
+			isBlind: true,
+			select: (g, nPairs, rngSeed) => crest(g, {
+				nPairs,
+				rngSeed
+			}).pairs
+		},
+		{
+			id: "spine",
+			weight: .9,
+			isBlind: true,
+			select: (g, nPairs, rngSeed) => spine(g, {
+				nPairs,
+				rngSeed
+			}).pairs
+		},
+		{
+			id: "grasp",
+			weight: .8,
+			isBlind: true,
+			select: (g, nPairs, rngSeed) => {
+				const k = Math.min(24, Math.max(8, Math.round(Math.sqrt(g.nodeCount))));
+				return grasp(g, {
+					rngSeed,
+					nClusters: k,
+					pairsPerCluster: Math.max(2, Math.ceil(nPairs / Math.max(1, k))),
+					sampleSize: Math.min(2e4, Math.max(2e3, g.nodeCount * 20))
+				}).pairs;
+			}
+		},
+		{
+			id: "degree_diverse",
+			weight: .7,
+			isBlind: true,
+			select: degreeDiversePairs
+		},
+		{
+			id: "max_distance_proxy",
+			weight: .7,
+			isBlind: false,
+			select: maxDistancePairs
+		},
+		{
+			id: "crisp",
+			weight: .8,
+			isBlind: false,
+			select: (g, nPairs, rngSeed) => crisp(g, {
+				nPairs,
+				rngSeed
+			}).pairs
+		}
+	], {
+		nPairs: config.nPairs,
+		rngSeed: config.rngSeed,
+		blindPriorityBias: config.blindPriorityBias
+	}) };
+}
+//#endregion
+//#region src/seeds/stratified.ts
+/** Default values */
+var DEFAULTS = {
+	pairsPerStratum: 10,
+	rngSeed: 42
+};
+/**
+* Simple seeded pseudo-random number generator using mulberry32.
+*/
+function createRNG(seed) {
+	let state = seed >>> 0;
+	return () => {
+		state = state + 1831565813 >>> 0;
+		let t = Math.imul(state ^ state >>> 15, state | 1);
+		t = (t ^ t >>> 7) * (t | 1640531527);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/**
+* Stratified seed selection algorithm.
+*
+* @param graph - The graph to sample seeds from
+* @param options - Configuration options including field classifier
+* @returns Stratified selection result
+*
+* @example
+* ```typescript
+* const graph = new AdjacencyMapGraph();
+* // ... populate graph ...
+*
+* const result = stratified(graph, {
+*   fieldClassifier: (node) => node.type === 'paper' ? 'computer-science' : undefined,
+*   pairsPerStratum: 20,
+* });
+*
+* for (const stratum of result.strata) {
+*   console.log(`${stratum.name}: ${stratum.pairs.length} pairs`);
+* }
+* ```
+*/
+function stratified(graph, options) {
+	const { fieldClassifier, pairsPerStratum = DEFAULTS.pairsPerStratum, rngSeed = DEFAULTS.rngSeed, customStrata } = options;
+	const rng = createRNG(rngSeed);
+	const strataDefinitions = customStrata ?? [];
+	const nodesWithFields = [];
+	for (const nodeId of graph.nodeIds()) {
+		const node = graph.getNode(nodeId);
+		if (node === void 0) continue;
+		const field = fieldClassifier(node.type !== void 0 ? {
+			id: nodeId,
+			type: node.type
+		} : { id: nodeId });
+		if (field === void 0) continue;
+		const nodeWithField = node.type !== void 0 ? {
+			id: nodeId,
+			type: node.type,
+			field
+		} : {
+			id: nodeId,
+			field
+		};
+		nodesWithFields.push(nodeWithField);
+	}
+	const errors = [];
+	const strataResults = [];
+	for (const stratum of strataDefinitions) {
+		const pairs = [];
+		const eligiblePairs = [];
+		for (let i = 0; i < nodesWithFields.length; i++) {
+			const source = nodesWithFields[i];
+			if (source === void 0) continue;
+			for (let j = i + 1; j < nodesWithFields.length; j++) {
+				if (j === i) continue;
+				const target = nodesWithFields[j];
+				if (target === void 0) continue;
+				if (stratum.predicate(source, target)) eligiblePairs.push({
+					source,
+					target
+				});
+			}
+		}
+		const numToSample = Math.min(pairsPerStratum, eligiblePairs.length);
+		for (let i = 0; i < numToSample; i++) {
+			const pair = eligiblePairs[Math.floor(rng() * eligiblePairs.length)];
+			if (pair === void 0) continue;
+			const sourceField = fieldClassifier(pair.source);
+			const targetField = fieldClassifier(pair.target);
+			pairs.push({
+				source: { id: pair.source.id },
+				target: { id: pair.target.id },
+				stratum: stratum.name,
+				sameField: sourceField === targetField
+			});
+		}
+		strataResults.push({
+			name: stratum.name,
+			pairs
+		});
+	}
+	for (const stratum of strataDefinitions) {
+		const result = strataResults.find((r) => r.name === stratum.name);
+		if (result === void 0 || result.pairs.length === 0) errors.push(/* @__PURE__ */ new Error(`No pairs found for stratum: ${stratum.name}`));
+	}
+	return {
+		strata: strataResults,
+		totalPairs: strataResults.reduce((sum, r) => sum + r.pairs.length, 0),
+		errors
+	};
+}
+//#endregion
+Object.defineProperty(exports, "basil", {
+	enumerable: true,
+	get: function() {
+		return basil;
+	}
+});
+Object.defineProperty(exports, "brisk", {
+	enumerable: true,
+	get: function() {
+		return brisk;
+	}
+});
+Object.defineProperty(exports, "crest", {
+	enumerable: true,
+	get: function() {
+		return crest;
+	}
+});
+Object.defineProperty(exports, "crisp", {
+	enumerable: true,
+	get: function() {
+		return crisp;
+	}
+});
+Object.defineProperty(exports, "grasp", {
+	enumerable: true,
+	get: function() {
+		return grasp;
+	}
+});
+Object.defineProperty(exports, "omnia", {
+	enumerable: true,
+	get: function() {
+		return omnia;
+	}
+});
+Object.defineProperty(exports, "prism", {
+	enumerable: true,
+	get: function() {
+		return prism;
+	}
+});
+Object.defineProperty(exports, "spine", {
+	enumerable: true,
+	get: function() {
+		return spine;
+	}
+});
+Object.defineProperty(exports, "stratified", {
+	enumerable: true,
+	get: function() {
+		return stratified;
+	}
+});
+Object.defineProperty(exports, "stride", {
+	enumerable: true,
+	get: function() {
+		return stride;
+	}
+});
+
+//# sourceMappingURL=seeds--fLhoBaG.cjs.map