graphwise 1.10.0 → 1.11.0

package/dist/seeds/index.cjs

@@ -1,8 +1,343 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_kmeans = require("../kmeans-CZ7tJFYw.cjs");
+//#region src/seeds/crisp.ts
+/** Default configuration values */
+var DEFAULTS$5 = {
+	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$3(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$5,
+		...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$3(aNbrs, paNbrs) >= config.diversityThreshold && jaccard$3(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/crest.ts
+/** Default configuration values */
+var DEFAULTS$4 = {
+	nPairs: 100,
+	rngSeed: 42,
+	diversityThreshold: .5,
+	sampleSize: 5e3
+};
+/**
+* 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;
+	};
+}
+/**
+* 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$2(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$4,
+		...options
+	};
+	const rng = createRNG$4(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$2(aNbrs, new Set(graph.neighbours(prev.source.id))) >= config.diversityThreshold) {
+			if (jaccard$2(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/grasp.ts
 /** Default configuration values */
-var DEFAULTS$1 = {
+var DEFAULTS$3 = {
 	nClusters: 100,
 	pairsPerCluster: 10,
 	withinClusterRatio: .5,
@@ -13,7 +348,7 @@ var DEFAULTS$1 = {
 /**
 * Simple seeded pseudo-random number generator using mulberry32.
 */
-function createRNG$1(seed) {
+function createRNG$3(seed) {
 	let state = seed >>> 0;
 	return () => {
 		state = state + 1831565813 >>> 0;
@@ -261,10 +596,10 @@ function computeFeatureDistance(a, b) {
 */
 function grasp(graph, options = {}) {
 	const config = {
-		...DEFAULTS$1,
+		...DEFAULTS$3,
 		...options
 	};
-	const rng = createRNG$1(config.rngSeed);
+	const rng = createRNG$3(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);
@@ -283,6 +618,377 @@ function grasp(graph, options = {}) {
 	};
 }
 //#endregion
+//#region src/seeds/spine.ts
+/** Default configuration values */
+var DEFAULTS$2 = {
+	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$2,
+		...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$1 = {
+	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$1,
+		...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/stratified.ts
 /** Default values */
 var DEFAULTS = {
@@ -393,7 +1099,11 @@ function stratified(graph, options) {
 	};
 }
 //#endregion
+exports.crest = crest;
+exports.crisp = crisp;
 exports.grasp = grasp;
+exports.spine = spine;
 exports.stratified = stratified;
+exports.stride = stride;
 
 //# sourceMappingURL=index.cjs.map