graphwise 1.0.0 → 1.1.0

package/dist/seeds/grasp.d.ts

@@ -0,0 +1,79 @@
+import { ReadableGraph } from '../graph';
+import { Seed } from '../schemas/index';
+import { LabelledFeature } from '../utils/kmeans';
+/**
+ * Configuration options for GRASP seed selection.
+ */
+export interface GraspOptions {
+    /** Number of clusters for K-means (default: 100) */
+    readonly nClusters?: number;
+    /** Number of pairs to sample per cluster (default: 10) */
+    readonly pairsPerCluster?: number;
+    /** Ratio of within-cluster pairs vs cross-cluster pairs (default: 0.5) */
+    readonly withinClusterRatio?: number;
+    /** Reservoir sample size (default: 200000) */
+    readonly sampleSize?: number;
+    /** Random seed for reproducibility (default: 42) */
+    readonly rngSeed?: number;
+    /** Number of PageRank iterations for feature computation (default: 10) */
+    readonly pagerankIterations?: number;
+}
+/**
+ * A sampled seed pair with structural metadata.
+ */
+export interface GraspSeedPair {
+    /** Source seed */
+    readonly source: Seed;
+    /** Target seed */
+    readonly target: Seed;
+    /** Euclidean distance in feature space */
+    readonly featureDistance: number;
+    /** Whether both seeds are from the same cluster */
+    readonly sameCluster: boolean;
+    /** Cluster index of source (or -1 if unclustered) */
+    readonly sourceCluster: number;
+    /** Cluster index of target (or -1 if unclustered) */
+    readonly targetCluster: number;
+}
+/**
+ * Result of GRASP seed selection.
+ */
+export interface GraspResult {
+    /** Sampled seed pairs */
+    readonly pairs: readonly GraspSeedPair[];
+    /** Number of clusters used */
+    readonly nClusters: number;
+    /** Total nodes sampled */
+    readonly sampledNodeCount: number;
+    /** Features computed for sampled nodes */
+    readonly features: readonly LabelledFeature[];
+    /** Cluster assignments (nodeId -> cluster index) */
+    readonly clusterAssignments: ReadonlyMap<string, number>;
+}
+/**
+ * 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`);
+ * ```
+ */
+export declare function grasp(graph: ReadableGraph, options?: GraspOptions): GraspResult;
+//# sourceMappingURL=grasp.d.ts.map

package/dist/seeds/grasp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grasp.d.ts","sourceRoot":"","sources":["../../src/seeds/grasp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAU,MAAM,UAAU,CAAC;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAGN,KAAK,eAAe,EAEpB,MAAM,iBAAiB,CAAC;AAEzB;;GAEG;AACH,MAAM,WAAW,YAAY;IAC5B,oDAAoD;IACpD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,0DAA0D;IAC1D,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,0EAA0E;IAC1E,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,8CAA8C;IAC9C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,oDAAoD;IACpD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,0EAA0E;IAC1E,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,kBAAkB;IAClB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,kBAAkB;IAClB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,0CAA0C;IAC1C,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,mDAAmD;IACnD,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,qDAAqD;IACrD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,qDAAqD;IACrD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,yBAAyB;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IACzC,8BAA8B;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,0BAA0B;IAC1B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;IAC9C,oDAAoD;IACpD,QAAQ,CAAC,kBAAkB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzD;AA6UD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,KAAK,CACpB,KAAK,EAAE,aAAa,EACpB,OAAO,GAAE,YAAiB,GACxB,WAAW,CAuDb"}

package/dist/seeds/grasp.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=grasp.unit.test.d.ts.map

package/dist/seeds/grasp.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grasp.unit.test.d.ts","sourceRoot":"","sources":["../../src/seeds/grasp.unit.test.ts"],"names":[],"mappings":""}

package/dist/seeds/index.cjs

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_seeds = require("../seeds-B6J9oJfU.cjs");
+exports.grasp = require_seeds.grasp;
+exports.stratified = require_seeds.stratified;

package/dist/seeds/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Seed selection algorithms.
+ *
+ * @module seeds
+ */
+export { grasp } from './grasp';
+export type { GraspOptions, GraspResult, GraspSeedPair } from './grasp';
+export { stratified } from './stratified';
+export type { StratifiedOptions, StratifiedResult, StratumResult, StratumDefinition, SeedPair, FieldClassifier, } from './stratified';
+//# sourceMappingURL=index.d.ts.map

package/dist/seeds/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/seeds/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,YAAY,EACX,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,QAAQ,EACR,eAAe,GACf,MAAM,cAAc,CAAC"}

package/dist/seeds/index.js

@@ -0,0 +1,2 @@
+import { n as grasp, t as stratified } from "../seeds-UNZxqm_U.js";
+export { grasp, stratified };

package/dist/seeds/stratified.d.ts

@@ -0,0 +1,85 @@
+import { ReadableGraph, NodeId } from '../graph/index';
+import { Seed } from '../schemas/index';
+/**
+ * Field classification function type.
+ * User provides a function that returns the field name for a node.
+ */
+export type FieldClassifier = (node: {
+    id: NodeId;
+    type?: string;
+}) => string | undefined;
+/**
+ * Stratum definition for seed pair selection.
+ */
+export interface StratumDefinition {
+    readonly name: string;
+    readonly description: string;
+    readonly predicate: (source: {
+        id: NodeId;
+        type?: string;
+    }, target: {
+        id: NodeId;
+        type?: string;
+    }) => boolean;
+}
+/**
+ * Stratum with sampled seed pairs.
+ */
+export interface StratumResult {
+    readonly name: string;
+    readonly pairs: readonly SeedPair[];
+}
+/**
+ * A seed pair with stratum metadata.
+ */
+export interface SeedPair {
+    readonly source: Seed;
+    readonly target: Seed;
+    readonly stratum: string;
+    readonly sameField: boolean;
+}
+/**
+ * Result of stratified seed selection.
+ */
+export interface StratifiedResult {
+    readonly strata: readonly StratumResult[];
+    readonly totalPairs: number;
+    readonly errors: readonly Error[];
+}
+/**
+ * Configuration for stratified seed selection.
+ */
+export interface StratifiedOptions {
+    /** Function to classify nodes by field */
+    readonly fieldClassifier: FieldClassifier;
+    /** Number of pairs to sample per stratum */
+    readonly pairsPerStratum?: number;
+    /** Random seed for reproducibility */
+    readonly rngSeed?: number;
+    /** Custom stratum definitions */
+    readonly customStrata?: readonly StratumDefinition[];
+}
+/**
+ * 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`);
+ * }
+ * ```
+ */
+export declare function stratified(graph: ReadableGraph, options: StratifiedOptions): StratifiedResult;
+//# sourceMappingURL=stratified.d.ts.map

package/dist/seeds/stratified.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stratified.d.ts","sourceRoot":"","sources":["../../src/seeds/stratified.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE7C;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;CACd,KAAK,MAAM,GAAG,SAAS,CAAC;AAEzB;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,CACnB,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,EACrC,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KACjC,OAAO,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACxB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,0CAA0C;IAC1C,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAC1C,4CAA4C;IAC5C,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,sCAAsC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,iCAAiC;IACjC,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACrD;AAqBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CACzB,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,iBAAiB,GACxB,gBAAgB,CA0FlB"}

package/dist/seeds/stratified.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stratified.unit.test.d.ts.map

package/dist/seeds/stratified.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stratified.unit.test.d.ts","sourceRoot":"","sources":["../../src/seeds/stratified.unit.test.ts"],"names":[],"mappings":""}

package/dist/seeds-B6J9oJfU.cjs

@@ -0,0 +1,404 @@
+const require_kmeans = require("./kmeans-B0HEOU6k.cjs");
+//#region src/seeds/grasp.ts
+/** Default configuration values */
+var DEFAULTS$1 = {
+	nClusters: 100,
+	pairsPerCluster: 10,
+	withinClusterRatio: .5,
+	sampleSize: 2e5,
+	rngSeed: 42,
+	pagerankIterations: 10
+};
+/**
+* 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;
+	};
+}
+/**
+* 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$1,
+		...options
+	};
+	const rng = createRNG$1(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/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({
+			id: nodeId,
+			type: node.type
+		});
+		if (field === void 0) continue;
+		nodesWithFields.push({
+			id: nodeId,
+			type: node.type,
+			field
+		});
+	}
+	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, "grasp", {
+	enumerable: true,
+	get: function() {
+		return grasp;
+	}
+});
+Object.defineProperty(exports, "stratified", {
+	enumerable: true,
+	get: function() {
+		return stratified;
+	}
+});
+
+//# sourceMappingURL=seeds-B6J9oJfU.cjs.map