graphwise 1.0.0 → 1.1.0

package/dist/kmeans-DgbsOznU.js

@@ -0,0 +1,223 @@
+//#region src/utils/kmeans.ts
+/** Small epsilon to prevent division by zero */
+var EPSILON = 1e-10;
+/**
+* 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;
+	};
+}
+/**
+* Compute Euclidean distance between two 3D feature vectors.
+*/
+function euclideanDistance(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);
+}
+function normaliseFeatures(features) {
+	if (features.length === 0) return [];
+	let sum1 = 0;
+	let sum2 = 0;
+	let sum3 = 0;
+	for (const f of features) {
+		sum1 += f.f1;
+		sum2 += f.f2;
+		sum3 += f.f3;
+	}
+	const n = features.length;
+	const mean1 = sum1 / n;
+	const mean2 = sum2 / n;
+	const mean3 = sum3 / n;
+	let var1 = 0;
+	let var2 = 0;
+	let var3 = 0;
+	for (const f of features) {
+		var1 += (f.f1 - mean1) ** 2;
+		var2 += (f.f2 - mean2) ** 2;
+		var3 += (f.f3 - mean3) ** 2;
+	}
+	const std1 = Math.sqrt(var1 / n + EPSILON);
+	const std2 = Math.sqrt(var2 / n + EPSILON);
+	const std3 = Math.sqrt(var3 / n + EPSILON);
+	return features.map((f) => ({
+		nodeId: f.nodeId,
+		f1: (f.f1 - mean1) / std1,
+		f2: (f.f2 - mean2) / std2,
+		f3: (f.f3 - mean3) / std3
+	}));
+}
+/**
+* Mini-batch K-means clustering for 3D feature vectors.
+*
+* Uses Mini-batch K-means for efficiency with large datasets.
+* This is specifically designed for the GRASP seed selection algorithm.
+*
+* @param features - Array of labelled feature vectors
+* @param options - Clustering options
+* @returns Clustering result with centroids and assignments
+*/
+function miniBatchKMeans(features, options) {
+	const { k, maxIterations = 100, tolerance = 1e-6, seed = 42 } = options;
+	if (features.length === 0) return {
+		centroids: [],
+		assignments: /* @__PURE__ */ new Map(),
+		k
+	};
+	const rng = createRNG(seed);
+	const n = features.length;
+	const effectiveK = Math.min(k, n);
+	const centroids = initialiseCentroidsKMeansPP(features, effectiveK, rng);
+	const assignments = /* @__PURE__ */ new Map();
+	const batchSize = Math.max(10, Math.floor(n / 10));
+	for (let iter = 0; iter < maxIterations; iter++) {
+		const batchIndices = /* @__PURE__ */ new Set();
+		while (batchIndices.size < Math.min(batchSize, n)) batchIndices.add(Math.floor(rng() * n));
+		const batchPoints = [];
+		for (const idx of batchIndices) {
+			const feature = features[idx];
+			if (feature === void 0) continue;
+			let minDist = Infinity;
+			let bestCluster = 0;
+			for (let c = 0; c < centroids.length; c++) {
+				const centroid = centroids[c];
+				if (centroid === void 0) continue;
+				const dist = euclideanDistance(feature, centroid);
+				if (dist < minDist) {
+					minDist = dist;
+					bestCluster = c;
+				}
+			}
+			batchPoints.push({
+				feature,
+				cluster: bestCluster
+			});
+		}
+		const oldCentroids = centroids.map((c) => ({ ...c }));
+		const clusterCounts = Array.from({ length: centroids.length }, () => 0);
+		const clusterSums = Array.from({ length: centroids.length }, () => [
+			0,
+			0,
+			0
+		]);
+		for (const { feature, cluster } of batchPoints) {
+			const currentCount = clusterCounts[cluster];
+			if (currentCount !== void 0) clusterCounts[cluster] = currentCount + 1;
+			const sum = clusterSums[cluster];
+			if (sum !== void 0) {
+				sum[0] += feature.f1;
+				sum[1] += feature.f2;
+				sum[2] += feature.f3;
+			}
+		}
+		for (let c = 0; c < centroids.length; c++) {
+			const count = clusterCounts[c] ?? 0;
+			if (count > 0) {
+				const sum = clusterSums[c];
+				if (sum !== void 0) centroids[c] = {
+					f1: sum[0] / count,
+					f2: sum[1] / count,
+					f3: sum[2] / count
+				};
+			}
+		}
+		let maxShift = 0;
+		for (let c = 0; c < centroids.length; c++) {
+			const newCentroid = centroids[c];
+			const oldCentroid = oldCentroids[c];
+			if (newCentroid !== void 0 && oldCentroid !== void 0) {
+				const shift = euclideanDistance(newCentroid, oldCentroid);
+				maxShift = Math.max(maxShift, shift);
+			}
+		}
+		if (maxShift < tolerance) break;
+	}
+	for (const feature of features) {
+		let minDist = Infinity;
+		let bestCluster = 0;
+		for (let c = 0; c < centroids.length; c++) {
+			const centroid = centroids[c];
+			if (centroid === void 0) continue;
+			const dist = euclideanDistance(feature, centroid);
+			if (dist < minDist) {
+				minDist = dist;
+				bestCluster = c;
+			}
+		}
+		assignments.set(feature.nodeId, bestCluster);
+	}
+	return {
+		centroids,
+		assignments,
+		k: effectiveK
+	};
+}
+/**
+* K-means++ initialisation for better centroid seeding.
+*/
+function initialiseCentroidsKMeansPP(features, k, rng) {
+	const centroids = [];
+	const n = features.length;
+	const firstFeature = features[Math.floor(rng() * n)];
+	if (firstFeature === void 0) return [{
+		f1: 0,
+		f2: 0,
+		f3: 0
+	}];
+	centroids.push({
+		f1: firstFeature.f1,
+		f2: firstFeature.f2,
+		f3: firstFeature.f3
+	});
+	const distances = Array.from({ length: n }, () => Infinity);
+	for (let c = 1; c < k; c++) {
+		let totalDistSq = 0;
+		for (let i = 0; i < n; i++) {
+			const feature = features[i];
+			if (feature === void 0) continue;
+			const lastCentroid = centroids[c - 1];
+			if (lastCentroid === void 0) continue;
+			const dist = euclideanDistance(feature, lastCentroid);
+			const currentMin = distances[i];
+			if (currentMin !== void 0 && dist < currentMin) distances[i] = dist;
+			const d = distances[i];
+			if (d !== void 0) totalDistSq += d * d;
+		}
+		const threshold = rng() * totalDistSq;
+		let cumulative = 0;
+		let nextIdx = 0;
+		for (let i = 0; i < n; i++) {
+			const d = distances[i];
+			if (d !== void 0) {
+				cumulative += d * d;
+				if (cumulative >= threshold) {
+					nextIdx = i;
+					break;
+				}
+			}
+		}
+		const nextFeature = features[nextIdx];
+		if (nextFeature !== void 0) centroids.push({
+			f1: nextFeature.f1,
+			f2: nextFeature.f2,
+			f3: nextFeature.f3
+		});
+		else centroids.push({
+			f1: 0,
+			f2: 0,
+			f3: 0
+		});
+	}
+	return centroids;
+}
+//#endregion
+export { normaliseFeatures as n, miniBatchKMeans as t };
+
+//# sourceMappingURL=kmeans-DgbsOznU.js.map

package/dist/kmeans-DgbsOznU.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kmeans-DgbsOznU.js","names":[],"sources":["../src/utils/kmeans.ts"],"sourcesContent":["/**\n * Minimal K-means clustering implementation for GRASP seed selection.\n *\n * This is a lightweight implementation specifically designed for 3D feature vectors\n * used in structural seed selection. For general-purpose clustering, consider\n * using a dedicated library.\n *\n * @packageDocumentation\n */\n\n/**\n * A 3D feature vector representing node structural properties.\n */\nexport interface FeatureVector3D {\n\t/** First dimension (e.g., log-degree) */\n\treadonly f1: number;\n\t/** Second dimension (e.g., clustering coefficient) */\n\treadonly f2: number;\n\t/** Third dimension (e.g., approximate PageRank) */\n\treadonly f3: number;\n}\n\n/**\n * A labelled feature vector with associated node ID.\n */\nexport interface LabelledFeature extends FeatureVector3D {\n\t/** Node identifier */\n\treadonly nodeId: string;\n}\n\n/**\n * Result of K-means clustering.\n */\nexport interface KMeansResult {\n\t/** Cluster centroids */\n\treadonly centroids: readonly FeatureVector3D[];\n\t/** Cluster assignments: nodeId -> cluster index */\n\treadonly assignments: ReadonlyMap<string, number>;\n\t/** Number of clusters */\n\treadonly k: number;\n}\n\n/**\n * Options for K-means clustering.\n */\nexport interface KMeansOptions {\n\t/** Number of clusters */\n\treadonly k: number;\n\t/** Maximum iterations (default: 100) */\n\treadonly maxIterations?: number;\n\t/** Convergence threshold (default: 1e-6) */\n\treadonly tolerance?: number;\n\t/** Random seed for reproducibility */\n\treadonly seed?: number;\n}\n\n/** Small epsilon to prevent division by zero */\nconst EPSILON = 1e-10;\n\n/**\n * Simple seeded pseudo-random number generator using mulberry32.\n */\nfunction createRNG(seed: number): () => number {\n\tlet state = seed >>> 0;\n\treturn (): number => {\n\t\tstate = (state + 0x6d2b79f5) >>> 0;\n\t\tlet t = Math.imul(state ^ (state >>> 15), state | 1);\n\t\tt = (t ^ (t >>> 7)) * (t | 0x61c88647);\n\t\treturn ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n\t};\n}\n\n/**\n * Compute Euclidean distance between two 3D feature vectors.\n */\nfunction euclideanDistance(a: FeatureVector3D, b: FeatureVector3D): number {\n\tconst d1 = a.f1 - b.f1;\n\tconst d2 = a.f2 - b.f2;\n\tconst d3 = a.f3 - b.f3;\n\treturn Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3);\n}\n\n/**\n * Compute the mean of a set of feature vectors.\n * @internal - Used for testing\n */\nexport function _computeMean(\n\tvectors: readonly FeatureVector3D[],\n): FeatureVector3D {\n\tif (vectors.length === 0) {\n\t\treturn { f1: 0, f2: 0, f3: 0 };\n\t}\n\tlet sum1 = 0;\n\tlet sum2 = 0;\n\tlet sum3 = 0;\n\tfor (const v of vectors) {\n\t\tsum1 += v.f1;\n\t\tsum2 += v.f2;\n\t\tsum3 += v.f3;\n\t}\n\tconst n = vectors.length;\n\treturn { f1: sum1 / n, f2: sum2 / n, f3: sum3 / n };\n}\n\n/**\n * Z-score normalise features (zero mean, unit variance).\n */\nexport { normaliseFeatures as zScoreNormalise };\n\nexport function normaliseFeatures(\n\tfeatures: readonly LabelledFeature[],\n): LabelledFeature[] {\n\tif (features.length === 0) {\n\t\treturn [];\n\t}\n\n\t// Compute means\n\tlet sum1 = 0;\n\tlet sum2 = 0;\n\tlet sum3 = 0;\n\tfor (const f of features) {\n\t\tsum1 += f.f1;\n\t\tsum2 += f.f2;\n\t\tsum3 += f.f3;\n\t}\n\tconst n = features.length;\n\tconst mean1 = sum1 / n;\n\tconst mean2 = sum2 / n;\n\tconst mean3 = sum3 / n;\n\n\t// Compute standard deviations\n\tlet var1 = 0;\n\tlet var2 = 0;\n\tlet var3 = 0;\n\tfor (const f of features) {\n\t\tvar1 += (f.f1 - mean1) ** 2;\n\t\tvar2 += (f.f2 - mean2) ** 2;\n\t\tvar3 += (f.f3 - mean3) ** 2;\n\t}\n\tconst std1 = Math.sqrt(var1 / n + EPSILON);\n\tconst std2 = Math.sqrt(var2 / n + EPSILON);\n\tconst std3 = Math.sqrt(var3 / n + EPSILON);\n\n\t// Normalise\n\treturn features.map(\n\t\t(f): LabelledFeature => ({\n\t\t\tnodeId: f.nodeId,\n\t\t\tf1: (f.f1 - mean1) / std1,\n\t\t\tf2: (f.f2 - mean2) / std2,\n\t\t\tf3: (f.f3 - mean3) / std3,\n\t\t}),\n\t);\n}\n\n/**\n * Mini-batch K-means clustering for 3D feature vectors.\n *\n * Uses Mini-batch K-means for efficiency with large datasets.\n * This is specifically designed for the GRASP seed selection algorithm.\n *\n * @param features - Array of labelled feature vectors\n * @param options - Clustering options\n * @returns Clustering result with centroids and assignments\n */\nexport function miniBatchKMeans(\n\tfeatures: readonly LabelledFeature[],\n\toptions: KMeansOptions,\n): KMeansResult {\n\tconst { k, maxIterations = 100, tolerance = 1e-6, seed = 42 } = options;\n\n\tif (features.length === 0) {\n\t\treturn {\n\t\t\tcentroids: [],\n\t\t\tassignments: new Map(),\n\t\t\tk,\n\t\t};\n\t}\n\n\tconst rng = createRNG(seed);\n\tconst n = features.length;\n\tconst effectiveK = Math.min(k, n);\n\n\t// Initialise centroids using k-means++ seeding\n\tconst centroids: FeatureVector3D[] = initialiseCentroidsKMeansPP(\n\t\tfeatures,\n\t\teffectiveK,\n\t\trng,\n\t);\n\n\t// Assignments map\n\tconst assignments = new Map<string, number>();\n\n\t// Mini-batch size (10% of data or at least 10)\n\tconst batchSize = Math.max(10, Math.floor(n / 10));\n\n\tfor (let iter = 0; iter < maxIterations; iter++) {\n\t\t// Sample mini-batch\n\t\tconst batchIndices = new Set<number>();\n\t\twhile (batchIndices.size < Math.min(batchSize, n)) {\n\t\t\tbatchIndices.add(Math.floor(rng() * n));\n\t\t}\n\n\t\t// Assign batch points to nearest centroid\n\t\tconst batchPoints: { feature: LabelledFeature; cluster: number }[] = [];\n\t\tfor (const idx of batchIndices) {\n\t\t\tconst feature = features[idx];\n\t\t\tif (feature === undefined) continue;\n\t\t\tlet minDist = Infinity;\n\t\t\tlet bestCluster = 0;\n\t\t\tfor (let c = 0; c < centroids.length; c++) {\n\t\t\t\tconst centroid = centroids[c];\n\t\t\t\tif (centroid === undefined) continue;\n\t\t\t\tconst dist = euclideanDistance(feature, centroid);\n\t\t\t\tif (dist < minDist) {\n\t\t\t\t\tminDist = dist;\n\t\t\t\t\tbestCluster = c;\n\t\t\t\t}\n\t\t\t}\n\t\t\tbatchPoints.push({ feature, cluster: bestCluster });\n\t\t}\n\n\t\t// Update centroids based on batch\n\t\tconst oldCentroids = centroids.map((c) => ({ ...c }));\n\n\t\t// Compute per-cluster counts and sums from batch\n\t\tconst clusterCounts = Array.from({ length: centroids.length }, () => 0);\n\t\tconst clusterSums: [number, number, number][] = Array.from(\n\t\t\t{ length: centroids.length },\n\t\t\t(): [number, number, number] => [0, 0, 0],\n\t\t);\n\n\t\tfor (const { feature, cluster } of batchPoints) {\n\t\t\tconst currentCount = clusterCounts[cluster];\n\t\t\tif (currentCount !== undefined) {\n\t\t\t\tclusterCounts[cluster] = currentCount + 1;\n\t\t\t}\n\t\t\tconst sum = clusterSums[cluster];\n\t\t\tif (sum !== undefined) {\n\t\t\t\tsum[0] += feature.f1;\n\t\t\t\tsum[1] += feature.f2;\n\t\t\t\tsum[2] += feature.f3;\n\t\t\t}\n\t\t}\n\n\t\t// Update centroids\n\t\tfor (let c = 0; c < centroids.length; c++) {\n\t\t\tconst count = clusterCounts[c] ?? 0;\n\t\t\tif (count > 0) {\n\t\t\t\tconst sum = clusterSums[c];\n\t\t\t\tif (sum !== undefined) {\n\t\t\t\t\tcentroids[c] = {\n\t\t\t\t\t\tf1: sum[0] / count,\n\t\t\t\t\t\tf2: sum[1] / count,\n\t\t\t\t\t\tf3: sum[2] / count,\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Check convergence\n\t\tlet maxShift = 0;\n\t\tfor (let c = 0; c < centroids.length; c++) {\n\t\t\tconst newCentroid = centroids[c];\n\t\t\tconst oldCentroid = oldCentroids[c];\n\t\t\tif (newCentroid !== undefined && oldCentroid !== undefined) {\n\t\t\t\tconst shift = euclideanDistance(newCentroid, oldCentroid);\n\t\t\t\tmaxShift = Math.max(maxShift, shift);\n\t\t\t}\n\t\t}\n\n\t\tif (maxShift < tolerance) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t// Final assignment of all points\n\tfor (const feature of features) {\n\t\tlet minDist = Infinity;\n\t\tlet bestCluster = 0;\n\t\tfor (let c = 0; c < centroids.length; c++) {\n\t\t\tconst centroid = centroids[c];\n\t\t\tif (centroid === undefined) continue;\n\t\t\tconst dist = euclideanDistance(feature, centroid);\n\t\t\tif (dist < minDist) {\n\t\t\t\tminDist = dist;\n\t\t\t\tbestCluster = c;\n\t\t\t}\n\t\t}\n\t\tassignments.set(feature.nodeId, bestCluster);\n\t}\n\n\treturn {\n\t\tcentroids,\n\t\tassignments,\n\t\tk: effectiveK,\n\t};\n}\n\n/**\n * K-means++ initialisation for better centroid seeding.\n */\nfunction initialiseCentroidsKMeansPP(\n\tfeatures: readonly LabelledFeature[],\n\tk: number,\n\trng: () => number,\n): FeatureVector3D[] {\n\tconst centroids: FeatureVector3D[] = [];\n\tconst n = features.length;\n\n\t// Choose first centroid randomly\n\tconst firstIdx = Math.floor(rng() * n);\n\tconst firstFeature = features[firstIdx];\n\tif (firstFeature === undefined) {\n\t\treturn [{ f1: 0, f2: 0, f3: 0 }];\n\t}\n\tcentroids.push({\n\t\tf1: firstFeature.f1,\n\t\tf2: firstFeature.f2,\n\t\tf3: firstFeature.f3,\n\t});\n\n\t// Choose remaining centroids with probability proportional to squared distance\n\tconst distances = Array.from({ length: n }, () => Infinity);\n\n\tfor (let c = 1; c < k; c++) {\n\t\t// Update distances to nearest centroid\n\t\tlet totalDistSq = 0;\n\t\tfor (let i = 0; i < n; i++) {\n\t\t\tconst feature = features[i];\n\t\t\tif (feature === undefined) continue;\n\t\t\tconst lastCentroid = centroids[c - 1];\n\t\t\tif (lastCentroid === undefined) continue;\n\t\t\tconst dist = euclideanDistance(feature, lastCentroid);\n\t\t\tconst currentMin = distances[i];\n\t\t\tif (currentMin !== undefined && dist < currentMin) {\n\t\t\t\tdistances[i] = dist;\n\t\t\t}\n\t\t\tconst d = distances[i];\n\t\t\tif (d !== undefined) {\n\t\t\t\ttotalDistSq += d * d;\n\t\t\t}\n\t\t}\n\n\t\t// Choose next centroid with probability proportional to squared distance\n\t\tconst threshold = rng() * totalDistSq;\n\t\tlet cumulative = 0;\n\t\tlet nextIdx = 0;\n\t\tfor (let i = 0; i < n; i++) {\n\t\t\tconst d = distances[i];\n\t\t\tif (d !== undefined) {\n\t\t\t\tcumulative += d * d;\n\t\t\t\tif (cumulative >= threshold) {\n\t\t\t\t\tnextIdx = i;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tconst nextFeature = features[nextIdx];\n\t\tif (nextFeature !== undefined) {\n\t\t\tcentroids.push({\n\t\t\t\tf1: nextFeature.f1,\n\t\t\t\tf2: nextFeature.f2,\n\t\t\t\tf3: nextFeature.f3,\n\t\t\t});\n\t\t} else {\n\t\t\t// Fallback: use zero centroid\n\t\t\tcentroids.push({ f1: 0, f2: 0, f3: 0 });\n\t\t}\n\t}\n\n\treturn centroids;\n}\n"],"mappings":";;AAyDA,IAAM,UAAU;;;;AAKhB,SAAS,UAAU,MAA4B;CAC9C,IAAI,QAAQ,SAAS;AACrB,cAAqB;AACpB,UAAS,QAAQ,eAAgB;EACjC,IAAI,IAAI,KAAK,KAAK,QAAS,UAAU,IAAK,QAAQ,EAAE;AACpD,OAAK,IAAK,MAAM,MAAO,IAAI;AAC3B,WAAS,IAAK,MAAM,QAAS,KAAK;;;;;;AAOpC,SAAS,kBAAkB,GAAoB,GAA4B;CAC1E,MAAM,KAAK,EAAE,KAAK,EAAE;CACpB,MAAM,KAAK,EAAE,KAAK,EAAE;CACpB,MAAM,KAAK,EAAE,KAAK,EAAE;AACpB,QAAO,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG;;AA8B9C,SAAgB,kBACf,UACoB;AACpB,KAAI,SAAS,WAAW,EACvB,QAAO,EAAE;CAIV,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;AACX,MAAK,MAAM,KAAK,UAAU;AACzB,UAAQ,EAAE;AACV,UAAQ,EAAE;AACV,UAAQ,EAAE;;CAEX,MAAM,IAAI,SAAS;CACnB,MAAM,QAAQ,OAAO;CACrB,MAAM,QAAQ,OAAO;CACrB,MAAM,QAAQ,OAAO;CAGrB,IAAI,OAAO;CACX,IAAI,OAAO;CACX,IAAI,OAAO;AACX,MAAK,MAAM,KAAK,UAAU;AACzB,WAAS,EAAE,KAAK,UAAU;AAC1B,WAAS,EAAE,KAAK,UAAU;AAC1B,WAAS,EAAE,KAAK,UAAU;;CAE3B,MAAM,OAAO,KAAK,KAAK,OAAO,IAAI,QAAQ;CAC1C,MAAM,OAAO,KAAK,KAAK,OAAO,IAAI,QAAQ;CAC1C,MAAM,OAAO,KAAK,KAAK,OAAO,IAAI,QAAQ;AAG1C,QAAO,SAAS,KACd,OAAwB;EACxB,QAAQ,EAAE;EACV,KAAK,EAAE,KAAK,SAAS;EACrB,KAAK,EAAE,KAAK,SAAS;EACrB,KAAK,EAAE,KAAK,SAAS;EACrB,EACD;;;;;;;;;;;;AAaF,SAAgB,gBACf,UACA,SACe;CACf,MAAM,EAAE,GAAG,gBAAgB,KAAK,YAAY,MAAM,OAAO,OAAO;AAEhE,KAAI,SAAS,WAAW,EACvB,QAAO;EACN,WAAW,EAAE;EACb,6BAAa,IAAI,KAAK;EACtB;EACA;CAGF,MAAM,MAAM,UAAU,KAAK;CAC3B,MAAM,IAAI,SAAS;CACnB,MAAM,aAAa,KAAK,IAAI,GAAG,EAAE;CAGjC,MAAM,YAA+B,4BACpC,UACA,YACA,IACA;CAGD,MAAM,8BAAc,IAAI,KAAqB;CAG7C,MAAM,YAAY,KAAK,IAAI,IAAI,KAAK,MAAM,IAAI,GAAG,CAAC;AAElD,MAAK,IAAI,OAAO,GAAG,OAAO,eAAe,QAAQ;EAEhD,MAAM,+BAAe,IAAI,KAAa;AACtC,SAAO,aAAa,OAAO,KAAK,IAAI,WAAW,EAAE,CAChD,cAAa,IAAI,KAAK,MAAM,KAAK,GAAG,EAAE,CAAC;EAIxC,MAAM,cAA+D,EAAE;AACvE,OAAK,MAAM,OAAO,cAAc;GAC/B,MAAM,UAAU,SAAS;AACzB,OAAI,YAAY,KAAA,EAAW;GAC3B,IAAI,UAAU;GACd,IAAI,cAAc;AAClB,QAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;IAC1C,MAAM,WAAW,UAAU;AAC3B,QAAI,aAAa,KAAA,EAAW;IAC5B,MAAM,OAAO,kBAAkB,SAAS,SAAS;AACjD,QAAI,OAAO,SAAS;AACnB,eAAU;AACV,mBAAc;;;AAGhB,eAAY,KAAK;IAAE;IAAS,SAAS;IAAa,CAAC;;EAIpD,MAAM,eAAe,UAAU,KAAK,OAAO,EAAE,GAAG,GAAG,EAAE;EAGrD,MAAM,gBAAgB,MAAM,KAAK,EAAE,QAAQ,UAAU,QAAQ,QAAQ,EAAE;EACvE,MAAM,cAA0C,MAAM,KACrD,EAAE,QAAQ,UAAU,QAAQ,QACI;GAAC;GAAG;GAAG;GAAE,CACzC;AAED,OAAK,MAAM,EAAE,SAAS,aAAa,aAAa;GAC/C,MAAM,eAAe,cAAc;AACnC,OAAI,iBAAiB,KAAA,EACpB,eAAc,WAAW,eAAe;GAEzC,MAAM,MAAM,YAAY;AACxB,OAAI,QAAQ,KAAA,GAAW;AACtB,QAAI,MAAM,QAAQ;AAClB,QAAI,MAAM,QAAQ;AAClB,QAAI,MAAM,QAAQ;;;AAKpB,OAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;GAC1C,MAAM,QAAQ,cAAc,MAAM;AAClC,OAAI,QAAQ,GAAG;IACd,MAAM,MAAM,YAAY;AACxB,QAAI,QAAQ,KAAA,EACX,WAAU,KAAK;KACd,IAAI,IAAI,KAAK;KACb,IAAI,IAAI,KAAK;KACb,IAAI,IAAI,KAAK;KACb;;;EAMJ,IAAI,WAAW;AACf,OAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;GAC1C,MAAM,cAAc,UAAU;GAC9B,MAAM,cAAc,aAAa;AACjC,OAAI,gBAAgB,KAAA,KAAa,gBAAgB,KAAA,GAAW;IAC3D,MAAM,QAAQ,kBAAkB,aAAa,YAAY;AACzD,eAAW,KAAK,IAAI,UAAU,MAAM;;;AAItC,MAAI,WAAW,UACd;;AAKF,MAAK,MAAM,WAAW,UAAU;EAC/B,IAAI,UAAU;EACd,IAAI,cAAc;AAClB,OAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;GAC1C,MAAM,WAAW,UAAU;AAC3B,OAAI,aAAa,KAAA,EAAW;GAC5B,MAAM,OAAO,kBAAkB,SAAS,SAAS;AACjD,OAAI,OAAO,SAAS;AACnB,cAAU;AACV,kBAAc;;;AAGhB,cAAY,IAAI,QAAQ,QAAQ,YAAY;;AAG7C,QAAO;EACN;EACA;EACA,GAAG;EACH;;;;;AAMF,SAAS,4BACR,UACA,GACA,KACoB;CACpB,MAAM,YAA+B,EAAE;CACvC,MAAM,IAAI,SAAS;CAInB,MAAM,eAAe,SADJ,KAAK,MAAM,KAAK,GAAG,EAAE;AAEtC,KAAI,iBAAiB,KAAA,EACpB,QAAO,CAAC;EAAE,IAAI;EAAG,IAAI;EAAG,IAAI;EAAG,CAAC;AAEjC,WAAU,KAAK;EACd,IAAI,aAAa;EACjB,IAAI,aAAa;EACjB,IAAI,aAAa;EACjB,CAAC;CAGF,MAAM,YAAY,MAAM,KAAK,EAAE,QAAQ,GAAG,QAAQ,SAAS;AAE3D,MAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;EAE3B,IAAI,cAAc;AAClB,OAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;GAC3B,MAAM,UAAU,SAAS;AACzB,OAAI,YAAY,KAAA,EAAW;GAC3B,MAAM,eAAe,UAAU,IAAI;AACnC,OAAI,iBAAiB,KAAA,EAAW;GAChC,MAAM,OAAO,kBAAkB,SAAS,aAAa;GACrD,MAAM,aAAa,UAAU;AAC7B,OAAI,eAAe,KAAA,KAAa,OAAO,WACtC,WAAU,KAAK;GAEhB,MAAM,IAAI,UAAU;AACpB,OAAI,MAAM,KAAA,EACT,gBAAe,IAAI;;EAKrB,MAAM,YAAY,KAAK,GAAG;EAC1B,IAAI,aAAa;EACjB,IAAI,UAAU;AACd,OAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;GAC3B,MAAM,IAAI,UAAU;AACpB,OAAI,MAAM,KAAA,GAAW;AACpB,kBAAc,IAAI;AAClB,QAAI,cAAc,WAAW;AAC5B,eAAU;AACV;;;;EAKH,MAAM,cAAc,SAAS;AAC7B,MAAI,gBAAgB,KAAA,EACnB,WAAU,KAAK;GACd,IAAI,YAAY;GAChB,IAAI,YAAY;GAChB,IAAI,YAAY;GAChB,CAAC;MAGF,WAAU,KAAK;GAAE,IAAI;GAAG,IAAI;GAAG,IAAI;GAAG,CAAC;;AAIzC,QAAO"}

package/dist/ranking/baselines/shortest.d.ts

@@ -0,0 +1,15 @@
+import { NodeData, EdgeData, ReadableGraph } from '../../graph';
+import { ExpansionPath } from '../../expansion/types';
+import { BaselineConfig, BaselineResult } from './types';
+/**
+ * Rank paths by length (shortest first).
+ *
+ * Score = 1 / path_length, normalised to [0, 1].
+ *
+ * @param _graph - Source graph (unused for length ranking)
+ * @param paths - Paths to rank
+ * @param config - Configuration options
+ * @returns Ranked paths (shortest first)
+ */
+export declare function shortest<N extends NodeData, E extends EdgeData>(_graph: ReadableGraph<N, E>, paths: readonly ExpansionPath[], config?: BaselineConfig): BaselineResult;
+//# sourceMappingURL=shortest.d.ts.map

package/dist/ranking/baselines/shortest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortest.d.ts","sourceRoot":"","sources":["../../../src/ranking/baselines/shortest.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAc,MAAM,SAAS,CAAC;AAE1E;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC9D,MAAM,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC3B,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,MAAM,CAAC,EAAE,cAAc,GACrB,cAAc,CAiChB"}

package/dist/ranking/baselines/shortest.unit.test.d.ts

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

package/dist/ranking/baselines/shortest.unit.test.d.ts.map

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

package/dist/ranking/baselines/types.d.ts

@@ -0,0 +1,30 @@
+import { NodeData, EdgeData, ReadableGraph } from '../../graph';
+import { ExpansionPath } from '../../expansion/types';
+/**
+ * Configuration for baseline ranking methods.
+ */
+export interface BaselineConfig {
+    /** Whether to include scores in result */
+    readonly includeScores?: boolean;
+}
+/**
+ * A scored path from baseline ranking.
+ */
+export interface ScoredPath extends ExpansionPath {
+    /** Ranking score */
+    readonly score: number;
+}
+/**
+ * Result from baseline ranking.
+ */
+export interface BaselineResult {
+    /** Paths ranked by score */
+    readonly paths: readonly ScoredPath[];
+    /** Ranking method name */
+    readonly method: string;
+}
+/**
+ * Path ranking function type.
+ */
+export type PathRanker<N extends NodeData = NodeData, E extends EdgeData = EdgeData> = (graph: ReadableGraph<N, E>, paths: readonly ExpansionPath[], config?: BaselineConfig) => BaselineResult;
+//# sourceMappingURL=types.d.ts.map

package/dist/ranking/baselines/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/ranking/baselines/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,0CAA0C;IAC1C,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,UAAW,SAAQ,aAAa;IAChD,oBAAoB;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,4BAA4B;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;IACtC,0BAA0B;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,CACrB,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,IAC1B,CACH,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,MAAM,CAAC,EAAE,cAAc,KACnB,cAAc,CAAC"}

package/dist/ranking/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Path ranking module.
+ *
+ * Provides PARSE (Path-Aware Ranking via Salience Estimation) and
+ * baseline ranking methods for comparing discovered paths.
+ *
+ * @module ranking
+ */
+export { parse } from './parse';
+export type { PARSEConfig, PARSEResult, RankedPath } from './parse';
+export type { MIFunction, MIVariantName, MIConfig, AdaptiveMIConfig, } from './mi/types';
+export { jaccard, adamicAdar, scale, skew, span, etch, notch, adaptive, } from './mi/index';
+export { shortest } from './baselines/shortest';
+export type { BaselineConfig, BaselineResult, ScoredPath, PathRanker, } from './baselines/types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ranking/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAGpE,YAAY,EACX,UAAU,EACV,aAAa,EACb,QAAQ,EACR,gBAAgB,GAChB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACN,OAAO,EACP,UAAU,EACV,KAAK,EACL,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,QAAQ,GACR,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,YAAY,EACX,cAAc,EACd,cAAc,EACd,UAAU,EACV,UAAU,GACV,MAAM,mBAAmB,CAAC"}

package/dist/ranking/mi/adamic-adar.d.ts

@@ -0,0 +1,13 @@
+import { NodeId, NodeData, EdgeData, ReadableGraph } from '../../graph';
+import { MIConfig } from './types';
+/**
+ * Compute Adamic-Adar index between neighbourhoods of two nodes.
+ *
+ * @param graph - Source graph
+ * @param source - Source node ID
+ * @param target - Target node ID
+ * @param config - Optional configuration
+ * @returns Adamic-Adar index (normalised to [0, 1] if configured)
+ */
+export declare function adamicAdar<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, source: NodeId, target: NodeId, config?: MIConfig): number;
+//# sourceMappingURL=adamic-adar.d.ts.map

package/dist/ranking/mi/adamic-adar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adamic-adar.d.ts","sourceRoot":"","sources":["../../../src/ranking/mi/adamic-adar.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAChE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,QAAQ,GACf,MAAM,CAuCR"}

package/dist/ranking/mi/adaptive.d.ts

@@ -0,0 +1,16 @@
+import { NodeId, NodeData, EdgeData, ReadableGraph } from '../../graph';
+import { AdaptiveMIConfig } from './types';
+/**
+ * Compute unified adaptive MI between two connected nodes.
+ *
+ * Combines structural, degree, and overlap signals with
+ * adaptive weighting based on graph density.
+ *
+ * @param graph - Source graph
+ * @param source - Source node ID
+ * @param target - Target node ID
+ * @param config - Optional configuration with component weights
+ * @returns Adaptive MI score in [0, 1]
+ */
+export declare function adaptive<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, source: NodeId, target: NodeId, config?: AdaptiveMIConfig): number;
+//# sourceMappingURL=adaptive.d.ts.map

package/dist/ranking/mi/adaptive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive.d.ts","sourceRoot":"","sources":["../../../src/ranking/mi/adaptive.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAIhD;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC9D,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,gBAAgB,GACvB,MAAM,CAmDR"}

package/dist/ranking/mi/etch.d.ts

@@ -0,0 +1,7 @@
+import { NodeId, NodeData, EdgeData, ReadableGraph } from '../../graph';
+import { MIConfig } from './types';
+/**
+ * Compute ETCH MI between two nodes.
+ */
+export declare function etch<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, source: NodeId, target: NodeId, config?: MIConfig): number;
+//# sourceMappingURL=etch.d.ts.map

package/dist/ranking/mi/etch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"etch.d.ts","sourceRoot":"","sources":["../../../src/ranking/mi/etch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;GAEG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC1D,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,QAAQ,GACf,MAAM,CA6DR"}

package/dist/ranking/mi/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Mutual Information (MI) variants module.
+ *
+ * MI measures quantify the strength of association between connected nodes.
+ * These are used in PARSE for computing path salience via geometric mean.
+ *
+ * @module ranking/mi
+ */
+export type { MIFunction, MIVariantName, MIConfig, AdaptiveMIConfig, } from './types';
+export { jaccard } from './jaccard';
+export { adamicAdar } from './adamic-adar';
+export { scale } from './scale';
+export { skew } from './skew';
+export { span } from './span';
+export { etch } from './etch';
+export { notch } from './notch';
+export { adaptive } from './adaptive';
+//# sourceMappingURL=index.d.ts.map

package/dist/ranking/mi/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ranking/mi/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,YAAY,EACX,UAAU,EACV,aAAa,EACb,QAAQ,EACR,gBAAgB,GAChB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGhC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAG9B,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAG9B,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAG9B,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGhC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/dist/ranking/mi/jaccard.d.ts

@@ -0,0 +1,13 @@
+import { NodeId, NodeData, EdgeData, ReadableGraph } from '../../graph';
+import { MIConfig } from './types';
+/**
+ * Compute Jaccard similarity between neighbourhoods of two nodes.
+ *
+ * @param graph - Source graph
+ * @param source - Source node ID
+ * @param target - Target node ID
+ * @param config - Optional configuration
+ * @returns Jaccard coefficient in [0, 1]
+ */
+export declare function jaccard<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, source: NodeId, target: NodeId, config?: MIConfig): number;
+//# sourceMappingURL=jaccard.d.ts.map

package/dist/ranking/mi/jaccard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jaccard.d.ts","sourceRoot":"","sources":["../../../src/ranking/mi/jaccard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC7D,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,QAAQ,GACf,MAAM,CAgCR"}

package/dist/ranking/mi/mi-variants.unit.test.d.ts

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

package/dist/ranking/mi/mi-variants.unit.test.d.ts.map

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

package/dist/ranking/mi/notch.d.ts

@@ -0,0 +1,7 @@
+import { NodeId, NodeData, EdgeData, ReadableGraph } from '../../graph';
+import { MIConfig } from './types';
+/**
+ * Compute NOTCH MI between two nodes.
+ */
+export declare function notch<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, source: NodeId, target: NodeId, config?: MIConfig): number;
+//# sourceMappingURL=notch.d.ts.map

package/dist/ranking/mi/notch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notch.d.ts","sourceRoot":"","sources":["../../../src/ranking/mi/notch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;GAEG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC3D,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,QAAQ,GACf,MAAM,CAkCR"}

package/dist/ranking/mi/scale.d.ts

@@ -0,0 +1,7 @@
+import { NodeId, NodeData, EdgeData, ReadableGraph } from '../../graph';
+import { MIConfig } from './types';
+/**
+ * Compute SCALE MI between two nodes.
+ */
+export declare function scale<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, source: NodeId, target: NodeId, config?: MIConfig): number;
+//# sourceMappingURL=scale.d.ts.map

package/dist/ranking/mi/scale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scale.d.ts","sourceRoot":"","sources":["../../../src/ranking/mi/scale.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;GAEG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC3D,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,QAAQ,GACf,MAAM,CAsCR"}

package/dist/ranking/mi/skew.d.ts

@@ -0,0 +1,7 @@
+import { NodeId, NodeData, EdgeData, ReadableGraph } from '../../graph';
+import { MIConfig } from './types';
+/**
+ * Compute SKEW MI between two nodes.
+ */
+export declare function skew<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, source: NodeId, target: NodeId, config?: MIConfig): number;
+//# sourceMappingURL=skew.d.ts.map

package/dist/ranking/mi/skew.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skew.d.ts","sourceRoot":"","sources":["../../../src/ranking/mi/skew.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;GAEG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC1D,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,QAAQ,GACf,MAAM,CAuCR"}

package/dist/ranking/mi/span.d.ts

@@ -0,0 +1,7 @@
+import { NodeId, NodeData, EdgeData, ReadableGraph } from '../../graph';
+import { MIConfig } from './types';
+/**
+ * Compute SPAN MI between two nodes.
+ */
+export declare function span<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, source: NodeId, target: NodeId, config?: MIConfig): number;
+//# sourceMappingURL=span.d.ts.map

package/dist/ranking/mi/span.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span.d.ts","sourceRoot":"","sources":["../../../src/ranking/mi/span.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;GAEG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC1D,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,QAAQ,GACf,MAAM,CAkCR"}

package/dist/ranking/mi/types.d.ts

@@ -0,0 +1,35 @@
+import { NodeId, NodeData, EdgeData, ReadableGraph } from '../../graph';
+/**
+ * MI function computes association strength between connected nodes.
+ *
+ * @param graph - Source graph
+ * @param source - Source node ID
+ * @param target - Target node ID
+ * @returns MI score in [0, 1] range (0 = no association, 1 = perfect)
+ */
+export type MIFunction<N extends NodeData = NodeData, E extends EdgeData = EdgeData> = (graph: ReadableGraph<N, E>, source: NodeId, target: NodeId) => number;
+/**
+ * Names of available MI variants.
+ */
+export type MIVariantName = "jaccard" | "adamic-adar" | "scale" | "skew" | "span" | "etch" | "notch" | "adaptive";
+/**
+ * Configuration for MI computation.
+ */
+export interface MIConfig {
+    /** Epsilon for numerical stability */
+    readonly epsilon?: number;
+    /** Whether to normalise result to [0, 1] */
+    readonly normalise?: boolean;
+}
+/**
+ * Configuration for Adaptive MI.
+ */
+export interface AdaptiveMIConfig extends MIConfig {
+    /** Weight for structural (Jaccard) MI component */
+    readonly structuralWeight?: number;
+    /** Weight for degree-weighted (Adamic-Adar) MI component */
+    readonly degreeWeight?: number;
+    /** Weight for overlap coefficient component */
+    readonly overlapWeight?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/ranking/mi/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/ranking/mi/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE7E;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,CACrB,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,IAC1B,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,aAAa,GACtB,SAAS,GACT,aAAa,GACb,OAAO,GACP,MAAM,GACN,MAAM,GACN,MAAM,GACN,OAAO,GACP,UAAU,CAAC;AAEd;;GAEG;AACH,MAAM,WAAW,QAAQ;IACxB,sCAAsC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,4CAA4C;IAC5C,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,QAAQ;IACjD,mDAAmD;IACnD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,4DAA4D;IAC5D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,+CAA+C;IAC/C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CAChC"}

package/dist/ranking/parse.d.ts

@@ -0,0 +1,56 @@
+import { NodeData, EdgeData, ReadableGraph } from '../graph';
+import { ExpansionPath } from '../expansion/types';
+import { MIFunction } from './mi/types';
+/**
+ * Configuration for PARSE ranking.
+ */
+export interface PARSEConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> {
+    /** MI function to use (default: jaccard) */
+    readonly mi?: MIFunction<N, E>;
+    /** Minimum epsilon for MI (default: 1e-10) */
+    readonly epsilon?: number;
+    /** Whether to include salience scores in result (default: true) */
+    readonly includeSalience?: boolean;
+}
+/**
+ * A ranked path with salience score.
+ */
+export interface RankedPath extends ExpansionPath {
+    /** Salience score (geometric mean of edge MI) */
+    readonly salience: number;
+}
+/**
+ * Result of PARSE ranking.
+ */
+export interface PARSEResult {
+    /** Paths ranked by salience (highest first) */
+    readonly paths: readonly RankedPath[];
+    /** Ranking statistics */
+    readonly stats: {
+        /** Total paths ranked */
+        readonly pathsRanked: number;
+        /** Mean salience */
+        readonly meanSalience: number;
+        /** Median salience */
+        readonly medianSalience: number;
+        /** Maximum salience */
+        readonly maxSalience: number;
+        /** Minimum salience */
+        readonly minSalience: number;
+        /** Ranking duration in milliseconds */
+        readonly durationMs: number;
+    };
+}
+/**
+ * Rank paths using PARSE (Path-Aware Ranking via Salience Estimation).
+ *
+ * Computes geometric mean of edge MI scores for each path,
+ * then sorts by salience (highest first).
+ *
+ * @param graph - Source graph
+ * @param paths - Paths to rank
+ * @param config - Configuration options
+ * @returns Ranked paths with statistics
+ */
+export declare function parse<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, paths: readonly ExpansionPath[], config?: PARSEConfig<N, E>): PARSEResult;
+//# sourceMappingURL=parse.d.ts.map

package/dist/ranking/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/ranking/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C;;GAEG;AACH,MAAM,WAAW,WAAW,CAC3B,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ;IAE7B,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/B,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,mEAAmE;IACnE,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,UAAW,SAAQ,aAAa;IAChD,iDAAiD;IACjD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,+CAA+C;IAC/C,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;IACtC,yBAAyB;IACzB,QAAQ,CAAC,KAAK,EAAE;QACf,yBAAyB;QACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;QAC7B,oBAAoB;QACpB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;QAC9B,sBAAsB;QACtB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;QAChC,uBAAuB;QACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;QAC7B,uBAAuB;QACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;QAC7B,uCAAuC;QACvC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;KAC5B,CAAC;CACF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC3D,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GACxB,WAAW,CAoDb"}

package/dist/ranking/parse.unit.test.d.ts

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

package/dist/ranking/parse.unit.test.d.ts.map

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

package/dist/schemas/define.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+/**
+ * Attach a type guard directly to a Zod schema.
+ *
+ * This keeps the runtime validator, the inferred TypeScript type,
+ * and the runtime type guard derived from the same source.
+ */
+export declare function defineSchema<T extends z.ZodType>(schema: T): T & {
+    is(value: unknown): value is z.infer<T>;
+};
+/**
+ * Create a schema with a custom type guard name for better error messages.
+ */
+export declare function defineNamedSchema<T extends z.ZodType>(name: string, schema: T): T & {
+    is(value: unknown): value is z.infer<T>;
+    typeName: string;
+};
+//# sourceMappingURL=define.d.ts.map

package/dist/schemas/define.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.d.ts","sourceRoot":"","sources":["../../src/schemas/define.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAC/C,MAAM,EAAE,CAAC,GACP,CAAC,GAAG;IAAE,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;CAAE,CAMjD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EACpD,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,GACP,CAAC,GAAG;IAAE,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAOnE"}

package/dist/schemas/define.unit.test.d.ts

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

package/dist/schemas/define.unit.test.d.ts.map

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