umap-web 0.2.0

package/dist/core-BPpH5_PW.js

@@ -0,0 +1,2816 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { f as UmapBackendError, h as UmapValidationError } from "./init-DLiEtGpx.js";
+
+//#region src/graph/ab.ts
+function findABParams(spread, minDist) {
+	const N = 300;
+	const xv = new Float64Array(N);
+	const yv = new Float64Array(N);
+	const step = spread * 3 / (N - 1);
+	for (let i = 0; i < N; i++) {
+		const x = i * step;
+		xv[i] = x;
+		yv[i] = x < minDist ? 1 : Math.exp(-(x - minDist) / spread);
+	}
+	let a = 1;
+	let b = 1;
+	let lambda = .001;
+	const residuals = (pa, pb) => {
+		let cost$1 = 0;
+		for (let i = 0; i < N; i++) {
+			const r = 1 / (1 + pa * xv[i] ** (2 * pb)) - yv[i];
+			cost$1 += r * r;
+		}
+		return cost$1;
+	};
+	let cost = residuals(a, b);
+	for (let iter = 0; iter < 300; iter++) {
+		let jaa = 0;
+		let jab = 0;
+		let jbb = 0;
+		let ga = 0;
+		let gb = 0;
+		for (let i = 0; i < N; i++) {
+			const x = xv[i];
+			const xp = x > 0 ? x ** (2 * b) : 0;
+			const denom = 1 + a * xp;
+			const r = 1 / denom - yv[i];
+			const dfda = -xp / (denom * denom);
+			const dfdb = x > 0 ? -a * xp * 2 * Math.log(x) / (denom * denom) : 0;
+			jaa += dfda * dfda;
+			jab += dfda * dfdb;
+			jbb += dfdb * dfdb;
+			ga += dfda * r;
+			gb += dfdb * r;
+		}
+		const m00 = jaa * (1 + lambda);
+		const m11 = jbb * (1 + lambda);
+		const m01 = jab;
+		const det = m00 * m11 - m01 * m01;
+		if (det === 0 || !Number.isFinite(det)) break;
+		const da = (-ga * m11 + gb * m01) / det;
+		const db = (ga * m01 - gb * m00) / det;
+		const na = a + da;
+		const nb = b + db;
+		const newCost = residuals(na, nb);
+		if (newCost < cost) {
+			a = na;
+			b = nb;
+			const improvement = cost - newCost;
+			cost = newCost;
+			lambda = Math.max(lambda / 3, 1e-12);
+			if (improvement < 1e-15 && Math.abs(da) + Math.abs(db) < 1e-12) break;
+		} else {
+			lambda *= 3;
+			if (lambda > 0xe8d4a51000) break;
+		}
+	}
+	return {
+		a,
+		b
+	};
+}
+
+//#endregion
+//#region src/sparse.ts
+function csrNnz(m) {
+	return m.indptr[m.rows];
+}
+/**
+* Build canonical CSR from COO triplets: duplicates summed, zeros eliminated,
+* columns sorted per row.
+*/
+function csrFromCoo(rows, cols, rowIdx, colIdx, values) {
+	const nnzIn = rowIdx.length;
+	const counts = new Int32Array(rows + 1);
+	for (let t = 0; t < nnzIn; t++) counts[rowIdx[t] + 1]++;
+	for (let r = 0; r < rows; r++) counts[r + 1] += counts[r];
+	const order = new Int32Array(nnzIn);
+	const cursor = counts.slice(0, rows);
+	for (let t = 0; t < nnzIn; t++) {
+		const r = rowIdx[t];
+		order[cursor[r]++] = t;
+	}
+	const indptr = new Int32Array(rows + 1);
+	const outIdx = new Int32Array(nnzIn);
+	const outVal = new Float64Array(nnzIn);
+	let nnz = 0;
+	const tmpCols = [];
+	const tmpVals = [];
+	for (let r = 0; r < rows; r++) {
+		tmpCols.length = 0;
+		tmpVals.length = 0;
+		for (let p = counts[r]; p < counts[r + 1]; p++) {
+			const t = order[p];
+			tmpCols.push(colIdx[t]);
+			tmpVals.push(values[t]);
+		}
+		const n = tmpCols.length;
+		if (n > 0) {
+			const perm = Array.from({ length: n }, (_, i) => i).sort((a, b) => tmpCols[a] - tmpCols[b]);
+			let lastCol = -1;
+			let acc = 0;
+			for (let i = 0; i <= n; i++) {
+				const c = i < n ? tmpCols[perm[i]] : -2;
+				if (c !== lastCol) {
+					if (lastCol >= 0 && acc !== 0) {
+						outIdx[nnz] = lastCol;
+						outVal[nnz] = acc;
+						nnz++;
+					}
+					lastCol = c;
+					acc = 0;
+				}
+				if (i < n) acc += tmpVals[perm[i]];
+			}
+		}
+		indptr[r + 1] = nnz;
+	}
+	return {
+		data: outVal.slice(0, nnz),
+		indices: outIdx.slice(0, nnz),
+		indptr,
+		rows,
+		cols
+	};
+}
+function csrTranspose(m) {
+	const nnz = csrNnz(m);
+	const counts = new Int32Array(m.cols + 1);
+	for (let t = 0; t < nnz; t++) counts[m.indices[t] + 1]++;
+	for (let c = 0; c < m.cols; c++) counts[c + 1] += counts[c];
+	const indptr = counts.slice();
+	const indices = new Int32Array(nnz);
+	const data = new Float64Array(nnz);
+	const cursor = counts.slice(0, m.cols);
+	for (let r = 0; r < m.rows; r++) for (let p = m.indptr[r]; p < m.indptr[r + 1]; p++) {
+		const c = m.indices[p];
+		const dst = cursor[c]++;
+		indices[dst] = r;
+		data[dst] = m.data[p];
+	}
+	return {
+		data,
+		indices,
+		indptr,
+		rows: m.cols,
+		cols: m.rows
+	};
+}
+/**
+* Elementwise combine over the UNION sparsity of two canonical CSRs.
+* `f(a, b)` receives 0 for absent entries; results equal to 0 are eliminated.
+*/
+function csrBinaryOp(A, B, f) {
+	const rows = A.rows;
+	const cols = A.cols;
+	const indptr = new Int32Array(rows + 1);
+	const cap = csrNnz(A) + csrNnz(B);
+	const indices = new Int32Array(cap);
+	const data = new Float64Array(cap);
+	let nnz = 0;
+	for (let r = 0; r < rows; r++) {
+		let pa = A.indptr[r];
+		let pb = B.indptr[r];
+		const ea = A.indptr[r + 1];
+		const eb = B.indptr[r + 1];
+		while (pa < ea || pb < eb) {
+			const ca = pa < ea ? A.indices[pa] : Infinity;
+			const cb = pb < eb ? B.indices[pb] : Infinity;
+			let col;
+			let va = 0;
+			let vb = 0;
+			if (ca < cb) {
+				col = ca;
+				va = A.data[pa];
+				pa++;
+			} else if (cb < ca) {
+				col = cb;
+				vb = B.data[pb];
+				pb++;
+			} else {
+				col = ca;
+				va = A.data[pa];
+				vb = B.data[pb];
+				pa++;
+				pb++;
+			}
+			const v = f(va, vb);
+			if (v !== 0) {
+				indices[nnz] = col;
+				data[nnz] = v;
+				nnz++;
+			}
+		}
+		indptr[r + 1] = nnz;
+	}
+	return {
+		data: data.slice(0, nnz),
+		indices: indices.slice(0, nnz),
+		indptr,
+		rows,
+		cols
+	};
+}
+/** Drop explicit zeros (canonicalize). */
+function csrEliminateZeros(m) {
+	const nnz = csrNnz(m);
+	let out = 0;
+	for (let t = 0; t < nnz; t++) if (m.data[t] !== 0) out++;
+	if (out === nnz) return m;
+	const indptr = new Int32Array(m.rows + 1);
+	const indices = new Int32Array(out);
+	const data = new Float64Array(out);
+	let k = 0;
+	for (let r = 0; r < m.rows; r++) {
+		for (let p = m.indptr[r]; p < m.indptr[r + 1]; p++) if (m.data[p] !== 0) {
+			indices[k] = m.indices[p];
+			data[k] = m.data[p];
+			k++;
+		}
+		indptr[r + 1] = k;
+	}
+	return {
+		data,
+		indices,
+		indptr,
+		rows: m.rows,
+		cols: m.cols
+	};
+}
+/** Map values in place. */
+function csrMapValues(m, f) {
+	for (let t = 0; t < csrNnz(m); t++) m.data[t] = f(m.data[t]);
+	return m;
+}
+/** Max of |A - B| over union sparsity, for tests. */
+function csrMaxAbsDiff(A, B) {
+	let worst = 0;
+	csrBinaryOp(A, B, (a, b) => {
+		const v = Math.abs(a - b);
+		if (v > worst) worst = v;
+		return v;
+	});
+	return worst;
+}
+/** Row-normalize by max (scipy normalize(norm='max')): divide each row by its max value. */
+function csrRowNormalizeMax(m) {
+	for (let r = 0; r < m.rows; r++) {
+		let mx = 0;
+		for (let p = m.indptr[r]; p < m.indptr[r + 1]; p++) {
+			const v = m.data[p];
+			if (v > mx) mx = v;
+		}
+		if (mx > 0) for (let p = m.indptr[r]; p < m.indptr[r + 1]; p++) m.data[p] = m.data[p] / mx;
+	}
+	return m;
+}
+/** COO iteration helper. */
+function csrForEach(m, cb) {
+	for (let r = 0; r < m.rows; r++) for (let p = m.indptr[r]; p < m.indptr[r + 1]; p++) cb(r, m.indices[p], m.data[p]);
+}
+/** Deep copy. */
+function csrCopy(m) {
+	return {
+		data: m.data.slice(),
+		indices: m.indices.slice(),
+		indptr: m.indptr.slice(),
+		rows: m.rows,
+		cols: m.cols
+	};
+}
+
+//#endregion
+//#region src/graph/epochs.ts
+function makeEpochsPerSample(weights, nEpochs) {
+	const result = new Float64Array(weights.length).fill(-1);
+	let wMax = -Infinity;
+	for (let i = 0; i < weights.length; i++) if (weights[i] > wMax) wMax = weights[i];
+	for (let i = 0; i < weights.length; i++) {
+		const nSamples = nEpochs * (weights[i] / wMax);
+		if (nSamples > 0) result[i] = nEpochs / nSamples;
+	}
+	return result;
+}
+/** Default epoch rule: 500 for n<=10000 else 200; +200 when densMAP (notes §6.2). */
+function defaultNEpochs(nVertices, densmap) {
+	let d = nVertices <= 1e4 ? 500 : 200;
+	if (densmap) d += 200;
+	return d;
+}
+/**
+* Prune graph weights below max/n_epochs (in place on a copy) exactly like
+* simplicial_set_embedding, returning the pruned graph.
+*/
+function pruneGraphForEpochs(graph, nEpochsMax, defaultEpochs) {
+	const out = {
+		data: graph.data.slice(),
+		indices: graph.indices,
+		indptr: graph.indptr,
+		rows: graph.rows,
+		cols: graph.cols
+	};
+	let mx = -Infinity;
+	for (let i = 0; i < out.data.length; i++) if (out.data[i] > mx) mx = out.data[i];
+	const thresh = mx / (nEpochsMax > 10 ? nEpochsMax : defaultEpochs);
+	for (let i = 0; i < out.data.length; i++) if (out.data[i] < thresh) out.data[i] = 0;
+	return csrEliminateZeros(out);
+}
+
+//#endregion
+//#region src/graph/smooth.ts
+/**
+* smooth_knn_dist — sigma/rho computation (umap_.py:143-253; notes §1).
+*
+* Python runs this in float32 fastmath; we compute in float64 (matches to ~1e-6,
+* within the §3.3 tolerance policy).
+*/
+const SMOOTH_K_TOLERANCE = 1e-5;
+const MIN_K_DIST_SCALE = .001;
+/**
+* @param distances (nSamples × nNeighbors) row-major, each row sorted ascending
+*                  (includes self at column 0 for standard kNN).
+* @param k the float number of neighbors (callers pass the integer k).
+*/
+function smoothKnnDist(distances, nNeighbors, k, { nIter = 64, localConnectivity = 1, bandwidth = 1 } = {}) {
+	const nSamples = distances.length / nNeighbors;
+	const target = Math.log2(k) * bandwidth;
+	const rhos = new Float32Array(nSamples);
+	const sigmas = new Float32Array(nSamples);
+	let meanDistances = 0;
+	for (let t = 0; t < distances.length; t++) meanDistances += distances[t];
+	meanDistances /= distances.length;
+	const nonZero = new Float64Array(nNeighbors);
+	for (let i = 0; i < nSamples; i++) {
+		const base = i * nNeighbors;
+		let lo = 0;
+		let hi = Infinity;
+		let mid = 1;
+		let nz = 0;
+		for (let j = 0; j < nNeighbors; j++) {
+			const d = distances[base + j];
+			if (d > 0) nonZero[nz++] = d;
+		}
+		let rho = 0;
+		if (nz >= localConnectivity) {
+			const index = Math.floor(localConnectivity);
+			const interpolation = localConnectivity - index;
+			if (index > 0) {
+				rho = nonZero[index - 1];
+				if (interpolation > SMOOTH_K_TOLERANCE) rho += interpolation * (nonZero[index] - nonZero[index - 1]);
+			} else rho = interpolation * nonZero[0];
+		} else if (nz > 0) {
+			let mx = -Infinity;
+			for (let j = 0; j < nz; j++) if (nonZero[j] > mx) mx = nonZero[j];
+			rho = mx;
+		}
+		rhos[i] = rho;
+		for (let n = 0; n < nIter; n++) {
+			let psum = 0;
+			for (let j = 1; j < nNeighbors; j++) {
+				const d = distances[base + j] - rho;
+				psum += d > 0 ? Math.exp(-(d / mid)) : 1;
+			}
+			if (Math.abs(psum - target) < SMOOTH_K_TOLERANCE) break;
+			if (psum > target) hi = mid;
+			else lo = mid;
+			mid = (lo + hi) / 2;
+		}
+		let sigma = mid;
+		if (rho > 0) {
+			let meanIth = 0;
+			for (let j = 0; j < nNeighbors; j++) meanIth += distances[base + j];
+			meanIth /= nNeighbors;
+			if (sigma < MIN_K_DIST_SCALE * meanIth) sigma = MIN_K_DIST_SCALE * meanIth;
+		} else if (sigma < MIN_K_DIST_SCALE * meanDistances) sigma = MIN_K_DIST_SCALE * meanDistances;
+		sigmas[i] = sigma;
+	}
+	return {
+		sigmas,
+		rhos
+	};
+}
+
+//#endregion
+//#region src/graph/fuzzy.ts
+function computeMembershipStrengths(knnIndices, knnDists, sigmas, rhos, nNeighbors, returnDists = false, bipartite = false) {
+	const nSamples = knnIndices.length / nNeighbors;
+	const size = nSamples * nNeighbors;
+	const rows = new Int32Array(size);
+	const cols = new Int32Array(size);
+	const vals = new Float32Array(size);
+	const dists = returnDists ? new Float32Array(size) : null;
+	for (let i = 0; i < nSamples; i++) {
+		const base = i * nNeighbors;
+		for (let j = 0; j < nNeighbors; j++) {
+			const idx = knnIndices[base + j];
+			if (idx === -1) continue;
+			let val;
+			if (!bipartite && idx === i) val = 0;
+			else if (knnDists[base + j] - rhos[i] <= 0 || sigmas[i] === 0) val = 1;
+			else val = Math.fround(Math.exp(-((knnDists[base + j] - rhos[i]) / sigmas[i])));
+			rows[base + j] = i;
+			cols[base + j] = idx;
+			vals[base + j] = val;
+			if (dists) dists[base + j] = knnDists[base + j];
+		}
+	}
+	return {
+		rows,
+		cols,
+		vals,
+		dists
+	};
+}
+/**
+* Build the fuzzy simplicial set from a kNN graph (knn indices+distances required;
+* the estimator computes them per §5.2 backends).
+*/
+function fuzzySimplicialSet(nSamples, nNeighbors, knnIndices, knnDists, { setOpMixRatio = 1, localConnectivity = 1, applySetOperations = true, returnDists = false } = {}) {
+	const { sigmas, rhos } = smoothKnnDist(knnDists, nNeighbors, nNeighbors, { localConnectivity });
+	const { rows, cols, vals, dists } = computeMembershipStrengths(knnIndices, knnDists, sigmas, rhos, nNeighbors, returnDists);
+	let graph = csrFromCoo(nSamples, nSamples, rows, cols, vals);
+	if (applySetOperations) {
+		const transpose = csrTranspose(graph);
+		graph = csrBinaryOp(graph, transpose, (a, b) => {
+			const prod = a * b;
+			return setOpMixRatio * (a + b - prod) + (1 - setOpMixRatio) * prod;
+		});
+	}
+	graph = csrEliminateZeros(graph);
+	let distGraph = null;
+	if (returnDists && dists) {
+		const dmat = csrFromCoo(nSamples, nSamples, rows, cols, dists);
+		distGraph = csrEliminateZeros(csrBinaryOp(dmat, csrTranspose(dmat), (a, b) => Math.max(a, b)));
+	}
+	return {
+		graph,
+		sigmas,
+		rhos,
+		dists: distGraph
+	};
+}
+
+//#endregion
+//#region src/metrics.ts
+var metrics_exports = /* @__PURE__ */ __export({
+	ANGULAR_METRICS: () => ANGULAR_METRICS,
+	NAMED_METRICS: () => NAMED_METRICS,
+	brayCurtis: () => brayCurtis,
+	canberra: () => canberra,
+	canonicalMetricName: () => canonicalMetricName,
+	chebyshev: () => chebyshev,
+	correlation: () => correlation,
+	cosine: () => cosine,
+	dice: () => dice,
+	euclidean: () => euclidean,
+	hamming: () => hamming,
+	haversine: () => haversine,
+	hellinger: () => hellinger,
+	isNamedMetric: () => isNamedMetric,
+	jaccard: () => jaccard,
+	kulsinski: () => kulsinski,
+	llDirichlet: () => llDirichlet,
+	mahalanobis: () => mahalanobis,
+	manhattan: () => manhattan,
+	matching: () => matching,
+	minkowski: () => minkowski,
+	resolveMetric: () => resolveMetric,
+	rogersTanimoto: () => rogersTanimoto,
+	russellrao: () => russellrao,
+	sokalMichener: () => sokalMichener,
+	sokalSneath: () => sokalSneath,
+	sqeuclidean: () => sqeuclidean,
+	standardisedEuclidean: () => standardisedEuclidean,
+	symmetricKl: () => symmetricKl,
+	validateMetricOptionSizes: () => validateMetricOptionSizes,
+	weightedMinkowski: () => weightedMinkowski,
+	yule: () => yule
+});
+function euclidean(x, y) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) {
+		const d = x[i] - y[i];
+		result += d * d;
+	}
+	return Math.sqrt(result);
+}
+/** Squared euclidean — used internally by the optimizer (rdist). */
+function sqeuclidean(x, y) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) {
+		const d = x[i] - y[i];
+		result += d * d;
+	}
+	return result;
+}
+function standardisedEuclidean(x, y, sigma) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) {
+		const d = x[i] - y[i];
+		result += d * d / sigma[i];
+	}
+	return Math.sqrt(result);
+}
+function manhattan(x, y) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) result += Math.abs(x[i] - y[i]);
+	return result;
+}
+function chebyshev(x, y) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) {
+		const v = Math.abs(x[i] - y[i]);
+		if (v > result) result = v;
+	}
+	return result;
+}
+function minkowski(x, y, p) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) result += Math.abs(x[i] - y[i]) ** p;
+	return result ** (1 / p);
+}
+function weightedMinkowski(x, y, w, p) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) result += w[i] * Math.abs(x[i] - y[i]) ** p;
+	return result ** (1 / p);
+}
+function mahalanobis(x, y, vinv) {
+	const n = x.length;
+	let result = 0;
+	const diff = new Float64Array(n);
+	for (let i = 0; i < n; i++) diff[i] = x[i] - y[i];
+	for (let i = 0; i < n; i++) {
+		let tmp = 0;
+		for (let j = 0; j < n; j++) tmp += vinv[i * n + j] * diff[j];
+		result += tmp * diff[i];
+	}
+	return Math.sqrt(result);
+}
+function hamming(x, y) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) if (x[i] !== y[i]) result += 1;
+	return result / x.length;
+}
+function canberra(x, y) {
+	let result = 0;
+	for (let i = 0; i < x.length; i++) {
+		const denominator = Math.abs(x[i]) + Math.abs(y[i]);
+		if (denominator > 0) result += Math.abs(x[i] - y[i]) / denominator;
+	}
+	return result;
+}
+function brayCurtis(x, y) {
+	let numerator = 0;
+	let denominator = 0;
+	for (let i = 0; i < x.length; i++) {
+		numerator += Math.abs(x[i] - y[i]);
+		denominator += Math.abs(x[i] + y[i]);
+	}
+	return denominator > 0 ? numerator / denominator : 0;
+}
+function jaccard(x, y) {
+	let numNonZero = 0;
+	let numEqual = 0;
+	for (let i = 0; i < x.length; i++) {
+		const xt = x[i] !== 0;
+		const yt = y[i] !== 0;
+		numNonZero += xt || yt ? 1 : 0;
+		numEqual += xt && yt ? 1 : 0;
+	}
+	return numNonZero === 0 ? 0 : (numNonZero - numEqual) / numNonZero;
+}
+function matching(x, y) {
+	let numNotEqual = 0;
+	for (let i = 0; i < x.length; i++) if (x[i] !== 0 !== (y[i] !== 0)) numNotEqual += 1;
+	return numNotEqual / x.length;
+}
+function dice(x, y) {
+	let numTrueTrue = 0;
+	let numNotEqual = 0;
+	for (let i = 0; i < x.length; i++) {
+		const xt = x[i] !== 0;
+		const yt = y[i] !== 0;
+		numTrueTrue += xt && yt ? 1 : 0;
+		numNotEqual += xt !== yt ? 1 : 0;
+	}
+	return numNotEqual === 0 ? 0 : numNotEqual / (2 * numTrueTrue + numNotEqual);
+}
+function kulsinski(x, y) {
+	let numTrueTrue = 0;
+	let numNotEqual = 0;
+	for (let i = 0; i < x.length; i++) {
+		const xt = x[i] !== 0;
+		const yt = y[i] !== 0;
+		numTrueTrue += xt && yt ? 1 : 0;
+		numNotEqual += xt !== yt ? 1 : 0;
+	}
+	return numNotEqual === 0 ? 0 : (numNotEqual - numTrueTrue + x.length) / (numNotEqual + x.length);
+}
+function rogersTanimoto(x, y) {
+	let numNotEqual = 0;
+	for (let i = 0; i < x.length; i++) if (x[i] !== 0 !== (y[i] !== 0)) numNotEqual += 1;
+	return 2 * numNotEqual / (x.length + numNotEqual);
+}
+function russellrao(x, y) {
+	let numTrueTrue = 0;
+	let xNonZero = 0;
+	let yNonZero = 0;
+	for (let i = 0; i < x.length; i++) {
+		const xt = x[i] !== 0;
+		const yt = y[i] !== 0;
+		numTrueTrue += xt && yt ? 1 : 0;
+		xNonZero += xt ? 1 : 0;
+		yNonZero += yt ? 1 : 0;
+	}
+	if (numTrueTrue === xNonZero && numTrueTrue === yNonZero) return 0;
+	return (x.length - numTrueTrue) / x.length;
+}
+function sokalMichener(x, y) {
+	return rogersTanimoto(x, y);
+}
+function sokalSneath(x, y) {
+	let numTrueTrue = 0;
+	let numNotEqual = 0;
+	for (let i = 0; i < x.length; i++) {
+		const xt = x[i] !== 0;
+		const yt = y[i] !== 0;
+		numTrueTrue += xt && yt ? 1 : 0;
+		numNotEqual += xt !== yt ? 1 : 0;
+	}
+	return numNotEqual === 0 ? 0 : numNotEqual / (.5 * numTrueTrue + numNotEqual);
+}
+function yule(x, y) {
+	let tt = 0;
+	let tf = 0;
+	let ft = 0;
+	for (let i = 0; i < x.length; i++) {
+		const xt = x[i] !== 0;
+		const yt = y[i] !== 0;
+		tt += xt && yt ? 1 : 0;
+		tf += xt && !yt ? 1 : 0;
+		ft += !xt && yt ? 1 : 0;
+	}
+	const ff = x.length - tt - tf - ft;
+	if (tf === 0 || ft === 0) return 0;
+	return 2 * tf * ft / (tt * ff + tf * ft);
+}
+function cosine(x, y) {
+	let result = 0;
+	let normX = 0;
+	let normY = 0;
+	for (let i = 0; i < x.length; i++) {
+		result += x[i] * y[i];
+		normX += x[i] * x[i];
+		normY += y[i] * y[i];
+	}
+	if (normX === 0 && normY === 0) return 0;
+	if (normX === 0 || normY === 0) return 1;
+	return 1 - result / Math.sqrt(normX * normY);
+}
+function correlation(x, y) {
+	let muX = 0;
+	let muY = 0;
+	let normX = 0;
+	let normY = 0;
+	let dot = 0;
+	const n = x.length;
+	for (let i = 0; i < n; i++) {
+		muX += x[i];
+		muY += y[i];
+	}
+	muX /= n;
+	muY /= n;
+	for (let i = 0; i < n; i++) {
+		const sx = x[i] - muX;
+		const sy = y[i] - muY;
+		normX += sx * sx;
+		normY += sy * sy;
+		dot += sx * sy;
+	}
+	if (normX === 0 && normY === 0) return 0;
+	if (dot === 0) return 1;
+	return 1 - dot / Math.sqrt(normX * normY);
+}
+function hellinger(x, y) {
+	let result = 0;
+	let l1x = 0;
+	let l1y = 0;
+	for (let i = 0; i < x.length; i++) {
+		result += Math.sqrt(x[i] * y[i]);
+		l1x += x[i];
+		l1y += y[i];
+	}
+	if (l1x === 0 && l1y === 0) return 0;
+	if (l1x === 0 || l1y === 0) return 1;
+	return Math.sqrt(1 - result / Math.sqrt(l1x * l1y));
+}
+function approxLogGamma(x) {
+	if (x === 1) return 0;
+	return x * Math.log(x) - x + .5 * Math.log(2 * Math.PI / x) + 1 / (x * 12);
+}
+function logBeta(x, y) {
+	const a = Math.min(x, y);
+	const b = Math.max(x, y);
+	if (b < 5) {
+		let value = -Math.log(b);
+		for (let i = 1; i < Math.trunc(a); i++) value += Math.log(i) - Math.log(b + i);
+		return value;
+	}
+	return approxLogGamma(x) + approxLogGamma(y) - approxLogGamma(x + y);
+}
+function logSingleBeta(x) {
+	return Math.log(2) * (-2 * x + .5) + .5 * Math.log(2 * Math.PI / x) + .125 / x;
+}
+function llDirichlet(data1, data2) {
+	let n1 = 0;
+	let n2 = 0;
+	for (let i = 0; i < data1.length; i++) n1 += data1[i];
+	for (let i = 0; i < data2.length; i++) n2 += data2[i];
+	let logB = 0;
+	let selfDenom1 = 0;
+	let selfDenom2 = 0;
+	for (let i = 0; i < data1.length; i++) {
+		const d1 = data1[i];
+		const d2 = data2[i];
+		if (d1 * d2 > .9) {
+			logB += logBeta(d1, d2);
+			selfDenom1 += logSingleBeta(d1);
+			selfDenom2 += logSingleBeta(d2);
+		} else {
+			if (d1 > .9) selfDenom1 += logSingleBeta(d1);
+			if (d2 > .9) selfDenom2 += logSingleBeta(d2);
+		}
+	}
+	return Math.sqrt(1 / n2 * (logB - logBeta(n1, n2) - (selfDenom2 - logSingleBeta(n2))) + 1 / n1 * (logB - logBeta(n2, n1) - (selfDenom1 - logSingleBeta(n1))));
+}
+/**
+* Symmetrized KL divergence. NOTE: the Python source mutates its inputs (adds z,
+* normalizes in place); we copy to preserve the same numerics without side effects.
+*/
+function symmetricKl(x, y, z = 1e-11) {
+	const n = x.length;
+	let xSum = 0;
+	let ySum = 0;
+	const xs = new Float64Array(n);
+	const ys = new Float64Array(n);
+	for (let i = 0; i < n; i++) {
+		xs[i] = x[i] + z;
+		xSum += xs[i];
+		ys[i] = y[i] + z;
+		ySum += ys[i];
+	}
+	for (let i = 0; i < n; i++) {
+		xs[i] = xs[i] / xSum;
+		ys[i] = ys[i] / ySum;
+	}
+	let kl1 = 0;
+	let kl2 = 0;
+	for (let i = 0; i < n; i++) {
+		kl1 += xs[i] * Math.log(xs[i] / ys[i]);
+		kl2 += ys[i] * Math.log(ys[i] / xs[i]);
+	}
+	return (kl1 + kl2) / 2;
+}
+function haversine(x, y) {
+	if (x.length !== 2) throw new UmapValidationError("haversine is only defined for 2 dimensional data");
+	const sinLat = Math.sin(.5 * (x[0] - y[0]));
+	const sinLong = Math.sin(.5 * (x[1] - y[1]));
+	const result = Math.sqrt(sinLat * sinLat + Math.cos(x[0]) * Math.cos(y[0]) * sinLong * sinLong);
+	return 2 * Math.asin(result);
+}
+function simple(fn, canonical) {
+	return {
+		canonical,
+		resolve: () => fn
+	};
+}
+const SPECS = {
+	euclidean: simple(euclidean, "euclidean"),
+	l2: simple(euclidean, "euclidean"),
+	sqeuclidean: simple(sqeuclidean, "sqeuclidean"),
+	manhattan: simple(manhattan, "manhattan"),
+	taxicab: simple(manhattan, "manhattan"),
+	l1: simple(manhattan, "manhattan"),
+	chebyshev: simple(chebyshev, "chebyshev"),
+	linfinity: simple(chebyshev, "chebyshev"),
+	linfty: simple(chebyshev, "chebyshev"),
+	linf: simple(chebyshev, "chebyshev"),
+	minkowski: {
+		canonical: "minkowski",
+		needs: ["p"],
+		resolve: (o) => {
+			const p = o.p ?? 2;
+			return (x, y) => minkowski(x, y, p);
+		}
+	},
+	seuclidean: {
+		canonical: "seuclidean",
+		needs: ["V"],
+		resolve: (o) => {
+			if (!o.V) throw new UmapValidationError("metric 'seuclidean' requires metricOptions.V");
+			const V = o.V;
+			return (x, y) => standardisedEuclidean(x, y, V);
+		}
+	},
+	standardised_euclidean: {
+		canonical: "seuclidean",
+		needs: ["V"],
+		resolve: (o) => {
+			if (!o.V) throw new UmapValidationError("metric 'standardised_euclidean' requires metricOptions.V");
+			const V = o.V;
+			return (x, y) => standardisedEuclidean(x, y, V);
+		}
+	},
+	wminkowski: {
+		canonical: "wminkowski",
+		needs: ["w", "p"],
+		resolve: (o) => {
+			if (!o.w) throw new UmapValidationError("metric 'wminkowski' requires metricOptions.w");
+			const w = o.w;
+			const p = o.p ?? 2;
+			return (x, y) => weightedMinkowski(x, y, w, p);
+		}
+	},
+	weighted_minkowski: {
+		canonical: "wminkowski",
+		needs: ["w", "p"],
+		resolve: (o) => {
+			if (!o.w) throw new UmapValidationError("metric 'weighted_minkowski' requires metricOptions.w");
+			const w = o.w;
+			const p = o.p ?? 2;
+			return (x, y) => weightedMinkowski(x, y, w, p);
+		}
+	},
+	mahalanobis: {
+		canonical: "mahalanobis",
+		needs: ["VInv"],
+		resolve: (o) => {
+			if (!o.VInv) throw new UmapValidationError("metric 'mahalanobis' requires metricOptions.VInv");
+			const VInv = o.VInv;
+			return (x, y) => mahalanobis(x, y, VInv);
+		}
+	},
+	canberra: simple(canberra, "canberra"),
+	braycurtis: simple(brayCurtis, "braycurtis"),
+	cosine: simple(cosine, "cosine"),
+	correlation: simple(correlation, "correlation"),
+	haversine: simple(haversine, "haversine"),
+	hamming: simple(hamming, "hamming"),
+	jaccard: simple(jaccard, "jaccard"),
+	dice: simple(dice, "dice"),
+	matching: simple(matching, "matching"),
+	kulsinski: simple(kulsinski, "kulsinski"),
+	rogerstanimoto: simple(rogersTanimoto, "rogerstanimoto"),
+	russellrao: simple(russellrao, "russellrao"),
+	sokalmichener: simple(sokalMichener, "sokalmichener"),
+	sokalsneath: simple(sokalSneath, "sokalsneath"),
+	yule: simple(yule, "yule"),
+	hellinger: simple(hellinger, "hellinger"),
+	ll_dirichlet: simple(llDirichlet, "ll_dirichlet"),
+	symmetric_kl: simple(symmetricKl, "symmetric_kl")
+};
+const NAMED_METRICS = Object.keys(SPECS);
+/** Metrics that auto-enable angular RP-forest (umap_.py:1938-1946). */
+const ANGULAR_METRICS = new Set([
+	"cosine",
+	"correlation",
+	"dice",
+	"jaccard",
+	"ll_dirichlet",
+	"hellinger"
+]);
+function isNamedMetric(name) {
+	return name in SPECS;
+}
+function canonicalMetricName(name) {
+	const spec = SPECS[name];
+	if (!spec) throw new UmapValidationError(`unknown metric '${name}'`);
+	return spec.canonical;
+}
+function resolveMetric(name, options = {}) {
+	const spec = SPECS[name];
+	if (!spec) throw new UmapValidationError(`unknown metric '${name}' — named metrics: ${NAMED_METRICS.join(", ")}`);
+	return spec.resolve(options);
+}
+/**
+* Size/positivity checks for metricOptions once the data dimension is known —
+* a wrong-sized V/w/VInv would otherwise read undefined and silently poison
+* every distance with NaN.
+*/
+function validateMetricOptionSizes(name, options, dim) {
+	const spec = SPECS[name];
+	if (!spec) return;
+	const canonical = spec.canonical;
+	if ((canonical === "minkowski" || canonical === "wminkowski") && options.p !== void 0) {
+		if (!Number.isFinite(options.p) || options.p <= 0) throw new UmapValidationError("metricOptions.p must be a finite number > 0");
+	}
+	if (canonical === "seuclidean" && options.V) {
+		if (options.V.length !== dim) throw new UmapValidationError(`metricOptions.V has ${options.V.length} entries; the data has ${dim} features`);
+		for (let i = 0; i < dim; i++) {
+			const v = options.V[i];
+			if (!Number.isFinite(v) || v <= 0) throw new UmapValidationError(`metricOptions.V must be positive (index ${i} is ${v})`);
+		}
+	}
+	if (canonical === "wminkowski" && options.w) {
+		if (options.w.length !== dim) throw new UmapValidationError(`metricOptions.w has ${options.w.length} entries; the data has ${dim} features`);
+	}
+	if (canonical === "mahalanobis" && options.VInv) {
+		if (options.VInv.length !== dim * dim) throw new UmapValidationError(`metricOptions.VInv has ${options.VInv.length} entries; expected ${dim}×${dim} = ${dim * dim}`);
+	}
+}
+
+//#endregion
+//#region src/knn/internal-metrics.ts
+const FLOAT32_MAX = 34028234663852886e22;
+const FLOAT32_EPS = 1.1920928955078125e-7;
+function squaredEuclidean(x, y) {
+	let r = 0;
+	const n = x.length;
+	let i = 0;
+	const n4 = n - n % 4;
+	for (; i < n4; i += 4) {
+		const d0 = x[i] - y[i];
+		const d1 = x[i + 1] - y[i + 1];
+		const d2 = x[i + 2] - y[i + 2];
+		const d3 = x[i + 3] - y[i + 3];
+		r += d0 * d0 + d1 * d1 + d2 * d2 + d3 * d3;
+	}
+	for (; i < n; i++) {
+		const d = x[i] - y[i];
+		r += d * d;
+	}
+	return r;
+}
+/** alternative_cosine (distances.py:583-630). */
+function alternativeCosine(x, y) {
+	let dot = 0;
+	let nx = 0;
+	let ny = 0;
+	for (let i = 0; i < x.length; i++) {
+		dot += x[i] * y[i];
+		nx += x[i] * x[i];
+		ny += y[i] * y[i];
+	}
+	if (nx === 0 && ny === 0) return 0;
+	if (nx === 0 || ny === 0) return FLOAT32_MAX;
+	if (dot <= 0) return FLOAT32_MAX;
+	return Math.log2(Math.sqrt(nx * ny) / dot);
+}
+/** alternative_hellinger (distances.py:1387-1416). */
+function alternativeHellinger(x, y) {
+	let result = 0;
+	let l1x = 0;
+	let l1y = 0;
+	for (let i = 0; i < x.length; i++) {
+		result += Math.sqrt(x[i] * y[i]);
+		l1x += x[i];
+		l1y += y[i];
+	}
+	if (l1x === 0 && l1y === 0) return 0;
+	if (l1x === 0 || l1y === 0) return FLOAT32_MAX;
+	if (result <= 0) return FLOAT32_MAX;
+	return Math.log2(Math.sqrt(l1x * l1y) / result);
+}
+/** alternative_jaccard (distances.py:259-336 family). */
+function alternativeJaccard(x, y) {
+	let numNonZero = 0;
+	let numEqual = 0;
+	for (let i = 0; i < x.length; i++) {
+		const xt = x[i] !== 0;
+		const yt = y[i] !== 0;
+		numNonZero += xt || yt ? 1 : 0;
+		numEqual += xt && yt ? 1 : 0;
+	}
+	if (numNonZero === 0) return 0;
+	if (numEqual === 0) return FLOAT32_MAX;
+	return -Math.log2(numEqual / numNonZero);
+}
+const identity = (d) => d;
+/** Metric names that switch NNDescent to angular trees (pynndescent_.py:1059-1077). */
+const ANGULAR_TREE_METRICS = new Set([
+	"cosine",
+	"dot",
+	"correlation",
+	"dice",
+	"jaccard",
+	"hellinger",
+	"hamming"
+]);
+/**
+* Resolve the internal metric + correction for NN-descent
+* (fast_distance_alternatives, distances.py:2170-2188).
+*/
+function resolveInternalMetric(name, options) {
+	const angularTrees = ANGULAR_TREE_METRICS.has(name);
+	switch (name) {
+		case "euclidean":
+		case "l2": return {
+			dist: squaredEuclidean,
+			correction: (d) => Math.sqrt(d),
+			angularTrees
+		};
+		case "cosine": return {
+			dist: alternativeCosine,
+			correction: (d) => 1 - 2 ** -d,
+			angularTrees
+		};
+		case "hellinger": return {
+			dist: alternativeHellinger,
+			correction: (d) => Math.sqrt(1 - 2 ** -d),
+			angularTrees
+		};
+		case "jaccard": return {
+			dist: alternativeJaccard,
+			correction: (d) => 1 - 2 ** -d,
+			angularTrees
+		};
+		default: return {
+			dist: resolveMetric(name, options),
+			correction: identity,
+			angularTrees
+		};
+	}
+}
+/** sparse_squared_euclidean (sparse.py:383-408). */
+function sparseSquaredEuclidean(ind1, data1, ind2, data2) {
+	let r = 0;
+	let i1 = 0;
+	let i2 = 0;
+	while (i1 < ind1.length && i2 < ind2.length) {
+		const c1 = ind1[i1];
+		const c2 = ind2[i2];
+		if (c1 === c2) {
+			const d = data1[i1] - data2[i2];
+			r += d * d;
+			i1++;
+			i2++;
+		} else if (c1 < c2) {
+			r += data1[i1] * data1[i1];
+			i1++;
+		} else {
+			r += data2[i2] * data2[i2];
+			i2++;
+		}
+	}
+	while (i1 < ind1.length) {
+		r += data1[i1] * data1[i1];
+		i1++;
+	}
+	while (i2 < ind2.length) {
+		r += data2[i2] * data2[i2];
+		i2++;
+	}
+	return r;
+}
+/** sparse_alternative_cosine (sparse.py:632-659). */
+function sparseAlternativeCosine(ind1, data1, ind2, data2) {
+	let dot = 0;
+	let i1 = 0;
+	let i2 = 0;
+	while (i1 < ind1.length && i2 < ind2.length) {
+		const c1 = ind1[i1];
+		const c2 = ind2[i2];
+		if (c1 === c2) {
+			dot += data1[i1] * data2[i2];
+			i1++;
+			i2++;
+		} else if (c1 < c2) i1++;
+		else i2++;
+	}
+	let nx = 0;
+	for (let i = 0; i < data1.length; i++) nx += data1[i] * data1[i];
+	let ny = 0;
+	for (let i = 0; i < data2.length; i++) ny += data2[i] * data2[i];
+	if (nx === 0 && ny === 0) return 0;
+	if (nx === 0 || ny === 0) return FLOAT32_MAX;
+	if (dot <= 0) return FLOAT32_MAX;
+	return Math.log2(Math.sqrt(nx * ny) / dot);
+}
+/** sparse_correct_alternative_cosine clamps near-zero/negative to 0 (sparse.py:662-667). */
+function sparseCorrectAlternativeCosine(d) {
+	if (Math.abs(d) < 1e-7 || d < 0) return 0;
+	return 1 - 2 ** -d;
+}
+function resolveSparseInternalMetric(name) {
+	switch (name) {
+		case "euclidean":
+		case "l2": return {
+			dist: sparseSquaredEuclidean,
+			correction: (d) => Math.sqrt(d),
+			angularTrees: false
+		};
+		case "cosine": return {
+			dist: sparseAlternativeCosine,
+			correction: sparseCorrectAlternativeCosine,
+			angularTrees: true
+		};
+		default: throw new Error(`sparse metric '${name}' is not supported (euclidean, cosine)`);
+	}
+}
+
+//#endregion
+//#region src/knn/exact.ts
+/** Row-wise exact kNN for dense data. Accepts a named metric or a custom MetricFn. */
+function exactKnnDense(X, k, metricName, { metricOptions = {}, disconnectionDistance = Infinity } = {}) {
+	const { rows: n, cols: d, data } = X;
+	const metric = typeof metricName === "function" ? metricName : resolveMetric(metricName, metricOptions);
+	const fastEuclidean = metricName === "euclidean" || metricName === "l2";
+	const indices = new Int32Array(n * k);
+	const distances = new Float32Array(n * k);
+	const rowDist = new Float64Array(n);
+	const order = new Int32Array(n);
+	const heapIdx = new Int32Array(k);
+	const heapDst = new Float64Array(k);
+	for (let i = 0; i < n; i++) {
+		const xi = data.subarray(i * d, (i + 1) * d);
+		if (fastEuclidean) {
+			const base = i * d;
+			for (let j = 0; j < n; j++) {
+				const jb = j * d;
+				let r = 0;
+				for (let c = 0; c < d; c++) {
+					const dd = data[base + c] - data[jb + c];
+					r += dd * dd;
+				}
+				rowDist[j] = r;
+			}
+		} else for (let j = 0; j < n; j++) rowDist[j] = metric(xi, data.subarray(j * d, (j + 1) * d));
+		selectKSmallest(rowDist, n, k, heapIdx, heapDst, order);
+		for (let j = 0; j < k; j++) {
+			let dist = heapDst[j];
+			if (fastEuclidean) dist = Math.sqrt(dist);
+			if (dist >= disconnectionDistance) {
+				indices[i * k + j] = -1;
+				distances[i * k + j] = Infinity;
+			} else {
+				indices[i * k + j] = heapIdx[j];
+				distances[i * k + j] = dist;
+			}
+		}
+	}
+	return {
+		indices,
+		distances,
+		k
+	};
+}
+/**
+* Select k smallest of rowDist[0..n) with ties broken by smaller index (matching
+* a stable argsort); outputs sorted ascending into heapIdx/heapDst.
+*/
+function selectKSmallest(rowDist, n, k, outIdx, outDst, scratchOrder) {
+	let count = 0;
+	const gt = (d1, i1, d2, i2) => d1 > d2 || d1 === d2 && i1 > i2;
+	for (let j = 0; j < n; j++) {
+		const dj = rowDist[j];
+		if (count < k) {
+			let c = count++;
+			outDst[c] = dj;
+			outIdx[c] = j;
+			while (c > 0) {
+				const parent = c - 1 >> 1;
+				if (gt(outDst[c], outIdx[c], outDst[parent], outIdx[parent])) {
+					swap(outDst, outIdx, c, parent);
+					c = parent;
+				} else break;
+			}
+		} else if (gt(outDst[0], outIdx[0], dj, j)) {
+			outDst[0] = dj;
+			outIdx[0] = j;
+			let c = 0;
+			for (;;) {
+				const l = 2 * c + 1;
+				const r = l + 1;
+				let m = c;
+				if (l < k && gt(outDst[l], outIdx[l], outDst[m], outIdx[m])) m = l;
+				if (r < k && gt(outDst[r], outIdx[r], outDst[m], outIdx[m])) m = r;
+				if (m === c) break;
+				swap(outDst, outIdx, c, m);
+				c = m;
+			}
+		}
+	}
+	for (let j = count; j < k; j++) {
+		outDst[j] = Infinity;
+		outIdx[j] = -1;
+	}
+	for (let j = 0; j < k; j++) scratchOrder[j] = j;
+	const idxArr = Array.from({ length: k }, (_, j) => j);
+	idxArr.sort((a, b) => outDst[a] - outDst[b] || outIdx[a] - outIdx[b]);
+	const tmpD = new Float64Array(k);
+	const tmpI = new Int32Array(k);
+	for (let j = 0; j < k; j++) {
+		tmpD[j] = outDst[idxArr[j]];
+		tmpI[j] = outIdx[idxArr[j]];
+	}
+	outDst.set(tmpD);
+	outIdx.set(tmpI);
+}
+function swap(d, i, a, b) {
+	const td = d[a];
+	d[a] = d[b];
+	d[b] = td;
+	const ti = i[a];
+	i[a] = i[b];
+	i[b] = ti;
+}
+/** Exact kNN for CSR input (euclidean or cosine). */
+function exactKnnSparse(X, k, metricName) {
+	const n = X.rows;
+	const internal = resolveSparseInternalMetric(metricName);
+	const indices = new Int32Array(n * k);
+	const distances = new Float32Array(n * k);
+	const rowDist = new Float64Array(n);
+	const heapIdx = new Int32Array(k);
+	const heapDst = new Float64Array(k);
+	const order = new Int32Array(n);
+	const rowInd = (i) => X.indices.subarray(X.indptr[i], X.indptr[i + 1]);
+	const rowDat = (i) => X.data.subarray(X.indptr[i], X.indptr[i + 1]);
+	for (let i = 0; i < n; i++) {
+		const ii = rowInd(i);
+		const di = rowDat(i);
+		for (let j = 0; j < n; j++) rowDist[j] = internal.dist(ii, di, rowInd(j), rowDat(j));
+		selectKSmallest(rowDist, n, k, heapIdx, heapDst, order);
+		for (let j = 0; j < k; j++) {
+			indices[i * k + j] = heapIdx[j];
+			distances[i * k + j] = internal.correction(heapDst[j]);
+		}
+	}
+	return {
+		indices,
+		distances,
+		k
+	};
+}
+/**
+* metric='precomputed': X is a dense n×n distance matrix; per-row argsort prefix
+* (umap_.py:312-324); infinite distances → index -1.
+*/
+function knnFromPrecomputed(X, k) {
+	const n = X.rows;
+	if (X.cols !== n) throw new UmapValidationError(`precomputed distance matrix must be square, got ${n}x${X.cols}`);
+	const indices = new Int32Array(n * k);
+	const distances = new Float32Array(n * k);
+	const heapIdx = new Int32Array(k);
+	const heapDst = new Float64Array(k);
+	const order = new Int32Array(n);
+	const rowDist = new Float64Array(n);
+	for (let i = 0; i < n; i++) {
+		for (let j = 0; j < n; j++) rowDist[j] = X.data[i * n + j];
+		selectKSmallest(rowDist, n, k, heapIdx, heapDst, order);
+		for (let j = 0; j < k; j++) {
+			const dist = heapDst[j];
+			if (dist === Infinity) {
+				indices[i * k + j] = -1;
+				distances[i * k + j] = Infinity;
+			} else {
+				indices[i * k + j] = heapIdx[j];
+				distances[i * k + j] = dist;
+			}
+		}
+	}
+	return {
+		indices,
+		distances,
+		k
+	};
+}
+
+//#endregion
+//#region src/rng.ts
+/**
+* Seeded PRNG — PCG32 (O'Neill, pcg-random.org), the reproducible generator of §5.5.
+*
+* Test vectors in test/unit/rng.test.ts were generated from the canonical C reference
+* (pcg_basic.c) compiled locally; the first draw for seed(42, 54) is 0xa15c02b7,
+* matching the published pcg32-demo output.
+*
+* 64-bit state is held as two u32 words; the LCG multiply uses exact 16-bit limb
+* arithmetic (all intermediates < 2^53).
+*/
+const MULT_HI = 1481765933;
+const MULT_LO = 1284865837;
+var Pcg32 = class Pcg32 {
+	sHi = 0;
+	sLo = 0;
+	iHi = 0;
+	iLo = 0;
+	spareNormal = null;
+	constructor(seedHi, seedLo, seqHi, seqLo) {
+		this.iHi = (seqHi << 1 | seqLo >>> 31) >>> 0;
+		this.iLo = (seqLo << 1 | 1) >>> 0;
+		this.sHi = 0;
+		this.sLo = 0;
+		this.nextU32();
+		const lo = this.sLo + (seedLo >>> 0);
+		this.sLo = lo >>> 0;
+		this.sHi = this.sHi + (seedHi >>> 0) + (lo > 4294967295 ? 1 : 0) >>> 0;
+		this.nextU32();
+	}
+	/** Derive from a JS number seed (integer-valued; uses full 53-bit range). */
+	static fromSeed(seed, stream = 54) {
+		const s = Math.abs(Math.floor(seed));
+		return new Pcg32(Math.floor(s / 4294967296) >>> 0, s >>> 0, 0, stream >>> 0);
+	}
+	nextU32() {
+		const oHi = this.sHi;
+		const oLo = this.sLo;
+		const a0 = oLo & 65535;
+		const a1 = oLo >>> 16;
+		const a2 = oHi & 65535;
+		const a3 = oHi >>> 16;
+		const b0 = MULT_LO & 65535;
+		const b1 = MULT_LO >>> 16;
+		const b2 = MULT_HI & 65535;
+		const b3 = MULT_HI >>> 16;
+		const p0 = a0 * b0;
+		const p1 = a1 * b0 + a0 * b1;
+		const p2 = a2 * b0 + a1 * b1 + a0 * b2;
+		const p3 = a3 * b0 + a2 * b1 + a1 * b2 + a0 * b3;
+		let l0 = p0 & 65535;
+		let acc = Math.floor(p0 / 65536) + p1;
+		let l1 = acc & 65535;
+		acc = Math.floor(acc / 65536) + p2;
+		let l2 = acc & 65535;
+		acc = Math.floor(acc / 65536) + p3;
+		let l3 = acc & 65535;
+		let s = l0 + (this.iLo & 65535);
+		l0 = s & 65535;
+		s = l1 + (this.iLo >>> 16) + (s >>> 16);
+		l1 = s & 65535;
+		s = l2 + (this.iHi & 65535) + (s >>> 16);
+		l2 = s & 65535;
+		s = l3 + (this.iHi >>> 16) + (s >>> 16);
+		l3 = s & 65535;
+		this.sLo = (l1 << 16 | l0) >>> 0;
+		this.sHi = (l3 << 16 | l2) >>> 0;
+		const xHi = (oHi ^ oHi >>> 18) >>> 0;
+		const xLo = (oLo ^ (oHi << 14 | oLo >>> 18)) >>> 0;
+		const xorshifted = (xHi << 5 | xLo >>> 27) >>> 0;
+		const rot = oHi >>> 27;
+		return (xorshifted >>> rot | xorshifted << (-rot & 31)) >>> 0;
+	}
+	/** Uniform float in [0, 1). */
+	nextFloat() {
+		return this.nextU32() * 23283064365386963e-26;
+	}
+	/** Uniform float in [lo, hi). */
+	uniform(lo, hi) {
+		return lo + (hi - lo) * this.nextFloat();
+	}
+	/** Integer in [0, n) — modulo method (matches umap's structural usage). */
+	randint(n) {
+		return this.nextU32() % n;
+	}
+	/** Integer in [lo, hi) like numpy randint. */
+	randintRange(lo, hi) {
+		return lo + this.nextU32() % (hi - lo);
+	}
+	/** Standard normal via Box–Muller (cached spare). */
+	normal() {
+		if (this.spareNormal !== null) {
+			const v$1 = this.spareNormal;
+			this.spareNormal = null;
+			return v$1;
+		}
+		let u = 0;
+		let v = 0;
+		do
+			u = this.nextFloat();
+		while (u <= 1e-12);
+		v = this.nextFloat();
+		const r = Math.sqrt(-2 * Math.log(u));
+		const theta = 2 * Math.PI * v;
+		this.spareNormal = r * Math.sin(theta);
+		return r * Math.cos(theta);
+	}
+	/** In-place Fisher–Yates shuffle. */
+	shuffle(arr) {
+		for (let i = arr.length - 1; i > 0; i--) {
+			const j = this.randint(i + 1);
+			const t = arr[i];
+			arr[i] = arr[j];
+			arr[j] = t;
+		}
+	}
+	/**
+	* Seed a 3-word tau state like Python's
+	* `random_state.randint(INT32_MIN, INT32_MAX, 3)` (values in int32 range).
+	*/
+	tauState() {
+		const st = new Int32Array(3);
+		for (let i = 0; i < 3; i++) st[i] = this.nextU32() | 0;
+		return st;
+	}
+	/** Snapshot the full generator state (backend-fallback rng restoration). */
+	clone() {
+		const c = new Pcg32(0, 0, 0, 0);
+		c.sHi = this.sHi;
+		c.sLo = this.sLo;
+		c.iHi = this.iHi;
+		c.iLo = this.iLo;
+		c.spareNormal = this.spareNormal;
+		return c;
+	}
+	/** Restore state from a clone() snapshot (un-consumes draws after the snapshot). */
+	restoreFrom(snapshot) {
+		this.sHi = snapshot.sHi;
+		this.sLo = snapshot.sLo;
+		this.iHi = snapshot.iHi;
+		this.iLo = snapshot.iLo;
+		this.spareNormal = snapshot.spareNormal;
+	}
+};
+/**
+* taus88 combined Tausworthe step, structurally identical to umap's `tau_rand_int`
+* but on u32 words (Python runs it on int64 with 32-bit truncations). Used for the
+* SGD negative-sampling stream; parity with Python is statistical, not bitwise (§5.5).
+* Returns a signed int32.
+*/
+function tauRandInt(state) {
+	const s0 = state[0] >>> 0;
+	const s1 = state[1] >>> 0;
+	const s2 = state[2] >>> 0;
+	state[0] = (s0 & 4294967294) << 12 ^ (s0 << 13 >>> 0 ^ s0) >>> 19 | 0;
+	state[1] = (s1 & 4294967288) << 4 ^ (s1 << 2 >>> 0 ^ s1) >>> 25 | 0;
+	state[2] = (s2 & 4294967280) << 17 ^ (s2 << 3 >>> 0 ^ s2) >>> 11 | 0;
+	return state[0] ^ state[1] ^ state[2] | 0;
+}
+/** Floor-mod (Python `%` semantics) of a signed int by a positive int. */
+function floorMod(a, n) {
+	const r = a % n;
+	return r < 0 ? r + n : r;
+}
+/** tau_rand: uniform in [0,1] from tauRandInt (umap utils.py:66-80). */
+function tauRand(state) {
+	return Math.abs(tauRandInt(state) / 2147483647);
+}
+
+//#endregion
+//#region src/knn/heap.ts
+function makeHeap(n, size) {
+	return {
+		indices: new Int32Array(n * size).fill(-1),
+		distances: new Float32Array(n * size).fill(Infinity),
+		flags: new Uint8Array(n * size),
+		n,
+		size
+	};
+}
+/**
+* checked_flagged_heap_push (utils.py:471-533). Operates on one row given by base
+* offset. Rejects p >= root (ties dropped) and duplicates. Returns 1 if pushed.
+*/
+function checkedFlaggedHeapPush(heap, row, p, n, f) {
+	const size = heap.size;
+	const base = row * size;
+	const priorities = heap.distances;
+	const indices = heap.indices;
+	const flags = heap.flags;
+	if (p >= priorities[base]) return 0;
+	for (let i$1 = 0; i$1 < size; i$1++) if (indices[base + i$1] === n) return 0;
+	let i = 0;
+	for (;;) {
+		const ic1 = 2 * i + 1;
+		const ic2 = ic1 + 1;
+		let iSwap;
+		if (ic1 >= size) break;
+		if (ic2 >= size) if (priorities[base + ic1] > p) iSwap = ic1;
+		else break;
+		else if (priorities[base + ic1] >= priorities[base + ic2]) if (p < priorities[base + ic1]) iSwap = ic1;
+		else break;
+		else if (p < priorities[base + ic2]) iSwap = ic2;
+		else break;
+		priorities[base + i] = priorities[base + iSwap];
+		indices[base + i] = indices[base + iSwap];
+		flags[base + i] = flags[base + iSwap];
+		i = iSwap;
+	}
+	priorities[base + i] = p;
+	indices[base + i] = n;
+	flags[base + i] = f;
+	return 1;
+}
+/** checked_heap_push (utils.py:409-468) — no flags. */
+function checkedHeapPush(priorities, indices, base, size, p, n) {
+	if (p >= priorities[base]) return 0;
+	for (let i$1 = 0; i$1 < size; i$1++) if (indices[base + i$1] === n) return 0;
+	let i = 0;
+	for (;;) {
+		const ic1 = 2 * i + 1;
+		const ic2 = ic1 + 1;
+		let iSwap;
+		if (ic1 >= size) break;
+		if (ic2 >= size) if (priorities[base + ic1] > p) iSwap = ic1;
+		else break;
+		else if (priorities[base + ic1] >= priorities[base + ic2]) if (p < priorities[base + ic1]) iSwap = ic1;
+		else break;
+		else if (p < priorities[base + ic2]) iSwap = ic2;
+		else break;
+		priorities[base + i] = priorities[base + iSwap];
+		indices[base + i] = indices[base + iSwap];
+		i = iSwap;
+	}
+	priorities[base + i] = p;
+	indices[base + i] = n;
+	return 1;
+}
+/** simple_heap_push (utils.py:352-406) — no duplicate scan (query uses visited mask). */
+function simpleHeapPush(priorities, indices, size, p, n) {
+	if (p >= priorities[0]) return 0;
+	let i = 0;
+	for (;;) {
+		const ic1 = 2 * i + 1;
+		const ic2 = ic1 + 1;
+		let iSwap;
+		if (ic1 >= size) break;
+		if (ic2 >= size) if (priorities[ic1] > p) iSwap = ic1;
+		else break;
+		else if (priorities[ic1] >= priorities[ic2]) if (p < priorities[ic1]) iSwap = ic1;
+		else break;
+		else if (p < priorities[ic2]) iSwap = ic2;
+		else break;
+		priorities[i] = priorities[iSwap];
+		indices[i] = indices[iSwap];
+		i = iSwap;
+	}
+	priorities[i] = p;
+	indices[i] = n;
+	return 1;
+}
+function siftdownRange(distances, indices, base, len, elt) {
+	let e = elt;
+	while (e * 2 + 1 < len) {
+		const leftChild = e * 2 + 1;
+		const rightChild = leftChild + 1;
+		let swap$1 = e;
+		if (distances[base + swap$1] < distances[base + leftChild]) swap$1 = leftChild;
+		if (rightChild < len && distances[base + swap$1] < distances[base + rightChild]) swap$1 = rightChild;
+		if (swap$1 === e) break;
+		const td = distances[base + e];
+		distances[base + e] = distances[base + swap$1];
+		distances[base + swap$1] = td;
+		const ti = indices[base + e];
+		indices[base + e] = indices[base + swap$1];
+		indices[base + swap$1] = ti;
+		e = swap$1;
+	}
+}
+/** deheap_sort (utils.py:189-218): per-row heapsort → ascending, (-1, inf) tail. */
+function deheapSort(heap) {
+	const { indices, distances, n, size } = heap;
+	for (let r = 0; r < n; r++) {
+		const base = r * size;
+		for (let j = size - 1; j > 0; j--) {
+			const td = distances[base];
+			distances[base] = distances[base + j];
+			distances[base + j] = td;
+			const ti = indices[base];
+			indices[base] = indices[base + j];
+			indices[base + j] = ti;
+			siftdownRange(distances, indices, base, j, 0);
+		}
+	}
+}
+
+//#endregion
+//#region src/knn/nndescent.ts
+/** init_rp_tree: all pairs within each leaf. */
+function initRpTree(nLeaves, leafCols, leafArray, heap, dist, leafAcceptance = "max") {
+	const k = heap.size;
+	const distances = heap.distances;
+	const either = leafAcceptance === "either";
+	for (let leaf = 0; leaf < nLeaves; leaf++) {
+		const base = leaf * leafCols;
+		for (let a = 0; a < leafCols; a++) {
+			const p = leafArray[base + a];
+			if (p < 0) break;
+			for (let b = a + 1; b < leafCols; b++) {
+				const q = leafArray[base + b];
+				if (q < 0) break;
+				const d = dist(p, q);
+				if (either ? d < distances[p * k] || d < distances[q * k] : d < Math.max(distances[p * k], distances[q * k])) {
+					checkedFlaggedHeapPush(heap, p, d, q, 1);
+					checkedFlaggedHeapPush(heap, q, d, p, 1);
+				}
+			}
+		}
+	}
+}
+/** init_random: one attempt per missing slot (pynndescent_.py:188-203). */
+function initRandom(n, heap, dist, rngState) {
+	const k = heap.size;
+	for (let i = 0; i < n; i++) if (heap.indices[i * k] < 0) {
+		let filled = 0;
+		for (let j = 0; j < k; j++) if (heap.indices[i * k + j] >= 0) filled++;
+		const missing = k - filled;
+		for (let j = 0; j < missing; j++) {
+			const idx = Math.abs(tauRandInt(rngState)) % n;
+			const d = dist(idx, i);
+			checkedFlaggedHeapPush(heap, i, d, idx, 1);
+		}
+	}
+}
+/**
+* new_build_candidates (utils.py:221-320): sample up to maxCandidates new/old
+* candidates per vertex via random priorities; clear "new" flags for sampled entries.
+* The master rng state is NOT advanced (per-thread copies in Python; thread 0 here).
+*/
+function buildCandidates(heap, maxCandidates, masterRng) {
+	const n = heap.n;
+	const k = heap.size;
+	const newIdx = new Int32Array(n * maxCandidates).fill(-1);
+	const newPri = new Float32Array(n * maxCandidates).fill(Infinity);
+	const oldIdx = new Int32Array(n * maxCandidates).fill(-1);
+	const oldPri = new Float32Array(n * maxCandidates).fill(Infinity);
+	const localRng = Int32Array.from(masterRng);
+	for (let i = 0; i < n; i++) for (let j = 0; j < k; j++) {
+		const idx = heap.indices[i * k + j];
+		if (idx < 0) continue;
+		const d = tauRand(localRng);
+		if (heap.flags[i * k + j] === 1) {
+			checkedHeapPush(newPri, newIdx, i * maxCandidates, maxCandidates, d, idx);
+			checkedHeapPush(newPri, newIdx, idx * maxCandidates, maxCandidates, d, i);
+		} else {
+			checkedHeapPush(oldPri, oldIdx, i * maxCandidates, maxCandidates, d, idx);
+			checkedHeapPush(oldPri, oldIdx, idx * maxCandidates, maxCandidates, d, i);
+		}
+	}
+	for (let i = 0; i < n; i++) for (let j = 0; j < k; j++) {
+		const idx = heap.indices[i * k + j];
+		if (idx < 0 || heap.flags[i * k + j] !== 1) continue;
+		const cbase = i * maxCandidates;
+		for (let c = 0; c < maxCandidates; c++) if (newIdx[cbase + c] === idx) {
+			heap.flags[i * k + j] = 0;
+			break;
+		}
+	}
+	return {
+		newIdx,
+		oldIdx
+	};
+}
+/** Local joins over candidate lists; returns number of successful pushes. */
+function processCandidates(heap, newIdx, oldIdx, maxCandidates, dist) {
+	const n = heap.n;
+	const k = heap.size;
+	const distances = heap.distances;
+	let c = 0;
+	for (let i = 0; i < n; i++) {
+		const base = i * maxCandidates;
+		for (let j = 0; j < maxCandidates; j++) {
+			const p = newIdx[base + j];
+			if (p < 0) continue;
+			for (let t = j; t < maxCandidates; t++) {
+				const q = newIdx[base + t];
+				if (q < 0) continue;
+				const d = dist(p, q);
+				if (d <= Math.max(distances[p * k], distances[q * k])) {
+					c += checkedFlaggedHeapPush(heap, p, d, q, 1);
+					c += checkedFlaggedHeapPush(heap, q, d, p, 1);
+				}
+			}
+			for (let t = 0; t < maxCandidates; t++) {
+				const q = oldIdx[base + t];
+				if (q < 0) continue;
+				const d = dist(p, q);
+				if (d <= Math.max(distances[p * k], distances[q * k])) {
+					c += checkedFlaggedHeapPush(heap, p, d, q, 1);
+					c += checkedFlaggedHeapPush(heap, q, d, p, 1);
+				}
+			}
+		}
+	}
+	return c;
+}
+/**
+* Full NN-descent. `leafArray` from the RP forest (or null to skip tree init).
+* Returns the heap AFTER deheap_sort: ascending distances, (-1, inf) tails.
+* Distances are in the INTERNAL metric space (corrections applied by the caller).
+*/
+function nnDescent(n, nNeighbors, dist, rngState, leafArray, { maxCandidates = 60, nIters = 10, delta = .001, leafAcceptance = "max", onIteration } = {}) {
+	const heap = makeHeap(n, nNeighbors);
+	if (leafArray) initRpTree(leafArray.rows, leafArray.cols, leafArray.data, heap, dist, leafAcceptance);
+	initRandom(n, heap, dist, rngState);
+	for (let iter = 0; iter < nIters; iter++) {
+		const { newIdx, oldIdx } = buildCandidates(heap, maxCandidates, rngState);
+		const c = processCandidates(heap, newIdx, oldIdx, maxCandidates, dist);
+		onIteration?.(iter, c);
+		if (c <= delta * nNeighbors * n) break;
+	}
+	deheapSort(heap);
+	return heap;
+}
+/** umap's NNDescent parameter rules (umap_.py:327-328). */
+function umapNnDescentParams(n) {
+	return {
+		nTrees: Math.min(64, 5 + Math.round(Math.sqrt(n) / 20)),
+		nIters: Math.max(5, Math.round(Math.log2(n)))
+	};
+}
+
+//#endregion
+//#region src/knn/rpforest.ts
+const RP_EPS = 1e-8;
+const MIN_SPLIT_BALANCE = .1;
+function defaultLeafSize(nNeighbors) {
+	return Math.max(60, Math.min(256, 5 * nNeighbors));
+}
+function partition(indices, side, nLeft, nRight) {
+	const left = new Int32Array(nLeft);
+	const right = new Int32Array(nRight);
+	let il = 0;
+	let ir = 0;
+	for (let i = 0; i < indices.length; i++) if (side[i] === 0) left[il++] = indices[i];
+	else right[ir++] = indices[i];
+	return {
+		left,
+		right
+	};
+}
+function euclideanSplit(data, dim, indices, rngState) {
+	const n = indices.length;
+	const leftIndex = floorMod(tauRandInt(rngState), n);
+	let rightIndex = floorMod(tauRandInt(rngState), n);
+	if (leftIndex === rightIndex) rightIndex += 1;
+	rightIndex = floorMod(rightIndex, n);
+	const l = indices[leftIndex];
+	const r = indices[rightIndex];
+	const hyperplane = new Float32Array(dim);
+	let offset = 0;
+	for (let d = 0; d < dim; d++) {
+		const hv = data[l * dim + d] - data[r * dim + d];
+		hyperplane[d] = hv;
+		offset -= hv * (data[l * dim + d] + data[r * dim + d]) / 2;
+	}
+	const side = new Uint8Array(n);
+	let nLeft = 0;
+	let nRight = 0;
+	for (let i = 0; i < n; i++) {
+		let margin = offset;
+		const p = indices[i];
+		for (let d = 0; d < dim; d++) margin += hyperplane[d] * data[p * dim + d];
+		if (Math.abs(margin) < RP_EPS) side[i] = Math.abs(tauRandInt(rngState)) % 2;
+		else if (margin > 0) side[i] = 0;
+		else side[i] = 1;
+		if (side[i] === 0) nLeft++;
+		else nRight++;
+	}
+	if (nLeft === 0 || nRight === 0) {
+		nLeft = 0;
+		nRight = 0;
+		for (let i = 0; i < n; i++) {
+			side[i] = floorMod(tauRandInt(rngState), 2);
+			if (side[i] === 0) nLeft++;
+			else nRight++;
+		}
+	}
+	const { left, right } = partition(indices, side, nLeft, nRight);
+	return {
+		left,
+		right,
+		hyperplane,
+		offset
+	};
+}
+function angularSplit(data, dim, indices, rngState) {
+	const n = indices.length;
+	const leftIndex = floorMod(tauRandInt(rngState), n);
+	let rightIndex = floorMod(tauRandInt(rngState), n);
+	if (leftIndex === rightIndex) rightIndex += 1;
+	rightIndex = floorMod(rightIndex, n);
+	const l = indices[leftIndex];
+	const r = indices[rightIndex];
+	let leftNorm = 0;
+	let rightNorm = 0;
+	for (let d = 0; d < dim; d++) {
+		leftNorm += data[l * dim + d] * data[l * dim + d];
+		rightNorm += data[r * dim + d] * data[r * dim + d];
+	}
+	leftNorm = Math.sqrt(leftNorm);
+	rightNorm = Math.sqrt(rightNorm);
+	if (Math.abs(leftNorm) < RP_EPS) leftNorm = 1;
+	if (Math.abs(rightNorm) < RP_EPS) rightNorm = 1;
+	const hyperplane = new Float32Array(dim);
+	let hnorm = 0;
+	for (let d = 0; d < dim; d++) {
+		const hv = data[l * dim + d] / leftNorm - data[r * dim + d] / rightNorm;
+		hyperplane[d] = hv;
+		hnorm += hv * hv;
+	}
+	hnorm = Math.sqrt(hnorm);
+	if (Math.abs(hnorm) < RP_EPS) hnorm = 1;
+	for (let d = 0; d < dim; d++) hyperplane[d] = hyperplane[d] / hnorm;
+	const side = new Uint8Array(n);
+	let nLeft = 0;
+	let nRight = 0;
+	for (let i = 0; i < n; i++) {
+		let margin = 0;
+		const p = indices[i];
+		for (let d = 0; d < dim; d++) margin += hyperplane[d] * data[p * dim + d];
+		if (Math.abs(margin) < RP_EPS) side[i] = floorMod(tauRandInt(rngState), 2);
+		else if (margin > 0) side[i] = 0;
+		else side[i] = 1;
+		if (side[i] === 0) nLeft++;
+		else nRight++;
+	}
+	if (nLeft === 0 || nRight === 0) {
+		nLeft = 0;
+		nRight = 0;
+		for (let i = 0; i < n; i++) {
+			side[i] = floorMod(tauRandInt(rngState), 2);
+			if (side[i] === 0) nLeft++;
+			else nRight++;
+		}
+	}
+	const { left, right } = partition(indices, side, nLeft, nRight);
+	return {
+		left,
+		right,
+		hyperplane,
+		offset: 0
+	};
+}
+function buildTree(data, dim, indices, leafSize, maxDepth, angular, rngState) {
+	if (indices.length > leafSize && maxDepth > 0) {
+		const { left, right, hyperplane, offset } = angular ? angularSplit(data, dim, indices, rngState) : euclideanSplit(data, dim, indices, rngState);
+		return {
+			left: buildTree(data, dim, left, leafSize, maxDepth - 1, angular, rngState),
+			right: buildTree(data, dim, right, leafSize, maxDepth - 1, angular, rngState),
+			hyperplane,
+			offset,
+			points: null
+		};
+	}
+	return {
+		left: null,
+		right: null,
+		hyperplane: null,
+		offset: 0,
+		points: indices
+	};
+}
+/** Flatten to preorder (convert_tree_format, rp_trees.py:3019-3049). */
+function flattenTree(root, nPoints, dim) {
+	let nNodes = 0;
+	let maxLeaf = 0;
+	const count = (node) => {
+		nNodes++;
+		if (node.points) {
+			if (node.points.length > maxLeaf) maxLeaf = node.points.length;
+		} else {
+			count(node.left);
+			count(node.right);
+		}
+	};
+	count(root);
+	const hyperplanes = new Float32Array(nNodes * dim);
+	const offsets = new Float32Array(nNodes);
+	const children = new Int32Array(nNodes * 2).fill(-1);
+	const indices = new Int32Array(nPoints).fill(-1);
+	let nodeNum = 0;
+	let leafStart = 0;
+	const walk = (node) => {
+		const my = nodeNum;
+		if (node.points) {
+			children[my * 2] = -leafStart;
+			children[my * 2 + 1] = -(leafStart + node.points.length);
+			indices.set(node.points, leafStart);
+			leafStart += node.points.length;
+			return;
+		}
+		hyperplanes.set(node.hyperplane, my * dim);
+		offsets[my] = node.offset;
+		nodeNum++;
+		children[my * 2] = nodeNum;
+		walk(node.left);
+		nodeNum++;
+		children[my * 2 + 1] = nodeNum;
+		walk(node.right);
+	};
+	walk(root);
+	return {
+		hyperplanes,
+		offsets,
+		children,
+		indices,
+		leafSize: maxLeaf,
+		nNodes,
+		dim
+	};
+}
+/** make_forest: per-tree tau states drawn from the master PRNG. */
+function makeForest(X, nNeighbors, nTrees, treeStates, { leafSize, angular = false, maxDepth = 200 } = {}) {
+	const ls = leafSize ?? defaultLeafSize(nNeighbors);
+	const all = new Int32Array(X.rows);
+	for (let i = 0; i < X.rows; i++) all[i] = i;
+	const forest = [];
+	for (let t = 0; t < nTrees; t++) {
+		const root = buildTree(X.data, X.cols, all.slice(), ls, maxDepth, angular, treeStates[t]);
+		forest.push(flattenTree(root, X.rows, X.cols));
+	}
+	return forest;
+}
+/** rptree_leaf_array: rows = leaves, padded with -1 to the forest-wide max leaf size. */
+function leafArrayFromForest(forest) {
+	if (forest.length === 0) return {
+		data: new Int32Array([-1]),
+		rows: 1,
+		cols: 1
+	};
+	let maxLeafSize = 0;
+	for (const t of forest) maxLeafSize = Math.max(maxLeafSize, t.leafSize);
+	const rows = [];
+	for (const t of forest) for (let node = 0; node < t.nNodes; node++) {
+		const c0 = t.children[node * 2];
+		if (c0 <= 0) {
+			const start = -c0;
+			const end = -t.children[node * 2 + 1];
+			const row = new Int32Array(maxLeafSize).fill(-1);
+			row.set(t.indices.subarray(start, end));
+			rows.push(row);
+		}
+	}
+	const out = new Int32Array(rows.length * maxLeafSize);
+	rows.forEach((r, i) => {
+		out.set(r, i * maxLeafSize);
+	});
+	return {
+		data: out,
+		rows: rows.length,
+		cols: maxLeafSize
+	};
+}
+/** search_flat_tree descent → [leafStart, leafEnd) into tree.indices. */
+function searchFlatTree(tree, point, rngState) {
+	let node = 0;
+	while (tree.children[node * 2] > 0) {
+		let margin = tree.offsets[node];
+		const base = node * tree.dim;
+		for (let d = 0; d < tree.dim; d++) margin += tree.hyperplanes[base + d] * point[d];
+		let side;
+		if (Math.abs(margin) < RP_EPS) side = Math.abs(tauRandInt(rngState)) % 2;
+		else side = margin > 0 ? 0 : 1;
+		node = tree.children[node * 2 + side];
+	}
+	return [-tree.children[node * 2], -tree.children[node * 2 + 1]];
+}
+function hubSplit(data, dim, indices, hubA, hubB, angular) {
+	const n = indices.length;
+	const hyperplane = new Float32Array(dim);
+	let offset = 0;
+	if (angular) {
+		let an = 0;
+		let bn = 0;
+		for (let d = 0; d < dim; d++) {
+			an += data[hubA * dim + d] * data[hubA * dim + d];
+			bn += data[hubB * dim + d] * data[hubB * dim + d];
+		}
+		an = Math.sqrt(an);
+		bn = Math.sqrt(bn);
+		if (Math.abs(an) < RP_EPS) an = 1;
+		if (Math.abs(bn) < RP_EPS) bn = 1;
+		let hn = 0;
+		for (let d = 0; d < dim; d++) {
+			const hv = data[hubA * dim + d] / an - data[hubB * dim + d] / bn;
+			hyperplane[d] = hv;
+			hn += hv * hv;
+		}
+		hn = Math.sqrt(hn);
+		if (Math.abs(hn) < RP_EPS) hn = 1;
+		for (let d = 0; d < dim; d++) hyperplane[d] = hyperplane[d] / hn;
+	} else for (let d = 0; d < dim; d++) {
+		const hv = data[hubA * dim + d] - data[hubB * dim + d];
+		hyperplane[d] = hv;
+		offset -= hv * (data[hubA * dim + d] + data[hubB * dim + d]) / 2;
+	}
+	const side = new Uint8Array(n);
+	let nLeft = 0;
+	let nRight = 0;
+	for (let i = 0; i < n; i++) {
+		let margin = offset;
+		const p = indices[i];
+		for (let d = 0; d < dim; d++) margin += hyperplane[d] * data[p * dim + d];
+		let s;
+		if (margin > RP_EPS) s = 0;
+		else if (margin < -RP_EPS) s = 1;
+		else s = i % 2;
+		side[i] = s;
+		if (s === 0) nLeft++;
+		else nRight++;
+	}
+	return {
+		hyperplane,
+		offset,
+		side,
+		nLeft,
+		nRight
+	};
+}
+/** make_hub_tree (rp_trees.py:1232-1312) — top-3-degree hub pairs, best balance. */
+function makeHubTree(X, knnIndices, leafSize = 30, angular = false, maxDepth = 200) {
+	const n = X.rows;
+	const degrees = new Int32Array(n);
+	for (let t = 0; t < knnIndices.length; t++) {
+		const j = knnIndices[t];
+		if (j >= 0) degrees[j]++;
+	}
+	const topHubs = (indices) => {
+		const top = [];
+		const topDeg = [];
+		for (let i = 0; i < indices.length; i++) {
+			const p = indices[i];
+			const dg = degrees[p];
+			let ins = -1;
+			for (let s = 0; s < Math.min(3, top.length + 1); s++) if (s >= top.length || dg > topDeg[s]) {
+				ins = s;
+				break;
+			}
+			if (ins >= 0) {
+				top.splice(ins, 0, p);
+				topDeg.splice(ins, 0, dg);
+				if (top.length > 3) {
+					top.pop();
+					topDeg.pop();
+				}
+			}
+		}
+		return top;
+	};
+	const build = (indices, depth) => {
+		if (indices.length <= leafSize || depth <= 0) return {
+			left: null,
+			right: null,
+			hyperplane: null,
+			offset: 0,
+			points: indices
+		};
+		const hubs = topHubs(indices);
+		let best = null;
+		let bestBalance = -1;
+		for (let a = 0; a < hubs.length; a++) for (let b = a + 1; b < hubs.length; b++) {
+			const res = hubSplit(X.data, X.cols, indices, hubs[a], hubs[b], angular);
+			if (res.nLeft === 0 || res.nRight === 0) continue;
+			const balance = Math.min(res.nLeft, res.nRight) / indices.length;
+			if (balance > bestBalance) {
+				bestBalance = balance;
+				best = res;
+			}
+		}
+		if (best === null || bestBalance < MIN_SPLIT_BALANCE) return {
+			left: null,
+			right: null,
+			hyperplane: null,
+			offset: 0,
+			points: indices
+		};
+		const { left, right } = partition(indices, best.side, best.nLeft, best.nRight);
+		return {
+			left: build(left, depth - 1),
+			right: build(right, depth - 1),
+			hyperplane: best.hyperplane,
+			offset: best.offset,
+			points: null
+		};
+	};
+	const all = new Int32Array(n);
+	for (let i = 0; i < n; i++) all[i] = i;
+	return flattenTree(build(all, maxDepth), n, X.cols);
+}
+
+//#endregion
+//#region src/knn/search.ts
+/** Forward diversify (pynndescent_.py:369-403) on sorted rows; prob = 1.0. */
+function diversifyRows(X, dist, knnIndices, knnDistances, k) {
+	const n = X.rows;
+	const d = X.cols;
+	for (let i = 0; i < n; i++) {
+		const base = i * k;
+		let retained = 1;
+		for (let j = 1; j < k; j++) {
+			const idxJ = knnIndices[base + j];
+			if (idxJ < 0) break;
+			let prune = false;
+			for (let c = 0; c < retained; c++) {
+				const idxC = knnIndices[base + c];
+				if (knnDistances[base + c] > FLOAT32_EPS) {
+					if (dist(X.data.subarray(idxJ * d, (idxJ + 1) * d), X.data.subarray(idxC * d, (idxC + 1) * d)) < knnDistances[base + j]) {
+						prune = true;
+						break;
+					}
+				}
+			}
+			if (!prune) {
+				knnIndices[base + retained] = idxJ;
+				knnDistances[base + retained] = knnDistances[base + j];
+				retained++;
+			}
+		}
+		for (let j = retained; j < k; j++) {
+			knnIndices[base + j] = -1;
+			knnDistances[base + j] = Infinity;
+		}
+	}
+}
+function csrTransposeF32(m) {
+	const nnz = m.indptr[m.n];
+	const counts = new Int32Array(m.n + 1);
+	for (let t = 0; t < nnz; t++) counts[m.indices[t] + 1]++;
+	for (let c = 0; c < m.n; c++) counts[c + 1] += counts[c];
+	const indptr = counts.slice();
+	const indices = new Int32Array(nnz);
+	const data = new Float32Array(nnz);
+	const cursor = counts.slice(0, m.n);
+	for (let r = 0; r < m.n; r++) for (let p = m.indptr[r]; p < m.indptr[r + 1]; p++) {
+		const c = m.indices[p];
+		const dst = cursor[c]++;
+		indices[dst] = r;
+		data[dst] = m.data[p];
+	}
+	return {
+		indptr,
+		indices,
+		data,
+		n: m.n
+	};
+}
+/** Reverse diversify (diversify_csr): per row in ascending-distance order. */
+function diversifyCsr(g, X, dist) {
+	const d = X.cols;
+	for (let r = 0; r < g.n; r++) {
+		const start = g.indptr[r];
+		const len = g.indptr[r + 1] - start;
+		if (len <= 1) continue;
+		const order = Array.from({ length: len }, (_, i) => i).sort((a, b) => g.data[start + a] - g.data[start + b]);
+		const retained = [];
+		for (const oi of order) {
+			const p = start + oi;
+			const colJ = g.indices[p];
+			const dj = g.data[p];
+			let prune = false;
+			for (const rp of retained) if (g.data[rp] > FLOAT32_EPS) {
+				if (dist(X.data.subarray(colJ * d, (colJ + 1) * d), X.data.subarray(g.indices[rp] * d, (g.indices[rp] + 1) * d)) < dj) {
+					prune = true;
+					break;
+				}
+			}
+			if (prune) g.data[p] = 0;
+			else retained.push(p);
+		}
+	}
+}
+function eliminateZerosF32(g) {
+	const indptr = new Int32Array(g.n + 1);
+	let nnz = 0;
+	for (let t = 0; t < g.indptr[g.n]; t++) if (g.data[t] !== 0) nnz++;
+	const indices = new Int32Array(nnz);
+	const data = new Float32Array(nnz);
+	let w = 0;
+	for (let r = 0; r < g.n; r++) {
+		for (let p = g.indptr[r]; p < g.indptr[r + 1]; p++) if (g.data[p] !== 0) {
+			indices[w] = g.indices[p];
+			data[w] = g.data[p];
+			w++;
+		}
+		indptr[r + 1] = w;
+	}
+	return {
+		indptr,
+		indices,
+		data,
+		n: g.n
+	};
+}
+/** Elementwise maximum over union sparsity (rows sorted). */
+function csrMaximumF32(A, B) {
+	const n = A.n;
+	const indptr = new Int32Array(n + 1);
+	const cap = A.indptr[n] + B.indptr[n];
+	const indices = new Int32Array(cap);
+	const data = new Float32Array(cap);
+	let nnz = 0;
+	for (let r = 0; r < n; r++) {
+		let pa = A.indptr[r];
+		let pb = B.indptr[r];
+		const ea = A.indptr[r + 1];
+		const eb = B.indptr[r + 1];
+		while (pa < ea || pb < eb) {
+			const ca = pa < ea ? A.indices[pa] : Infinity;
+			const cb = pb < eb ? B.indices[pb] : Infinity;
+			let col;
+			let v;
+			if (ca < cb) {
+				col = ca;
+				v = A.data[pa];
+				pa++;
+			} else if (cb < ca) {
+				col = cb;
+				v = B.data[pb];
+				pb++;
+			} else {
+				col = ca;
+				v = Math.max(A.data[pa], B.data[pb]);
+				pa++;
+				pb++;
+			}
+			if (col !== r) {
+				indices[nnz] = col;
+				data[nnz] = v;
+				nnz++;
+			}
+		}
+		indptr[r + 1] = nnz;
+	}
+	return {
+		indptr,
+		indices: indices.slice(0, nnz),
+		data: data.slice(0, nnz),
+		n
+	};
+}
+/** degree_prune: rows longer than maxDegree cut at the (maxDegree+1)-th smallest. */
+function degreePrune(g, maxDegree) {
+	for (let r = 0; r < g.n; r++) {
+		const start = g.indptr[r];
+		const end = g.indptr[r + 1];
+		if (end - start > maxDegree) {
+			const cut = Array.from(g.data.subarray(start, end)).sort((a, b) => a - b)[maxDegree];
+			for (let p = start; p < end; p++) if (g.data[p] > cut) g.data[p] = 0;
+		}
+	}
+	return eliminateZerosF32(g);
+}
+/**
+* Build the prepared search index from the finished kNN graph (notes §6).
+* `knn` must be the deheap-sorted neighbor graph in INTERNAL distance space.
+*/
+function prepareSearchIndex(X, knn, dist, correction, angular, nNeighbors, searchRngState, { pruningDegreeMultiplier = 1.5, searchLeafSize = 30, maxDepth = 200 } = {}) {
+	const n = X.rows;
+	const k = knn.k;
+	const tree = makeHubTree(X, knn.indices, searchLeafSize, angular, maxDepth);
+	const divIdx = knn.indices.slice();
+	const divDst = knn.distances.slice();
+	diversifyRows(X, dist, divIdx, divDst, k);
+	let nnz = 0;
+	for (let t = 0; t < divIdx.length; t++) if (divIdx[t] >= 0) nnz++;
+	const indptr = new Int32Array(n + 1);
+	const indices = new Int32Array(nnz);
+	const data = new Float32Array(nnz);
+	let w = 0;
+	for (let i = 0; i < n; i++) {
+		const cols = [];
+		const vals = [];
+		for (let j = 0; j < k; j++) {
+			const idx = divIdx[i * k + j];
+			if (idx < 0) continue;
+			let v = divDst[i * k + j];
+			if (v === 0) v = FLOAT32_EPS;
+			cols.push(idx);
+			vals.push(v);
+		}
+		const ord = cols.map((_, x) => x).sort((a, b) => cols[a] - cols[b]);
+		for (const o of ord) {
+			indices[w] = cols[o];
+			data[w] = Math.fround(vals[o]);
+			w++;
+		}
+		indptr[i + 1] = w;
+	}
+	let graph = {
+		indptr,
+		indices,
+		data,
+		n
+	};
+	let minDistance = Infinity;
+	for (let t = 0; t < w; t++) if (data[t] < minDistance) minDistance = data[t];
+	const reverse = csrTransposeF32(graph);
+	diversifyCsr(reverse, X, dist);
+	const reverseClean = eliminateZerosF32(reverse);
+	graph = csrMaximumF32(graph, reverseClean);
+	graph = degreePrune(graph, Math.round(pruningDegreeMultiplier * nNeighbors));
+	const vertexOrder = tree.indices.slice();
+	const inverse = new Int32Array(n);
+	for (let i = 0; i < n; i++) inverse[vertexOrder[i]] = i;
+	const rdata = new Float32Array(X.data.length);
+	const dcols = X.cols;
+	for (let i = 0; i < n; i++) rdata.set(X.data.subarray(vertexOrder[i] * dcols, (vertexOrder[i] + 1) * dcols), i * dcols);
+	const rX = {
+		data: rdata,
+		rows: n,
+		cols: dcols
+	};
+	const rIndptr = new Int32Array(n + 1);
+	for (let i = 0; i < n; i++) {
+		const src = vertexOrder[i];
+		rIndptr[i + 1] = rIndptr[i] + (graph.indptr[src + 1] - graph.indptr[src]);
+	}
+	const rIndices = new Int32Array(rIndptr[n]);
+	for (let i = 0; i < n; i++) {
+		const src = vertexOrder[i];
+		let dst = rIndptr[i];
+		for (let p = graph.indptr[src]; p < graph.indptr[src + 1]; p++) rIndices[dst++] = inverse[graph.indices[p]];
+	}
+	const rTreeIndices = new Int32Array(n);
+	for (let i = 0; i < n; i++) rTreeIndices[i] = inverse[tree.indices[i]];
+	return {
+		indptr: rIndptr,
+		indices: rIndices,
+		tree: {
+			...tree,
+			indices: rTreeIndices
+		},
+		vertexOrder,
+		data: rX,
+		dist,
+		correction,
+		angular,
+		minDistance,
+		searchRngState,
+		nNeighbors
+	};
+}
+/** Binary min-heap of (d, idx) pairs for the seed set (ties break on push order). */
+var SeedHeap = class {
+	d = [];
+	v = [];
+	get size() {
+		return this.d.length;
+	}
+	push(dist, idx) {
+		const d = this.d;
+		const v = this.v;
+		d.push(dist);
+		v.push(idx);
+		let i = d.length - 1;
+		while (i > 0) {
+			const parent = i - 1 >> 1;
+			if (d[i] < d[parent] || d[i] === d[parent] && v[i] < v[parent]) {
+				[d[i], d[parent]] = [d[parent], d[i]];
+				[v[i], v[parent]] = [v[parent], v[i]];
+				i = parent;
+			} else break;
+		}
+	}
+	pop() {
+		const d = this.d;
+		const v = this.v;
+		const outD = d[0];
+		const outV = v[0];
+		const lastD = d.pop();
+		const lastV = v.pop();
+		if (d.length > 0) {
+			d[0] = lastD;
+			v[0] = lastV;
+			let i = 0;
+			for (;;) {
+				const l = 2 * i + 1;
+				const r = l + 1;
+				let m = i;
+				if (l < d.length && (d[l] < d[m] || d[l] === d[m] && v[l] < v[m])) m = l;
+				if (r < d.length && (d[r] < d[m] || d[r] === d[m] && v[r] < v[m])) m = r;
+				if (m === i) break;
+				[d[i], d[m]] = [d[m], d[i]];
+				[v[i], v[m]] = [v[m], v[i]];
+				i = m;
+			}
+		}
+		return [outD, outV];
+	}
+};
+/**
+* Dense query (notes §7): tree init + random top-up + best-first expansion with
+* bound d_k + ε(d_k − minDistance). Returns ORIGINAL indices and CORRECTED distances.
+*/
+function searchKnn(index, Q, k, epsilon) {
+	const n = index.data.rows;
+	const dim = index.data.cols;
+	const nq = Q.rows;
+	const outIdx = new Int32Array(nq * k).fill(-1);
+	const outDst = new Float32Array(nq * k).fill(Infinity);
+	const visited = new Uint8Array((n >> 3) + 1);
+	const pri = new Float32Array(k);
+	const idx = new Int32Array(k);
+	const qbuf = new Float32Array(dim);
+	for (let qi = 0; qi < nq; qi++) {
+		visited.fill(0);
+		pri.fill(Infinity);
+		idx.fill(-1);
+		let query = Q.data.subarray(qi * dim, (qi + 1) * dim);
+		if (index.angular) {
+			let norm$1 = 0;
+			for (let d = 0; d < dim; d++) norm$1 += query[d] * query[d];
+			norm$1 = Math.sqrt(norm$1);
+			if (norm$1 > 0) {
+				for (let d = 0; d < dim; d++) qbuf[d] = query[d] / norm$1;
+				query = qbuf;
+			}
+		}
+		const rng = Int32Array.from(index.searchRngState);
+		const seeds = new SeedHeap();
+		const [ls, le] = searchFlatTree(index.tree, query, rng);
+		for (let p = ls; p < le; p++) {
+			const cand = index.tree.indices[p];
+			const d = index.dist(query, index.data.data.subarray(cand * dim, (cand + 1) * dim));
+			simpleHeapPush(pri, idx, k, d, cand);
+			seeds.push(d, cand);
+			visited[cand >> 3] = visited[cand >> 3] | 1 << (cand & 7);
+		}
+		const nRandom = Math.min(k, index.nNeighbors) - (le - ls);
+		for (let j = 0; j < nRandom; j++) {
+			const cand = Math.abs(tauRandInt(rng)) % n;
+			if ((visited[cand >> 3] & 1 << (cand & 7)) === 0) {
+				visited[cand >> 3] = visited[cand >> 3] | 1 << (cand & 7);
+				const d = index.dist(query, index.data.data.subarray(cand * dim, (cand + 1) * dim));
+				simpleHeapPush(pri, idx, k, d, cand);
+				seeds.push(d, cand);
+			}
+		}
+		let bound = pri[0] + epsilon * (pri[0] - index.minDistance);
+		while (seeds.size > 0) {
+			const [dv, vertex] = seeds.pop();
+			if (dv >= bound) break;
+			for (let p = index.indptr[vertex]; p < index.indptr[vertex + 1]; p++) {
+				const cand = index.indices[p];
+				if ((visited[cand >> 3] & 1 << (cand & 7)) !== 0) continue;
+				visited[cand >> 3] = visited[cand >> 3] | 1 << (cand & 7);
+				const d = index.dist(query, index.data.data.subarray(cand * dim, (cand + 1) * dim));
+				if (d < bound) {
+					simpleHeapPush(pri, idx, k, d, cand);
+					seeds.push(d, cand);
+					bound = pri[0] + epsilon * (pri[0] - index.minDistance);
+				}
+			}
+		}
+		const rowIdx = idx.slice();
+		const rowPri = pri.slice();
+		const ord = Array.from({ length: k }, (_, x) => x).sort((a, b) => rowPri[a] - rowPri[b]);
+		for (let j = 0; j < k; j++) {
+			const o = ord[j];
+			if (rowIdx[o] >= 0) {
+				outIdx[qi * k + j] = index.vertexOrder[rowIdx[o]];
+				outDst[qi * k + j] = index.correction(rowPri[o]);
+			}
+		}
+	}
+	return {
+		indices: outIdx,
+		distances: outDst,
+		k
+	};
+}
+
+//#endregion
+//#region src/knn/sparse-forest.ts
+function sparseRow(X, i) {
+	return {
+		inds: X.indices.subarray(X.indptr[i], X.indptr[i + 1]),
+		data: X.data.subarray(X.indptr[i], X.indptr[i + 1])
+	};
+}
+/** merged a*sa + b*sb over union of sparse supports */
+function sparseCombine(aInds, aData, sa, bInds, bData, sb) {
+	const out = [];
+	const outI = [];
+	let i = 0;
+	let j = 0;
+	while (i < aInds.length && j < bInds.length) {
+		const ca = aInds[i];
+		const cb = bInds[j];
+		if (ca === cb) {
+			const v = sa * aData[i] + sb * bData[j];
+			if (v !== 0) {
+				outI.push(ca);
+				out.push(v);
+			}
+			i++;
+			j++;
+		} else if (ca < cb) {
+			const v = sa * aData[i];
+			if (v !== 0) {
+				outI.push(ca);
+				out.push(v);
+			}
+			i++;
+		} else {
+			const v = sb * bData[j];
+			if (v !== 0) {
+				outI.push(cb);
+				out.push(v);
+			}
+			j++;
+		}
+	}
+	for (; i < aInds.length; i++) {
+		const v = sa * aData[i];
+		if (v !== 0) {
+			outI.push(aInds[i]);
+			out.push(v);
+		}
+	}
+	for (; j < bInds.length; j++) {
+		const v = sb * bData[j];
+		if (v !== 0) {
+			outI.push(bInds[j]);
+			out.push(v);
+		}
+	}
+	return {
+		inds: Int32Array.from(outI),
+		data: Float64Array.from(out)
+	};
+}
+function sparseDot(aInds, aData, bInds, bData) {
+	let r = 0;
+	let i = 0;
+	let j = 0;
+	while (i < aInds.length && j < bInds.length) {
+		const ca = aInds[i];
+		const cb = bInds[j];
+		if (ca === cb) {
+			r += aData[i] * bData[j];
+			i++;
+			j++;
+		} else if (ca < cb) i++;
+		else j++;
+	}
+	return r;
+}
+function norm(v) {
+	let s = 0;
+	for (let i = 0; i < v.length; i++) s += v[i] * v[i];
+	return Math.sqrt(s);
+}
+function sparseSplit(X, indices, rngState, angular) {
+	const n = indices.length;
+	const leftIndex = floorMod(Math.abs(tauRandInt(rngState)), n);
+	let rightIndex = floorMod(Math.abs(tauRandInt(rngState)), n);
+	if (leftIndex === rightIndex) rightIndex += 1;
+	rightIndex = floorMod(rightIndex, n);
+	const l = indices[leftIndex];
+	const r = indices[rightIndex];
+	const rowL = sparseRow(X, l);
+	const rowR = sparseRow(X, r);
+	let hyperplane;
+	let offset = 0;
+	if (angular) {
+		let ln = norm(rowL.data);
+		let rn = norm(rowR.data);
+		if (Math.abs(ln) < RP_EPS) ln = 1;
+		if (Math.abs(rn) < RP_EPS) rn = 1;
+		hyperplane = sparseCombine(rowL.inds, rowL.data, 1 / ln, rowR.inds, rowR.data, -1 / rn);
+		let hn = norm(hyperplane.data);
+		if (Math.abs(hn) < RP_EPS) hn = 1;
+		for (let t = 0; t < hyperplane.data.length; t++) hyperplane.data[t] = hyperplane.data[t] / hn;
+	} else {
+		hyperplane = sparseCombine(rowL.inds, rowL.data, 1, rowR.inds, rowR.data, -1);
+		const mid = sparseCombine(rowL.inds, rowL.data, .5, rowR.inds, rowR.data, .5);
+		offset = -sparseDot(hyperplane.inds, hyperplane.data, mid.inds, mid.data);
+	}
+	const side = new Uint8Array(n);
+	let nLeft = 0;
+	let nRight = 0;
+	for (let i = 0; i < n; i++) {
+		const p = indices[i];
+		const row = sparseRow(X, p);
+		const margin = offset + sparseDot(hyperplane.inds, hyperplane.data, row.inds, row.data);
+		if (Math.abs(margin) < RP_EPS) side[i] = floorMod(tauRandInt(rngState), 2);
+		else if (margin > 0) side[i] = 0;
+		else side[i] = 1;
+		if (side[i] === 0) nLeft++;
+		else nRight++;
+	}
+	if (nLeft === 0 || nRight === 0) {
+		nLeft = 0;
+		nRight = 0;
+		for (let i = 0; i < n; i++) {
+			side[i] = floorMod(tauRandInt(rngState), 2);
+			if (side[i] === 0) nLeft++;
+			else nRight++;
+		}
+	}
+	const left = new Int32Array(nLeft);
+	const right = new Int32Array(nRight);
+	let il = 0;
+	let ir = 0;
+	for (let i = 0; i < n; i++) if (side[i] === 0) left[il++] = indices[i];
+	else right[ir++] = indices[i];
+	return {
+		left,
+		right
+	};
+}
+/**
+* Build only the leaf arrays of a sparse RP forest (descent init needs nothing else).
+*/
+function sparseForestLeafArray(X, nNeighbors, nTrees, treeStates, angular, maxDepth = 200) {
+	const leafSize = Math.max(60, Math.min(256, 5 * nNeighbors));
+	const leaves = [];
+	let maxLeaf = 0;
+	const build = (indices, depth, rngState) => {
+		if (indices.length > leafSize && depth > 0) {
+			const { left, right } = sparseSplit(X, indices, rngState, angular);
+			build(left, depth - 1, rngState);
+			build(right, depth - 1, rngState);
+		} else {
+			leaves.push(indices);
+			if (indices.length > maxLeaf) maxLeaf = indices.length;
+		}
+	};
+	const all = new Int32Array(X.rows);
+	for (let i = 0; i < X.rows; i++) all[i] = i;
+	for (let t = 0; t < nTrees; t++) build(all.slice(), maxDepth, treeStates[t]);
+	const out = new Int32Array(leaves.length * maxLeaf).fill(-1);
+	leaves.forEach((leaf, i) => {
+		out.set(leaf, i * maxLeaf);
+	});
+	return {
+		data: out,
+		rows: leaves.length,
+		cols: maxLeaf
+	};
+}
+
+//#endregion
+//#region src/knn/index.ts
+const SMALL_DATA_CUTOFF = 4096;
+function nearestNeighborsDense(X, nNeighbors, metricName, rng, { metricOptions = {}, forceApproximation = false, angularRpForest = false, disconnectionDistance = Infinity } = {}) {
+	if (X.rows < SMALL_DATA_CUTOFF && !forceApproximation) return {
+		knn: exactKnnDense(X, nNeighbors, metricName, {
+			metricOptions,
+			disconnectionDistance
+		}),
+		searchIndex: null,
+		method: "exact"
+	};
+	const internal = resolveInternalMetric(metricName, metricOptions);
+	const angular = internal.angularTrees || angularRpForest;
+	const { nTrees, nIters } = umapNnDescentParams(X.rows);
+	const rngState = rng.tauState();
+	const searchRngState = rng.tauState();
+	for (let i = 0; i < 10; i++) tauRandInt(searchRngState);
+	const treeStates = [];
+	for (let t = 0; t < nTrees; t++) treeStates.push(rng.tauState());
+	const leafArray = leafArrayFromForest(makeForest(X, nNeighbors, nTrees, treeStates, {
+		leafSize: defaultLeafSize(nNeighbors),
+		angular
+	}));
+	const dim = X.cols;
+	const data = X.data;
+	const dist = (i, j) => internal.dist(data.subarray(i * dim, (i + 1) * dim), data.subarray(j * dim, (j + 1) * dim));
+	const heap = nnDescent(X.rows, nNeighbors, dist, rngState, leafArray, {
+		maxCandidates: 60,
+		nIters,
+		delta: .001
+	});
+	const knnInternal = {
+		indices: heap.indices,
+		distances: heap.distances,
+		k: nNeighbors
+	};
+	const pairDist = (a, b) => internal.dist(a, b);
+	const searchIndex = prepareSearchIndex(X, knnInternal, pairDist, internal.correction, angular, nNeighbors, searchRngState);
+	const outDst = new Float32Array(heap.distances.length);
+	for (let t = 0; t < outDst.length; t++) {
+		const d = heap.distances[t];
+		outDst[t] = d === Infinity ? Infinity : internal.correction(d);
+	}
+	const knn = {
+		indices: heap.indices.slice(),
+		distances: outDst,
+		k: nNeighbors
+	};
+	applyDisconnection(knn, disconnectionDistance);
+	return {
+		knn,
+		searchIndex,
+		method: "nndescent"
+	};
+}
+function nearestNeighborsSparse(X, nNeighbors, metricName, rng, { forceApproximation = false, angularRpForest = false, disconnectionDistance = Infinity } = {}) {
+	if (X.rows < SMALL_DATA_CUTOFF && !forceApproximation) {
+		const knn$1 = exactKnnSparse(X, nNeighbors, metricName);
+		applyDisconnection(knn$1, disconnectionDistance);
+		return {
+			knn: knn$1,
+			searchIndex: null,
+			method: "exact"
+		};
+	}
+	const internal = resolveSparseInternalMetric(metricName);
+	const angular = internal.angularTrees || angularRpForest;
+	const { nTrees, nIters } = umapNnDescentParams(X.rows);
+	const rngState = rng.tauState();
+	const searchRngState = rng.tauState();
+	for (let i = 0; i < 10; i++) tauRandInt(searchRngState);
+	const treeStates = [];
+	for (let t = 0; t < nTrees; t++) treeStates.push(rng.tauState());
+	const leafArray = sparseForestLeafArray(X, nNeighbors, nTrees, treeStates, angular);
+	const rowInd = (i) => X.indices.subarray(X.indptr[i], X.indptr[i + 1]);
+	const rowDat = (i) => X.data.subarray(X.indptr[i], X.indptr[i + 1]);
+	const dist = (i, j) => internal.dist(rowInd(i), rowDat(i), rowInd(j), rowDat(j));
+	const heap = nnDescent(X.rows, nNeighbors, dist, rngState, leafArray, {
+		maxCandidates: 60,
+		nIters,
+		delta: .001,
+		leafAcceptance: "either"
+	});
+	const outDst = new Float32Array(heap.distances.length);
+	for (let t = 0; t < outDst.length; t++) {
+		const d = heap.distances[t];
+		outDst[t] = d === Infinity ? Infinity : internal.correction(d);
+	}
+	const knn = {
+		indices: heap.indices,
+		distances: outDst,
+		k: nNeighbors
+	};
+	applyDisconnection(knn, disconnectionDistance);
+	return {
+		knn,
+		searchIndex: null,
+		method: "nndescent"
+	};
+}
+function applyDisconnection(knn, dc) {
+	if (dc === Infinity) return;
+	for (let t = 0; t < knn.distances.length; t++) if (knn.distances[t] >= dc) {
+		knn.distances[t] = Infinity;
+		knn.indices[t] = -1;
+	}
+}
+
+//#endregion
+//#region src/util.ts
+/**
+* Bound an async backend acquisition/init: broken environments (a stalled GPU
+* service, a worker that never loads) must degrade or fail typed — never hang.
+*/
+async function raceTimeout(p, ms, what) {
+	let timer;
+	const timeout = new Promise((_, reject) => {
+		timer = setTimeout(() => reject(new UmapBackendError(`${what} timed out after ${ms}ms`)), ms);
+	});
+	try {
+		return await Promise.race([p, timeout]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/** Convert any DenseInput to a canonical float32 Matrix, validating finiteness (§4.1). */
+function toMatrix(input, what = "X") {
+	if (Array.isArray(input)) {
+		const rows$1 = input.length;
+		if (rows$1 === 0) throw new UmapValidationError(`${what} has no rows`);
+		const first = input[0];
+		if (!Array.isArray(first)) throw new UmapValidationError(`${what} must be number[][]`);
+		const cols$1 = first.length;
+		if (cols$1 === 0) throw new UmapValidationError(`${what} has no columns`);
+		const data$1 = new Float32Array(rows$1 * cols$1);
+		for (let r = 0; r < rows$1; r++) {
+			const row = input[r];
+			if (!Array.isArray(row) || row.length !== cols$1) throw new UmapValidationError(`${what} row ${r} has inconsistent length`);
+			for (let c = 0; c < cols$1; c++) {
+				const v = row[c];
+				if (typeof v !== "number" || !Number.isFinite(v)) throw new UmapValidationError(`${what} contains a non-finite value at (${r}, ${c}); NaN/Infinity are rejected`);
+				data$1[r * cols$1 + c] = v;
+			}
+		}
+		return {
+			data: data$1,
+			rows: rows$1,
+			cols: cols$1
+		};
+	}
+	const { data, rows, cols } = input;
+	if (data.length !== rows * cols) throw new UmapValidationError(`${what}: data length ${data.length} != rows*cols = ${rows * cols}`);
+	for (let i = 0; i < data.length; i++) if (!Number.isFinite(data[i])) throw new UmapValidationError(`${what} contains a non-finite value at flat index ${i}; NaN/Infinity are rejected`);
+	return {
+		data: data instanceof Float32Array ? data.slice() : Float32Array.from(data),
+		rows,
+		cols
+	};
+}
+function isCsrInput(x) {
+	return typeof x === "object" && x !== null && "indptr" in x && "indices" in x && "data" in x && "rows" in x && "cols" in x;
+}
+function validateCsr(input, what = "X") {
+	const { data, indices, indptr, rows, cols } = input;
+	if (indptr.length !== rows + 1) throw new UmapValidationError(`${what}: indptr length must be rows+1`);
+	if (indptr[0] !== 0 || indptr[rows] !== data.length || indices.length !== data.length) throw new UmapValidationError(`${what}: malformed CSR structure`);
+	for (let i = 0; i < data.length; i++) {
+		if (!Number.isFinite(data[i])) throw new UmapValidationError(`${what} contains a non-finite value; NaN/Infinity rejected`);
+		const c = indices[i];
+		if (c < 0 || c >= cols) throw new UmapValidationError(`${what}: column index out of range`);
+	}
+	for (let r = 0; r < rows; r++) {
+		if (indptr[r + 1] < indptr[r]) throw new UmapValidationError(`${what}: indptr must be non-decreasing`);
+		for (let p = indptr[r] + 1; p < indptr[r + 1]; p++) if (indices[p] <= indices[p - 1]) throw new UmapValidationError(`${what}: row ${r} has unsorted or duplicate column indices (CSR rows must be strictly increasing)`);
+	}
+	return input;
+}
+
+//#endregion
+export { validateMetricOptionSizes as A, csrCopy as B, resolveInternalMetric as C, isNamedMetric as D, canonicalMetricName as E, smoothKnnDist as F, csrMaxAbsDiff as G, csrForEach as H, defaultNEpochs as I, csrTranspose as J, csrNnz as K, makeEpochsPerSample as L, fuzzySimplicialSet as M, MIN_K_DIST_SCALE as N, metrics_exports as O, SMOOTH_K_TOLERANCE as P, pruneGraphForEpochs as R, knnFromPrecomputed as S, NAMED_METRICS as T, csrFromCoo as U, csrEliminateZeros as V, csrMapValues as W, findABParams as Y, floorMod as _, SMALL_DATA_CUTOFF as a, exactKnnDense as b, prepareSearchIndex as c, umapNnDescentParams as d, checkedFlaggedHeapPush as f, Pcg32 as g, makeHeap as h, validateCsr as i, computeMembershipStrengths as j, resolveMetric as k, searchKnn as l, deheapSort as m, raceTimeout as n, nearestNeighborsDense as o, checkedHeapPush as p, csrRowNormalizeMax as q, toMatrix as r, nearestNeighborsSparse as s, isCsrInput as t, nnDescent as u, tauRand as v, ANGULAR_METRICS as w, exactKnnSparse as x, tauRandInt as y, csrBinaryOp as z };
+//# sourceMappingURL=core-BPpH5_PW.js.map