umap-web 0.2.0

package/dist/index.js

@@ -0,0 +1,2991 @@
+import { A as validateMetricOptionSizes, B as csrCopy, C as resolveInternalMetric, D as isNamedMetric, E as canonicalMetricName, F as smoothKnnDist, G as csrMaxAbsDiff, H as csrForEach, I as defaultNEpochs, J as csrTranspose, K as csrNnz, L as makeEpochsPerSample, M as fuzzySimplicialSet, N as MIN_K_DIST_SCALE, O as metrics_exports, P as SMOOTH_K_TOLERANCE, R as pruneGraphForEpochs, S as knnFromPrecomputed, T as NAMED_METRICS, U as csrFromCoo, V as csrEliminateZeros, W as csrMapValues, Y as findABParams, _ as floorMod, a as SMALL_DATA_CUTOFF, b as exactKnnDense, c as prepareSearchIndex, d as umapNnDescentParams, f as checkedFlaggedHeapPush, g as Pcg32, h as makeHeap, i as validateCsr, j as computeMembershipStrengths, k as resolveMetric, l as searchKnn, m as deheapSort, n as raceTimeout, o as nearestNeighborsDense, p as checkedHeapPush, q as csrRowNormalizeMax, r as toMatrix, s as nearestNeighborsSparse, t as isCsrInput, u as nnDescent, v as tauRand, w as ANGULAR_METRICS, x as exactKnnSparse, y as tauRandInt, z as csrBinaryOp } from "./core-BPpH5_PW.js";
+import { _ as silentLogger, a as degreeInvSqrt, c as spectralLayout, d as symmetricEigen, f as UmapBackendError, g as consoleLogger, h as UmapValidationError, i as connectedComponents, l as pcaScores, m as UmapError, n as initializeEmbedding, o as lobpcgSmallest, p as UmapConvergenceWarning, r as noisyScaleCoords, t as finalInitRescale, u as mgsOrthonormalize, v as throwIfAborted } from "./init-DLiEtGpx.js";
+
+//#region src/layout/sgd.ts
+function clip(val) {
+	if (val > 4) return 4;
+	if (val < -4) return -4;
+	return val;
+}
+/** Per-vertex tau streams: base rng_state + bit-pattern of the vertex's first coord. */
+function perVertexRngStates(n, rngState, embedding, dim) {
+	const states = new Int32Array(n * 3);
+	const buf = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+	for (let j = 0; j < n; j++) {
+		buf.setFloat64(0, embedding[j * dim], true);
+		const lo = buf.getInt32(0, true);
+		const hi = buf.getInt32(4, true);
+		states[j * 3] = rngState[0] + lo | 0;
+		states[j * 3 + 1] = rngState[1] + hi | 0;
+		states[j * 3 + 2] = rngState[2] + (lo ^ hi) | 0;
+	}
+	return states;
+}
+/**
+* optimize_layout_euclidean. Mutates headEmbedding (and tailEmbedding when
+* moveOther and they alias). Returns the final embedding.
+*/
+function optimizeLayoutEuclidean(headEmbedding, tailEmbedding, dim, head, tail, nEpochs, nVertices, epochsPerSample, a, b, rngState, { gamma = 1, initialAlpha = 1, negativeSampleRate = 5, moveOther = true, densmap = null, onEpoch, signal, snapshotEvery = 0 } = {}) {
+	const nEdges = epochsPerSample.length;
+	let alpha = initialAlpha;
+	const epochsPerNegativeSample = new Float64Array(nEdges);
+	for (let i = 0; i < nEdges; i++) epochsPerNegativeSample[i] = epochsPerSample[i] / negativeSampleRate;
+	const epochOfNextNegativeSample = epochsPerNegativeSample.slice();
+	const epochOfNextSample = epochsPerSample.slice();
+	const vertexRng = perVertexRngStates(headEmbedding.length / dim, rngState, headEmbedding, dim);
+	let densReSum = null;
+	let densPhiSum = null;
+	let densMuTot = 0;
+	if (densmap) {
+		densReSum = new Float32Array(nVertices);
+		densPhiSum = new Float32Array(nVertices);
+		for (let i = 0; i < densmap.muSum.length; i++) densMuTot += densmap.muSum[i];
+		densMuTot /= 2;
+	}
+	const rngRow = new Int32Array(3);
+	for (let n = 0; n < nEpochs; n++) {
+		throwIfAborted(signal);
+		let densmapFlag = false;
+		let densReStd = 0;
+		let densReMean = 0;
+		let densReCov = 0;
+		if (densmap && densmap.lambda > 0 && (n + 1) / nEpochs > 1 - densmap.frac) {
+			densmapFlag = true;
+			densReSum.fill(0);
+			densPhiSum.fill(0);
+			for (let i = 0; i < nEdges; i++) {
+				const j = head[i];
+				const k = tail[i];
+				let d2 = 0;
+				for (let d = 0; d < dim; d++) {
+					const diff = headEmbedding[j * dim + d] - tailEmbedding[k * dim + d];
+					d2 += diff * diff;
+				}
+				const phi = 1 / (1 + a * d2 ** b);
+				densReSum[j] = densReSum[j] + phi * d2;
+				densReSum[k] = densReSum[k] + phi * d2;
+				densPhiSum[j] = densPhiSum[j] + phi;
+				densPhiSum[k] = densPhiSum[k] + phi;
+			}
+			let mean = 0;
+			for (let i = 0; i < nVertices; i++) {
+				densReSum[i] = Math.log(1e-8 + densReSum[i] / densPhiSum[i]);
+				mean += densReSum[i];
+			}
+			mean /= nVertices;
+			let variance = 0;
+			let cov = 0;
+			for (let i = 0; i < nVertices; i++) {
+				variance += (densReSum[i] - mean) ** 2;
+				cov += densReSum[i] * densmap.R[i];
+			}
+			variance /= nVertices;
+			densReStd = Math.sqrt(variance + densmap.varShift);
+			densReMean = mean;
+			densReCov = cov / (nVertices - 1);
+		}
+		if (dim === 2 && !densmap) {
+			const fround = Math.fround;
+			const bm1 = b - 1;
+			for (let i = 0; i < nEdges; i++) {
+				if (epochOfNextSample[i] > n) continue;
+				const j = head[i];
+				let k = tail[i];
+				const jBase = j * 2;
+				let kBase = k * 2;
+				let cj0 = headEmbedding[jBase];
+				let cj1 = headEmbedding[jBase + 1];
+				let dx = cj0 - tailEmbedding[kBase];
+				let dy = cj1 - tailEmbedding[kBase + 1];
+				const d2 = dx * dx + dy * dy;
+				if (d2 > 0) {
+					const gc = -2 * a * b * d2 ** bm1 / (a * d2 ** b + 1);
+					const g0 = clip(gc * dx);
+					const g1 = clip(gc * dy);
+					cj0 = fround(cj0 + g0 * alpha);
+					cj1 = fround(cj1 + g1 * alpha);
+					if (moveOther) {
+						tailEmbedding[kBase] = tailEmbedding[kBase] - g0 * alpha;
+						tailEmbedding[kBase + 1] = tailEmbedding[kBase + 1] - g1 * alpha;
+					}
+				}
+				epochOfNextSample[i] = epochOfNextSample[i] + epochsPerSample[i];
+				const nNegSamples = Math.trunc((n - epochOfNextNegativeSample[i]) / epochsPerNegativeSample[i]);
+				let s0 = vertexRng[j * 3] | 0;
+				let s1 = vertexRng[j * 3 + 1] | 0;
+				let s2 = vertexRng[j * 3 + 2] | 0;
+				for (let s = 0; s < nNegSamples; s++) {
+					const u0 = s0 >>> 0;
+					const u1 = s1 >>> 0;
+					const u2 = s2 >>> 0;
+					s0 = (u0 & 4294967294) << 12 ^ (u0 << 13 >>> 0 ^ u0) >>> 19 | 0;
+					s1 = (u1 & 4294967288) << 4 ^ (u1 << 2 >>> 0 ^ u1) >>> 25 | 0;
+					s2 = (u2 & 4294967280) << 17 ^ (u2 << 3 >>> 0 ^ u2) >>> 11 | 0;
+					const rm = (s0 ^ s1 ^ s2 | 0) % nVertices;
+					k = rm + (rm < 0 ? nVertices : 0);
+					if (j === k) continue;
+					kBase = k * 2;
+					dx = cj0 - tailEmbedding[kBase];
+					dy = cj1 - tailEmbedding[kBase + 1];
+					const dn = dx * dx + dy * dy;
+					if (dn > 0) {
+						const rc = 2 * gamma * b / ((.001 + dn) * (a * dn ** b + 1));
+						cj0 = fround(cj0 + clip(rc * dx) * alpha);
+						cj1 = fround(cj1 + clip(rc * dy) * alpha);
+					}
+				}
+				headEmbedding[jBase] = cj0;
+				headEmbedding[jBase + 1] = cj1;
+				vertexRng[j * 3] = s0;
+				vertexRng[j * 3 + 1] = s1;
+				vertexRng[j * 3 + 2] = s2;
+				epochOfNextNegativeSample[i] = epochOfNextNegativeSample[i] + nNegSamples * epochsPerNegativeSample[i];
+			}
+			alpha = initialAlpha * (1 - n / nEpochs);
+			if (onEpoch) {
+				const info = {
+					epoch: n,
+					nEpochs,
+					phase: "layout"
+				};
+				if (snapshotEvery > 0 && (n % snapshotEvery === 0 || n === nEpochs - 1)) info.embedding = headEmbedding;
+				onEpoch(info);
+			}
+			continue;
+		}
+		for (let i = 0; i < nEdges; i++) {
+			if (epochOfNextSample[i] > n) continue;
+			const j = head[i];
+			let k = tail[i];
+			const jBase = j * dim;
+			let kBase = k * dim;
+			let distSquared = 0;
+			for (let d = 0; d < dim; d++) {
+				const diff = headEmbedding[jBase + d] - tailEmbedding[kBase + d];
+				distSquared += diff * diff;
+			}
+			let gradCorCoeff = 0;
+			if (densmapFlag) {
+				const phi = 1 / (1 + a * distSquared ** b);
+				const dphiTerm = a * b * distSquared ** (b - 1) / (1 + a * distSquared ** b);
+				const qjk = phi / densPhiSum[k];
+				const qkj = phi / densPhiSum[j];
+				const drk = qjk * ((1 - b * (1 - phi)) / Math.exp(densReSum[k]) + dphiTerm);
+				const drj = qkj * ((1 - b * (1 - phi)) / Math.exp(densReSum[j]) + dphiTerm);
+				const reStdSq = densReStd * densReStd;
+				const weightK = densmap.R[k] - densReCov * (densReSum[k] - densReMean) / reStdSq;
+				const weightJ = densmap.R[j] - densReCov * (densReSum[j] - densReMean) / reStdSq;
+				gradCorCoeff = densmap.lambda * densMuTot / (densmap.mu[i] * densReStd) * (weightK * drk + weightJ * drj) / nVertices;
+			}
+			let gradCoeff;
+			if (distSquared > 0) gradCoeff = -2 * a * b * distSquared ** (b - 1) / (a * distSquared ** b + 1);
+			else gradCoeff = 0;
+			for (let d = 0; d < dim; d++) {
+				const diff = headEmbedding[jBase + d] - tailEmbedding[kBase + d];
+				let gradD = clip(gradCoeff * diff);
+				if (densmapFlag) gradD += clip(2 * gradCorCoeff * diff);
+				headEmbedding[jBase + d] = headEmbedding[jBase + d] + gradD * alpha;
+				if (moveOther) tailEmbedding[kBase + d] = tailEmbedding[kBase + d] - gradD * alpha;
+			}
+			epochOfNextSample[i] = epochOfNextSample[i] + epochsPerSample[i];
+			const nNegSamples = Math.trunc((n - epochOfNextNegativeSample[i]) / epochsPerNegativeSample[i]);
+			rngRow[0] = vertexRng[j * 3];
+			rngRow[1] = vertexRng[j * 3 + 1];
+			rngRow[2] = vertexRng[j * 3 + 2];
+			for (let p = 0; p < nNegSamples; p++) {
+				const r = tauRandInt(rngRow);
+				k = r % nVertices + (r % nVertices < 0 ? nVertices : 0);
+				kBase = k * dim;
+				distSquared = 0;
+				for (let d = 0; d < dim; d++) {
+					const diff = headEmbedding[jBase + d] - tailEmbedding[kBase + d];
+					distSquared += diff * diff;
+				}
+				let repCoeff;
+				if (distSquared > 0) repCoeff = 2 * gamma * b / ((.001 + distSquared) * (a * distSquared ** b + 1));
+				else if (j === k) continue;
+				else repCoeff = 0;
+				for (let d = 0; d < dim; d++) {
+					let gradD;
+					if (repCoeff > 0) {
+						const diff = headEmbedding[jBase + d] - tailEmbedding[kBase + d];
+						gradD = clip(repCoeff * diff);
+					} else gradD = 0;
+					headEmbedding[jBase + d] = headEmbedding[jBase + d] + gradD * alpha;
+				}
+			}
+			vertexRng[j * 3] = rngRow[0];
+			vertexRng[j * 3 + 1] = rngRow[1];
+			vertexRng[j * 3 + 2] = rngRow[2];
+			epochOfNextNegativeSample[i] = epochOfNextNegativeSample[i] + nNegSamples * epochsPerNegativeSample[i];
+		}
+		alpha = initialAlpha * (1 - n / nEpochs);
+		if (onEpoch) {
+			const info = {
+				epoch: n,
+				nEpochs,
+				phase: "layout"
+			};
+			if (snapshotEvery > 0 && (n % snapshotEvery === 0 || n === nEpochs - 1)) info.embedding = headEmbedding;
+			onEpoch(info);
+		}
+	}
+	return headEmbedding;
+}
+/**
+* optimize_layout_inverse (layouts.py:663-732; notes §13): optimizes DATA-space
+* positions of inverse-transformed points against the raw training data.
+* Negative samples use the SHARED rng state (not per-vertex).
+*/
+function optimizeLayoutInverse(headEmbedding, tailEmbedding, dim, head, tail, weight, sigmas, rhos, nEpochs, nVertices, epochsPerSample, rngState, outputMetric, { gamma = 1, initialAlpha = 1, negativeSampleRate = 5, signal } = {}) {
+	const nEdges = epochsPerSample.length;
+	let alpha = initialAlpha;
+	const epochsPerNegativeSample = new Float64Array(nEdges);
+	for (let i = 0; i < nEdges; i++) epochsPerNegativeSample[i] = epochsPerSample[i] / negativeSampleRate;
+	const epochOfNextNegativeSample = epochsPerNegativeSample.slice();
+	const epochOfNextSample = epochsPerSample.slice();
+	const grad = new Float64Array(dim);
+	const cur = new Float32Array(dim);
+	const oth = new Float32Array(dim);
+	for (let n = 0; n < nEpochs; n++) {
+		throwIfAborted(signal);
+		for (let i = 0; i < nEdges; i++) {
+			if (epochOfNextSample[i] > n) continue;
+			const j = head[i];
+			let k = tail[i];
+			const jBase = j * dim;
+			let kBase = k * dim;
+			for (let d = 0; d < dim; d++) {
+				cur[d] = headEmbedding[jBase + d];
+				oth[d] = tailEmbedding[kBase + d];
+			}
+			outputMetric(cur, oth, grad);
+			const gradCoeff = -(1 / (weight[i] * sigmas[k] + 1e-6));
+			for (let d = 0; d < dim; d++) {
+				const gradD = clip(gradCoeff * grad[d]);
+				headEmbedding[jBase + d] = headEmbedding[jBase + d] + gradD * alpha;
+			}
+			epochOfNextSample[i] = epochOfNextSample[i] + epochsPerSample[i];
+			const nNegSamples = Math.trunc((n - epochOfNextNegativeSample[i]) / epochsPerNegativeSample[i]);
+			for (let p = 0; p < nNegSamples; p++) {
+				const r = tauRandInt(rngState);
+				k = r % nVertices + (r % nVertices < 0 ? nVertices : 0);
+				kBase = k * dim;
+				for (let d = 0; d < dim; d++) {
+					cur[d] = headEmbedding[jBase + d];
+					oth[d] = tailEmbedding[kBase + d];
+				}
+				const distOutput = outputMetric(cur, oth, grad);
+				const wH = Math.exp(-Math.max(distOutput - rhos[k], 1e-6) / (sigmas[k] + 1e-6));
+				let denom = (1 - wH) * sigmas[k] + 1e-6;
+				if (!Number.isFinite(denom)) denom = 1e-6;
+				const gradCoeffNeg = -gamma * ((0 - wH) / denom);
+				for (let d = 0; d < dim; d++) {
+					const gradD = clip(gradCoeffNeg * grad[d]);
+					headEmbedding[jBase + d] = headEmbedding[jBase + d] + gradD * alpha;
+				}
+			}
+			epochOfNextNegativeSample[i] = epochOfNextNegativeSample[i] + nNegSamples * epochsPerNegativeSample[i];
+		}
+		alpha = initialAlpha * (1 - n / nEpochs);
+	}
+	return headEmbedding;
+}
+/** optimize_layout_generic — non-euclidean output metrics (notes §10). */
+function optimizeLayoutGeneric(headEmbedding, tailEmbedding, dim, head, tail, nEpochs, nVertices, epochsPerSample, a, b, rngState, outputMetric, { gamma = 1, initialAlpha = 1, negativeSampleRate = 5, moveOther = true, onEpoch, signal, snapshotEvery = 0 } = {}) {
+	const nEdges = epochsPerSample.length;
+	let alpha = initialAlpha;
+	const epochsPerNegativeSample = new Float64Array(nEdges);
+	for (let i = 0; i < nEdges; i++) epochsPerNegativeSample[i] = epochsPerSample[i] / negativeSampleRate;
+	const epochOfNextNegativeSample = epochsPerNegativeSample.slice();
+	const epochOfNextSample = epochsPerSample.slice();
+	const vertexRng = perVertexRngStates(headEmbedding.length / dim, rngState, headEmbedding, dim);
+	const grad = new Float64Array(dim);
+	const revGrad = new Float64Array(dim);
+	const rngRow = new Int32Array(3);
+	const cur = new Float32Array(dim);
+	const oth = new Float32Array(dim);
+	for (let n = 0; n < nEpochs; n++) {
+		throwIfAborted(signal);
+		for (let i = 0; i < nEdges; i++) {
+			if (epochOfNextSample[i] > n) continue;
+			const j = head[i];
+			let k = tail[i];
+			const jBase = j * dim;
+			let kBase = k * dim;
+			for (let d = 0; d < dim; d++) {
+				cur[d] = headEmbedding[jBase + d];
+				oth[d] = tailEmbedding[kBase + d];
+			}
+			const distOutput = outputMetric(cur, oth, grad);
+			outputMetric(oth, cur, revGrad);
+			const wL = distOutput > 0 ? (1 + a * distOutput ** (2 * b)) ** -1 : 1;
+			const gradCoeff = 2 * b * (wL - 1) / (distOutput + 1e-6);
+			for (let d = 0; d < dim; d++) {
+				const gradD = clip(gradCoeff * grad[d]);
+				headEmbedding[jBase + d] = headEmbedding[jBase + d] + gradD * alpha;
+				if (moveOther) {
+					const revD = clip(gradCoeff * revGrad[d]);
+					tailEmbedding[kBase + d] = tailEmbedding[kBase + d] + revD * alpha;
+				}
+			}
+			epochOfNextSample[i] = epochOfNextSample[i] + epochsPerSample[i];
+			const nNegSamples = Math.trunc((n - epochOfNextNegativeSample[i]) / epochsPerNegativeSample[i]);
+			rngRow[0] = vertexRng[j * 3];
+			rngRow[1] = vertexRng[j * 3 + 1];
+			rngRow[2] = vertexRng[j * 3 + 2];
+			for (let p = 0; p < nNegSamples; p++) {
+				const r = tauRandInt(rngRow);
+				k = r % nVertices + (r % nVertices < 0 ? nVertices : 0);
+				kBase = k * dim;
+				for (let d = 0; d < dim; d++) {
+					cur[d] = headEmbedding[jBase + d];
+					oth[d] = tailEmbedding[kBase + d];
+				}
+				const dNeg = outputMetric(cur, oth, grad);
+				let wLNeg;
+				if (dNeg > 0) wLNeg = (1 + a * dNeg ** (2 * b)) ** -1;
+				else if (j === k) continue;
+				else wLNeg = 1;
+				const repCoeff = gamma * 2 * b * wLNeg / (dNeg + 1e-6);
+				for (let d = 0; d < dim; d++) {
+					const gradD = clip(repCoeff * grad[d]);
+					headEmbedding[jBase + d] = headEmbedding[jBase + d] + gradD * alpha;
+				}
+			}
+			vertexRng[j * 3] = rngRow[0];
+			vertexRng[j * 3 + 1] = rngRow[1];
+			vertexRng[j * 3 + 2] = rngRow[2];
+			epochOfNextNegativeSample[i] = epochOfNextNegativeSample[i] + nNegSamples * epochsPerNegativeSample[i];
+		}
+		alpha = initialAlpha * (1 - n / nEpochs);
+		if (onEpoch) {
+			const info = {
+				epoch: n,
+				nEpochs,
+				phase: "layout"
+			};
+			if (snapshotEvery > 0 && (n % snapshotEvery === 0 || n === nEpochs - 1)) info.embedding = headEmbedding;
+			onEpoch(info);
+		}
+	}
+	return headEmbedding;
+}
+
+//#endregion
+//#region src/backends/cpu/pool.ts
+const IS_NODE = typeof process !== "undefined" && !!process.versions?.node;
+/**
+* Runtime-only import of node builtins. The variable specifier plus the ignore
+* comments keep browser bundlers (esbuild/Vite/webpack) from trying to resolve
+* `node:*` modules they cannot ship; every call site is behind an IS_NODE
+* guard so the import never evaluates in a browser.
+*/
+function nodeImport(specifier) {
+	return import(
+		/* @vite-ignore */
+		/* webpackIgnore: true */
+		specifier
+);
+}
+function sabAvailable() {
+	if (typeof SharedArrayBuffer === "undefined") return false;
+	if (IS_NODE) return true;
+	return globalThis.crossOriginIsolated === true;
+}
+function hardwareConcurrency() {
+	return Math.max(1, globalThis.navigator?.hardwareConcurrency ?? 4);
+}
+/**
+* Bundler-visible browser worker factory. webpack 5 and Vite (build) statically
+* detect the exact inline `new Worker(new URL('./worker.js', import.meta.url),
+* {type:'module'})` expression — including inside node_modules — and emit the
+* worker as an asset of the consumer's build. Do NOT extract the URL into a
+* variable or helper: detection depends on the literal shape of this
+* expression (guarded by scripts/check-bundlers.mjs).
+*/
+function defaultBrowserWorker() {
+	return new Worker(new URL("./worker.js", import.meta.url), { type: "module" });
+}
+/**
+* Cross-origin retry (CDN / import-map consumers): fetch the sibling worker
+* source and spawn it from a blob: URL. Valid only because dist/worker.js is
+* built fully self-contained (no sibling-chunk imports; enforced by
+* scripts/check-worker-selfcontained.mjs). Requires `worker-src blob:` under
+* a strict CSP (documented in README).
+*/
+async function blobWorkerUrl() {
+	try {
+		const res = await fetch(new URL("./worker.js", import.meta.url));
+		if (!res.ok) return null;
+		const text = await res.text();
+		return URL.createObjectURL(new Blob([text], { type: "text/javascript" }));
+	} catch {
+		return null;
+	}
+}
+async function spawnWorker(source) {
+	if (IS_NODE) {
+		const { Worker: Worker$1 } = await nodeImport("node:worker_threads");
+		const resolved = source ?? await workerEntryUrl();
+		const w$1 = new Worker$1(typeof resolved === "string" && resolved.startsWith("file:") ? new URL(resolved) : resolved);
+		return {
+			post: (msg, transfers) => w$1.postMessage(msg, transfers ?? []),
+			onMessage: (cb) => {
+				w$1.on("message", cb);
+			},
+			onFailure: (cb) => {
+				w$1.on("error", (e) => cb(e instanceof Error ? e : new Error(String(e))));
+				w$1.on("messageerror", (e) => cb(/* @__PURE__ */ new Error(`worker messageerror: ${e}`)));
+				w$1.on("exit", (code) => {
+					if (code !== 0) cb(/* @__PURE__ */ new Error(`worker exited with code ${code}`));
+				});
+			},
+			terminate: async () => {
+				await w$1.terminate();
+			}
+		};
+	}
+	const w = source === void 0 ? defaultBrowserWorker() : new Worker(source, { type: "module" });
+	return {
+		post: (msg, transfers) => w.postMessage(msg, { transfer: transfers ?? [] }),
+		onMessage: (cb) => {
+			w.onmessage = (e) => cb(e.data);
+		},
+		onFailure: (cb) => {
+			w.onerror = (e) => cb(/* @__PURE__ */ new Error(`worker error: ${e.message || "failed to load worker.js"}`));
+			w.onmessageerror = () => cb(/* @__PURE__ */ new Error("worker messageerror (unserializable message)"));
+		},
+		terminate: () => w.terminate()
+	};
+}
+var WorkerPool = class WorkerPool {
+	workers = [];
+	pending = /* @__PURE__ */ new Map();
+	nextId = 1;
+	failure = null;
+	terminating = false;
+	cleanup = null;
+	size;
+	constructor(size) {
+		this.size = size;
+	}
+	/**
+	* Spawn `size` workers from `source` (undefined → platform default resolution).
+	* `cleanup` runs once at terminate() (e.g. revoking a blob: URL). Partial
+	* spawn failures terminate the already-spawned workers before rethrowing.
+	*/
+	static async create(size, source, cleanup) {
+		const pool = new WorkerPool(size);
+		pool.cleanup = cleanup ?? null;
+		try {
+			for (let i = 0; i < size; i++) {
+				const w = await spawnWorker(source);
+				w.onMessage((msg) => pool.dispatch(msg));
+				w.onFailure((err) => pool.markFailed(err));
+				pool.workers.push(w);
+			}
+		} catch (e) {
+			await pool.terminate();
+			throw e;
+		}
+		return pool;
+	}
+	/** A worker died: poison the pool and reject everything in flight. */
+	markFailed(err) {
+		if (this.terminating || this.failure) return;
+		this.failure = err;
+		const inflight = [...this.pending.values()];
+		this.pending.clear();
+		const wrapped = new UmapBackendError(`worker failed: ${err.message}`);
+		for (const p of inflight) p.reject(wrapped);
+	}
+	dispatch(msg) {
+		const m = msg;
+		if (typeof m?.id !== "number") return;
+		const p = this.pending.get(m.id);
+		if (!p) return;
+		this.pending.delete(m.id);
+		if (m.error) p.reject(new UmapBackendError(`worker error: ${m.error}`));
+		else p.resolve(m.result);
+	}
+	call(worker, method, args, transfers) {
+		if (this.failure) return Promise.reject(new UmapBackendError(`worker pool is dead: ${this.failure.message}`));
+		if (this.terminating) return Promise.reject(new UmapBackendError("worker pool has been terminated"));
+		const id = this.nextId++;
+		const promise = new Promise((resolve, reject) => {
+			this.pending.set(id, {
+				resolve,
+				reject
+			});
+		});
+		this.workers[worker].post({
+			id,
+			method,
+			args
+		}, transfers);
+		return promise;
+	}
+	/** Run `method` on every worker with per-worker args; await all. */
+	mapAll(method, argsFor, transfersFor) {
+		return Promise.all(this.workers.map((_, w) => this.call(w, method, argsFor(w), transfersFor?.(w))));
+	}
+	async terminate() {
+		if (this.terminating) return;
+		this.terminating = true;
+		const inflight = [...this.pending.values()];
+		this.pending.clear();
+		for (const p of inflight) p.reject(new UmapBackendError("worker pool terminated with calls in flight"));
+		await Promise.all(this.workers.map((w) => w.terminate()));
+		this.workers = [];
+		if (this.cleanup) {
+			this.cleanup();
+			this.cleanup = null;
+		}
+	}
+};
+/**
+* Node-only resolution of the worker entry: the bundled sibling (dist layout),
+* then the package export (bundled-consumer deploys that keep node_modules),
+* then the package's dist for the src/test context. Browser resolution happens
+* in defaultBrowserWorker/blobWorkerUrl instead.
+*/
+async function workerEntryUrl() {
+	const local = new URL("./worker.js", import.meta.url);
+	if (IS_NODE && local.protocol === "file:") {
+		const { existsSync } = await nodeImport("node:fs");
+		const { fileURLToPath } = await nodeImport("node:url");
+		if (!existsSync(fileURLToPath(local))) {
+			try {
+				const viaExport = import.meta.resolve?.("umap-web/worker");
+				if (viaExport?.startsWith("file:") && existsSync(fileURLToPath(new URL(viaExport)))) return new URL(viaExport);
+			} catch {}
+			return new URL("../../../dist/worker.js", import.meta.url);
+		}
+	}
+	return local;
+}
+
+//#endregion
+//#region src/backends/cpu/workers.ts
+/** Copy data into a SAB-backed view when available. */
+function shareData(X, sab) {
+	if (!sab) return X.data;
+	const shared = new Float32Array(new SharedArrayBuffer(X.data.length * 4));
+	shared.set(X.data);
+	return shared;
+}
+/** Cap on worker spawn + init; a stuck worker must degrade, never hang fit(). */
+const WORKER_INIT_TIMEOUT_MS = 1e4;
+async function tryCreatePool(size, source, cleanup, initArgs, failures) {
+	let pool = null;
+	try {
+		pool = await WorkerPool.create(size, source, cleanup);
+		const init = pool.mapAll("init", () => initArgs);
+		init.catch(() => {});
+		await raceTimeout(init, WORKER_INIT_TIMEOUT_MS, "worker init");
+		return pool;
+	} catch (e) {
+		failures.push(e instanceof Error ? e.message : String(e));
+		if (pool) await pool.terminate();
+		return null;
+	}
+}
+async function createParallelContext(X, metricName, metricOptions, requested, workerUrl, logger) {
+	const hw = hardwareConcurrency();
+	const size = requested === "auto" ? Math.max(1, Math.min(hw - 1, 16)) : requested;
+	if (size <= 1) return null;
+	const sab = sabAvailable();
+	const data = shareData(X, sab);
+	const initArgs = {
+		data,
+		rows: X.rows,
+		cols: X.cols,
+		metricName,
+		metricOptions
+	};
+	const failures = [];
+	let pool = null;
+	if (workerUrl !== void 0) pool = await tryCreatePool(size, workerUrl, void 0, initArgs, failures);
+	else {
+		pool = await tryCreatePool(size, void 0, void 0, initArgs, failures);
+		if (!pool && !IS_NODE) {
+			const blob = await blobWorkerUrl();
+			if (blob) pool = await tryCreatePool(size, blob, () => URL.revokeObjectURL(blob), initArgs, failures);
+			else failures.push("worker source fetch for blob retry failed");
+		}
+	}
+	if (!pool) {
+		logger?.warn(`worker pool unavailable (${failures.join("; ")}) — continuing single-threaded. Bundled apps: see the README section "Workers & bundlers" or pass options.workerUrl.`);
+		return null;
+	}
+	const internal = resolveInternalMetric(metricName, metricOptions);
+	return {
+		pool,
+		sab,
+		data,
+		rows: X.rows,
+		cols: X.cols,
+		dist: (a, b) => internal.dist(a, b)
+	};
+}
+function splitRange(total, parts) {
+	const out = [];
+	const step = Math.ceil(total / parts);
+	for (let i = 0; i < parts; i++) out.push([Math.min(i * step, total), Math.min((i + 1) * step, total)]);
+	return out;
+}
+function applyTriples(heap, buffers) {
+	let c = 0;
+	for (const buf of buffers) for (let t = 0; t < buf.length; t += 3) {
+		const p = buf[t];
+		const q = buf[t + 1];
+		const d = buf[t + 2];
+		c += checkedFlaggedHeapPush(heap, p, d, q, 1);
+		c += checkedFlaggedHeapPush(heap, q, d, p, 1);
+	}
+	return c;
+}
+function thresholdSnapshot(heap, out) {
+	const k = heap.size;
+	for (let i = 0; i < heap.n; i++) out[i] = heap.distances[i * k];
+	return out;
+}
+/**
+* Parallel NN-descent (same candidate scheme/acceptance as the single-thread
+* port; distance passes fan out to workers per block).
+*/
+async function parallelNnDescent(ctx, nNeighbors, rng, angular, { maxCandidates = 60, delta = .001 } = {}) {
+	const n = ctx.rows;
+	const { nTrees, nIters } = umapNnDescentParams(n);
+	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 perWorker = splitRange(nTrees, ctx.pool.size);
+	const parts = (await ctx.pool.mapAll("buildTrees", (w) => ({
+		treeStates: treeStates.slice(perWorker[w][0], perWorker[w][1]),
+		nNeighbors,
+		angular
+	}))).filter((p) => p.rows > 0 && p.cols > 0);
+	const maxCols = Math.max(1, ...parts.map((p) => p.cols));
+	const totalRows = parts.reduce((s, p) => s + p.rows, 0);
+	const leafArray = new Int32Array(totalRows * maxCols).fill(-1);
+	{
+		let r = 0;
+		for (const p of parts) for (let i = 0; i < p.rows; i++) {
+			leafArray.set(p.data.subarray(i * p.cols, (i + 1) * p.cols), r * maxCols);
+			r++;
+		}
+	}
+	const heap = makeHeap(n, nNeighbors);
+	const thresholds = new Float32Array(n);
+	const LEAF_BLOCK = 4096;
+	for (let start = 0; start < totalRows; start += LEAF_BLOCK) {
+		const end = Math.min(totalRows, start + LEAF_BLOCK);
+		thresholdSnapshot(heap, thresholds);
+		const shards = splitRange(end - start, ctx.pool.size);
+		applyTriples(heap, await ctx.pool.mapAll("leafUpdates", (w) => ({
+			leafArray,
+			cols: maxCols,
+			rowStart: start + shards[w][0],
+			rowEnd: start + shards[w][1],
+			thresholds
+		})));
+	}
+	{
+		const d = ctx.cols;
+		const dist = (i, j) => ctx.dist(ctx.data.subarray(i * d, (i + 1) * d), ctx.data.subarray(j * d, (j + 1) * d));
+		const k = nNeighbors;
+		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++;
+			for (let j = 0; j < k - filled; j++) {
+				const idx = Math.abs(tauRandInt(rngState)) % n;
+				checkedFlaggedHeapPush(heap, i, dist(idx, i), idx, 1);
+			}
+		}
+	}
+	const VBLOCK = 16384;
+	for (let iter = 0; iter < nIters; iter++) {
+		const { newIdx, oldIdx } = buildCandidatesMain(heap, maxCandidates, rngState);
+		let c = 0;
+		for (let vs = 0; vs < n; vs += VBLOCK) {
+			const ve = Math.min(n, vs + VBLOCK);
+			thresholdSnapshot(heap, thresholds);
+			const shards = splitRange(ve - vs, ctx.pool.size);
+			const results = await ctx.pool.mapAll("joinUpdates", (w) => ({
+				newIdx: newIdx.subarray((vs + shards[w][0]) * maxCandidates, (vs + shards[w][1]) * maxCandidates),
+				oldIdx: oldIdx.subarray((vs + shards[w][0]) * maxCandidates, (vs + shards[w][1]) * maxCandidates),
+				maxCandidates,
+				vStart: 0,
+				vEnd: shards[w][1] - shards[w][0],
+				thresholds
+			}));
+			c += applyTriples(heap, results);
+		}
+		if (c <= delta * nNeighbors * n) break;
+	}
+	deheapSort(heap);
+	return {
+		knnInternal: {
+			indices: heap.indices,
+			distances: heap.distances,
+			k: nNeighbors
+		},
+		searchRngState
+	};
+}
+/** new_build_candidates on the main thread (heap pushes are cheap). */
+function buildCandidatesMain(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
+	};
+}
+/**
+* Hogwild epoch-sharded SGD across the pool. SAB mode writes concurrently into
+* the shared embedding (races tolerated, like umap's parallel=True); transfer
+* mode applies per-worker deltas at each epoch barrier (stale-by-one-epoch reads).
+*/
+async function parallelOptimizeLayout(ctx, embedding, dim, head, tail, nEpochs, nVertices, epochsPerSample, a, b, rngState, opts) {
+	const nEdges = epochsPerSample.length;
+	const shards = splitRange(nEdges, ctx.pool.size);
+	let shared = null;
+	if (ctx.sab) {
+		shared = new Float32Array(new SharedArrayBuffer(embedding.length * 4));
+		shared.set(embedding);
+	}
+	const embForWorkers = shared ?? embedding;
+	await ctx.pool.mapAll("layoutInit", (w) => ({
+		embedding: embForWorkers,
+		tailEmbedding: null,
+		head,
+		tail,
+		epochsPerSample,
+		rngState,
+		params: {
+			a,
+			b,
+			gamma: opts.gamma,
+			initialAlpha: opts.initialAlpha,
+			negativeSampleRate: opts.negativeSampleRate,
+			dim,
+			nVertices,
+			moveOther: opts.moveOther,
+			edgeStart: shards[w][0],
+			edgeEnd: shards[w][1],
+			sharedEmbedding: ctx.sab
+		}
+	}));
+	let alpha = opts.initialAlpha;
+	for (let epoch = 0; epoch < nEpochs; epoch++) {
+		if (opts.signal?.aborted) throw opts.signal.reason ?? new DOMException("The operation was aborted.", "AbortError");
+		if (ctx.sab) await ctx.pool.mapAll("layoutEpoch", () => ({
+			epoch,
+			alpha
+		}));
+		else {
+			const deltas = await ctx.pool.mapAll("layoutEpoch", () => ({
+				epoch,
+				alpha,
+				embedding
+			}));
+			for (const d of deltas) for (let i = 0; i < embedding.length; i++) embedding[i] = embedding[i] + d[i];
+		}
+		alpha = opts.initialAlpha * (1 - epoch / nEpochs);
+		if (opts.onEpoch) {
+			const info = {
+				epoch,
+				nEpochs,
+				phase: "layout"
+			};
+			if (opts.snapshotEvery && (epoch % opts.snapshotEvery === 0 || epoch === nEpochs - 1)) {
+				if (shared) embedding.set(shared);
+				info.embedding = embedding;
+			}
+			opts.onEpoch(info);
+		}
+	}
+	if (shared) embedding.set(shared);
+	return embedding;
+}
+/** Build the prepared search index from a parallel kNN result (main thread). */
+function prepareIndexFromParallel(X, knnInternal, metricName, metricOptions, nNeighbors, searchRngState, angular) {
+	const internal = resolveInternalMetric(metricName, metricOptions);
+	const pairDist = (x, y) => internal.dist(x, y);
+	const searchIndex = prepareSearchIndex(X, knnInternal, pairDist, internal.correction, angular ?? internal.angularTrees, nNeighbors, searchRngState);
+	const outDst = new Float32Array(knnInternal.distances.length);
+	for (let t = 0; t < outDst.length; t++) {
+		const d = knnInternal.distances[t];
+		outDst[t] = d === Infinity ? Infinity : internal.correction(d);
+	}
+	return {
+		searchIndex,
+		knn: {
+			indices: knnInternal.indices.slice(),
+			distances: outDst,
+			k: knnInternal.k
+		}
+	};
+}
+
+//#endregion
+//#region src/graph/supervised.ts
+/**
+* fast_intersection semantics in-place over a COPY of the graph:
+* unknown (−1) edges ×= e^{−unknown_dist}; mismatched labels ×= e^{−far_dist}.
+*/
+function fastIntersection(graph, target, unknownDist = 1, farDist = 5) {
+	const out = {
+		data: graph.data.slice(),
+		indices: graph.indices,
+		indptr: graph.indptr,
+		rows: graph.rows,
+		cols: graph.cols
+	};
+	const eUnknown = Math.exp(-unknownDist);
+	const eFar = Math.exp(-farDist);
+	for (let i = 0; i < out.rows; i++) {
+		const ti = target[i];
+		for (let p = out.indptr[i]; p < out.indptr[i + 1]; p++) {
+			const tj = target[out.indices[p]];
+			if (ti === -1 || tj === -1) out.data[p] = out.data[p] * eUnknown;
+			else if (ti !== tj) out.data[p] = out.data[p] * eFar;
+		}
+	}
+	return out;
+}
+/** reset_local_connectivity (umap_.py:749-777): row-max normalize + fuzzy union. */
+function resetLocalConnectivity(graph) {
+	const normed = csrRowNormalizeMax({
+		data: graph.data.slice(),
+		indices: graph.indices,
+		indptr: graph.indptr,
+		rows: graph.rows,
+		cols: graph.cols
+	});
+	return csrEliminateZeros(csrBinaryOp(normed, csrTranspose(normed), (a, b) => a + b - a * b));
+}
+/**
+* discrete_metric_simplicial_set_intersection with metric=None (categorical path):
+* fast_intersection then reset_local_connectivity (umap_.py:780-855).
+*/
+function categoricalSimplicialSetIntersection(graph, target, { unknownDist = 1, farDist = 5 } = {}) {
+	return resetLocalConnectivity(csrEliminateZeros(fastIntersection(graph, target, unknownDist, farDist)));
+}
+/**
+* general_simplicial_set_intersection (umap_.py:858-883 + sparse.py:146-197):
+* result sparsity = union (A + B); values re-mixed by weight where either side
+* exceeds its floor.
+*/
+function generalSimplicialSetIntersection(A, B, weight) {
+	let leftMin = Infinity;
+	for (let t = 0; t < A.data.length; t++) if (A.data[t] < leftMin) leftMin = A.data[t];
+	leftMin = Math.max(leftMin / 2, 1e-8);
+	let rightMin = Infinity;
+	for (let t = 0; t < B.data.length; t++) if (B.data[t] < rightMin) rightMin = B.data[t];
+	rightMin = Math.min(Math.max(rightMin / 2, 1e-8), 1e-4);
+	return csrBinaryOp(A, B, (a, b) => {
+		const leftVal = a !== 0 ? a : leftMin;
+		const rightVal = b !== 0 ? b : rightMin;
+		if (leftVal > leftMin || rightVal > rightMin) {
+			if (weight < .5) return leftVal * rightVal ** (weight / (1 - weight));
+			return leftVal ** ((1 - weight) / weight) * rightVal;
+		}
+		return a + b;
+	});
+}
+/** far_dist rule from target_weight (umap_.py:2706-2713). */
+function farDistFromWeight(targetWeight) {
+	return targetWeight < 1 ? 2.5 * (1 / (1 - targetWeight)) : 0xe8d4a51000;
+}
+
+//#endregion
+//#region src/layout/densmap.ts
+/** Binary-search lookup in a canonical CSR row; absent → 0 (DOK semantics). */
+function csrLookup(m, row, col) {
+	let lo = m.indptr[row];
+	let hi = m.indptr[row + 1] - 1;
+	while (lo <= hi) {
+		const mid = lo + hi >> 1;
+		const c = m.indices[mid];
+		if (c === col) return m.data[mid];
+		if (c < col) lo = mid + 1;
+		else hi = mid - 1;
+	}
+	return 0;
+}
+/**
+* Original radii over the PRUNED graph edges, using the symmetrized kNN distance
+* matrix `dists`. `head`/`tail`/`mu` are the pruned COO arrays.
+*/
+function computeOrigRadii(head, tail, mu, dists, nVertices) {
+	const ro = new Float32Array(nVertices);
+	const muSum = new Float32Array(nVertices);
+	for (let i = 0; i < head.length; i++) {
+		const j = head[i];
+		const k = tail[i];
+		const dRaw = csrLookup(dists, j, k);
+		const D = dRaw * dRaw;
+		const m = mu[i];
+		ro[j] = ro[j] + m * D;
+		ro[k] = ro[k] + m * D;
+		muSum[j] = muSum[j] + m;
+		muSum[k] = muSum[k] + m;
+	}
+	const R = new Float32Array(nVertices);
+	let mean = 0;
+	for (let i = 0; i < nVertices; i++) {
+		ro[i] = Math.log(1e-8 + ro[i] / muSum[i]);
+		mean += ro[i];
+	}
+	mean /= nVertices;
+	let variance = 0;
+	for (let i = 0; i < nVertices; i++) variance += (ro[i] - mean) ** 2;
+	variance /= nVertices;
+	const std = Math.sqrt(variance);
+	for (let i = 0; i < nVertices; i++) R[i] = (ro[i] - mean) / std;
+	return {
+		ro,
+		muSum,
+		R
+	};
+}
+/**
+* Embedding radii for outputDens: mu-weighted mean of UNsquared embedding kNN
+* distances over a fresh fuzzy set built on the embedding (asymmetric with
+* rad_orig, which squares — pinned quirk).
+*/
+function computeEmbRadii(graph, dists, nVertices) {
+	const re = new Float32Array(nVertices);
+	const muSum = new Float32Array(nVertices);
+	for (let j = 0; j < nVertices; j++) for (let p = graph.indptr[j]; p < graph.indptr[j + 1]; p++) {
+		const k = graph.indices[p];
+		const m = graph.data[p];
+		const D = csrLookup(dists, j, k);
+		re[j] = re[j] + m * D;
+		re[k] = re[k] + m * D;
+		muSum[j] = muSum[j] + m;
+		muSum[k] = muSum[k] + m;
+	}
+	for (let i = 0; i < nVertices; i++) re[i] = Math.log(1e-8 + re[i] / muSum[i]);
+	return re;
+}
+
+//#endregion
+//#region src/layout/outputMetrics.ts
+function euclideanGrad(x, y, grad) {
+	let s = 0;
+	for (let i = 0; i < x.length; i++) {
+		const d = x[i] - y[i];
+		s += d * d;
+	}
+	const dist = Math.sqrt(s);
+	for (let i = 0; i < x.length; i++) grad[i] = (x[i] - y[i]) / (1e-6 + dist);
+	return dist;
+}
+/** haversine_grad (distances.py:504-531) — 2-D only, latitudes offset by π/2. */
+function haversineGrad(x, y, grad) {
+	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 cosLat = Math.cos(.5 * (x[0] - y[0]));
+	const sinLong = Math.sin(.5 * (x[1] - y[1]));
+	const cosLong = Math.cos(.5 * (x[1] - y[1]));
+	const a1 = Math.cos(x[0] + Math.PI / 2) * Math.cos(y[0] + Math.PI / 2) * sinLong * sinLong + sinLat * sinLat;
+	const d = 2 * Math.asin(Math.sqrt(Math.min(Math.max(Math.abs(a1), 0), 1)));
+	const denom = Math.sqrt(Math.abs(a1 - 1)) * Math.sqrt(Math.abs(a1));
+	grad[0] = (sinLat * cosLat - Math.sin(x[0] + Math.PI / 2) * Math.cos(y[0] + Math.PI / 2) * sinLong * sinLong) / (denom + 1e-6);
+	grad[1] = Math.cos(x[0] + Math.PI / 2) * Math.cos(y[0] + Math.PI / 2) * sinLong * cosLong / (denom + 1e-6);
+	return d;
+}
+/** hyperboloid_grad (distances.py:205-225) — reduced hyperboloid coordinates. */
+function hyperboloidGrad(x, y, grad) {
+	let sx = 1;
+	let sy = 1;
+	let dot = 0;
+	for (let i = 0; i < x.length; i++) {
+		sx += x[i] * x[i];
+		sy += y[i] * y[i];
+		dot += x[i] * y[i];
+	}
+	const s = Math.sqrt(sx);
+	const t = Math.sqrt(sy);
+	let B = s * t - dot;
+	if (B <= 1) B = 1.00000001;
+	const gradCoeff = 1 / (Math.sqrt(B - 1) * Math.sqrt(B + 1));
+	for (let i = 0; i < x.length; i++) grad[i] = gradCoeff * (x[i] * t / s - y[i]);
+	return Math.acosh(B);
+}
+const OUTPUT_METRIC_GRADS = {
+	euclidean: euclideanGrad,
+	l2: euclideanGrad,
+	haversine: haversineGrad,
+	hyperboloid: hyperboloidGrad
+};
+function resolveOutputMetricGrad(name) {
+	const fn = OUTPUT_METRIC_GRADS[name];
+	if (!fn) throw new UmapValidationError(`gradient function is not implemented for output metric '${name}' (supported: ${Object.keys(OUTPUT_METRIC_GRADS).join(", ")})`);
+	return fn;
+}
+function isEuclideanOutput(name) {
+	return name === "euclidean" || name === "l2";
+}
+
+//#endregion
+//#region src/estimator/options.ts
+/** DISCONNECTION_DISTANCES (umap_.py:61-68). */
+const DISCONNECTION_DISTANCES = {
+	correlation: 2,
+	cosine: 2,
+	hellinger: 1,
+	jaccard: 1,
+	bit_jaccard: 1,
+	dice: 1
+};
+
+//#endregion
+//#region src/estimator/serialize.ts
+const MAGIC = "UMAPWEB1";
+const BYTES_PER = {
+	f32: 4,
+	f64: 8,
+	i32: 4,
+	u8: 1
+};
+function dtypeOf(arr) {
+	if (arr instanceof Float32Array) return "f32";
+	if (arr instanceof Float64Array) return "f64";
+	if (arr instanceof Int32Array) return "i32";
+	return "u8";
+}
+function serializeModel(model) {
+	const m = model;
+	if (!m._embedding) throw new UmapError("cannot serialize an unfitted model");
+	if (typeof model.options.metric === "function") throw new UmapValidationError("models with custom metric functions cannot be serialized");
+	if (m._rawCsr) throw new UmapValidationError("sparse-fitted model serialization is not supported");
+	if (!m._graph || !m._sigmas || !m._rhos) throw new UmapError("cannot serialize a partially fitted model");
+	const sections = [];
+	const push = (name, arr) => {
+		if (arr) sections.push({
+			name,
+			arr
+		});
+	};
+	push("embedding", m._embedding.data);
+	push("embeddingUnique", m._embeddingUnique);
+	push("graph.data", m._graph.data);
+	push("graph.indices", m._graph.indices);
+	push("graph.indptr", m._graph.indptr);
+	push("sigmas", m._sigmas);
+	push("rhos", m._rhos);
+	push("knn.indices", m._knn?.indices);
+	push("knn.distances", m._knn?.distances);
+	push("rawData", m._rawData?.data);
+	push("uniqueIndex", m._uniqueIndex);
+	push("uniqueInverse", m._uniqueInverse);
+	push("radOrig", m._radOrig);
+	push("radEmb", m._radEmb);
+	const si = m._searchIndex;
+	if (si) {
+		push("si.indptr", si.indptr);
+		push("si.indices", si.indices);
+		push("si.vertexOrder", si.vertexOrder);
+		push("si.data", si.data.data);
+		push("si.tree.hyperplanes", si.tree.hyperplanes);
+		push("si.tree.offsets", si.tree.offsets);
+		push("si.tree.children", si.tree.children);
+		push("si.tree.indices", si.tree.indices);
+		push("si.searchRngState", si.searchRngState);
+	}
+	let offset = 0;
+	const sectionMeta = [];
+	for (const s of sections) {
+		offset = Math.ceil(offset / 8) * 8;
+		sectionMeta.push({
+			name: s.name,
+			dtype: dtypeOf(s.arr),
+			offset,
+			length: s.arr.length
+		});
+		offset += s.arr.length * BYTES_PER[dtypeOf(s.arr)];
+	}
+	const { onEpoch: _onEpoch, verbose: _verbose, device: _device, precomputedKnn: _precomputedKnn,...serializableOptions } = model.options;
+	const header = {
+		magic: MAGIC,
+		version: 1,
+		options: serializableOptions,
+		scalars: {
+			a: m._a,
+			b: m._b,
+			nNeighborsUsed: m._nNeighborsUsed,
+			smallData: m._smallData,
+			disconnection: m._disconnection === Infinity ? "inf" : m._disconnection,
+			supervised: m._supervised,
+			inputHash: m._inputHash,
+			embedding: {
+				rows: m._embedding.rows,
+				cols: m._embedding.cols
+			},
+			graph: {
+				rows: m._graph.rows,
+				cols: m._graph.cols
+			},
+			knnK: m._knn?.k ?? null,
+			rawData: m._rawData ? {
+				rows: m._rawData.rows,
+				cols: m._rawData.cols
+			} : null,
+			searchIndex: si ? {
+				angular: si.angular,
+				minDistance: si.minDistance,
+				nNeighbors: si.nNeighbors,
+				metricName: model.options.metric ?? "euclidean",
+				tree: {
+					leafSize: si.tree.leafSize,
+					nNodes: si.tree.nNodes,
+					dim: si.tree.dim
+				},
+				dataRows: si.data.rows,
+				dataCols: si.data.cols
+			} : null
+		},
+		sections: sectionMeta
+	};
+	const headerBytes = new TextEncoder().encode(JSON.stringify(header));
+	const base = Math.ceil((12 + headerBytes.length) / 8) * 8;
+	const total = base + offset;
+	const out = new Uint8Array(total);
+	const dv = new DataView(out.buffer);
+	out.set(new TextEncoder().encode(MAGIC), 0);
+	dv.setUint32(8, headerBytes.length, true);
+	out.set(headerBytes, 12);
+	for (let i = 0; i < sections.length; i++) {
+		const s = sections[i];
+		const metaS = sectionMeta[i];
+		const bytes = new Uint8Array(s.arr.buffer, s.arr.byteOffset, s.arr.byteLength);
+		out.set(bytes, base + metaS.offset);
+	}
+	return out;
+}
+function fail(why) {
+	throw new UmapValidationError(`invalid serialized model: ${why}`);
+}
+function reqInt(v, name, min) {
+	if (typeof v !== "number" || !Number.isInteger(v) || v < min) fail(`${name} must be an integer >= ${min}`);
+	return v;
+}
+function reqFinite(v, name) {
+	if (typeof v !== "number" || !Number.isFinite(v)) fail(`${name} must be a finite number`);
+	return v;
+}
+function reqBool(v, name) {
+	if (typeof v !== "boolean") fail(`${name} must be a boolean`);
+	return v;
+}
+/** indptr shape: length n+1, starts at 0, monotone, ends at nnz. */
+function checkIndptr(indptr, n, nnz, name) {
+	if (indptr.length !== n + 1) fail(`${name} length must be ${n + 1}`);
+	if (indptr[0] !== 0) fail(`${name} must start at 0`);
+	for (let i = 0; i < n; i++) if (indptr[i + 1] < indptr[i]) fail(`${name} must be non-decreasing`);
+	if (indptr[n] !== nnz) fail(`${name} end (${indptr[n]}) must equal nnz (${nnz})`);
+}
+function checkIndexRange(arr, lo, hi, name) {
+	for (let i = 0; i < arr.length; i++) {
+		const v = arr[i];
+		if (v < lo || v >= hi) fail(`${name} contains out-of-range index ${v}`);
+	}
+}
+function deserializeModel(blob, UMAPClass) {
+	if (!(blob instanceof Uint8Array)) fail("expected a Uint8Array");
+	if (blob.byteLength < 12) fail("blob too short for a header");
+	if (new TextDecoder().decode(blob.subarray(0, 8)) !== MAGIC) fail("bad magic (not a umap-web serialized model)");
+	const headerLen = new DataView(blob.buffer, blob.byteOffset, blob.byteLength).getUint32(8, true);
+	if (12 + headerLen > blob.byteLength) fail("declared header length exceeds the blob");
+	let header;
+	try {
+		header = JSON.parse(new TextDecoder().decode(blob.subarray(12, 12 + headerLen)));
+	} catch {
+		fail("corrupt JSON header");
+	}
+	if (header?.version !== 1) throw new UmapValidationError(`unsupported serialization version ${header?.version}`);
+	const sc = header.scalars;
+	if (typeof sc !== "object" || sc === null || !Array.isArray(header.sections)) fail("malformed header");
+	const base = Math.ceil((12 + headerLen) / 8) * 8;
+	const metas = /* @__PURE__ */ new Map();
+	for (const s of header.sections) {
+		if (typeof s?.name !== "string" || !(s?.dtype in BYTES_PER)) fail("malformed section entry");
+		reqInt(s.offset, `section ${s.name} offset`, 0);
+		reqInt(s.length, `section ${s.name} length`, 0);
+		if (base + s.offset + s.length * BYTES_PER[s.dtype] > blob.byteLength) fail(`section ${s.name} exceeds the blob bounds`);
+		if (metas.has(s.name)) fail(`duplicate section ${s.name}`);
+		metas.set(s.name, s);
+	}
+	const view = (s) => {
+		const start = blob.byteOffset + base + s.offset;
+		switch (s.dtype) {
+			case "f32": return new Float32Array(blob.buffer.slice(start, start + s.length * 4));
+			case "f64": return new Float64Array(blob.buffer.slice(start, start + s.length * 8));
+			case "i32": return new Int32Array(blob.buffer.slice(start, start + s.length * 4));
+			default: return new Uint8Array(blob.buffer.slice(start, start + s.length));
+		}
+	};
+	const arrays = /* @__PURE__ */ new Map();
+	for (const s of metas.values()) arrays.set(s.name, view(s));
+	/** Fetch a section, enforcing its declared dtype (a lying header must not type-pun). */
+	const need = (name, dtype) => {
+		const meta = metas.get(name);
+		const a = arrays.get(name);
+		if (!meta || !a) fail(`missing section ${name}`);
+		if (meta.dtype !== dtype) fail(`section ${name} has dtype ${meta.dtype}, expected ${dtype}`);
+		return a;
+	};
+	const optional = (name, dtype) => metas.has(name) ? need(name, dtype) : null;
+	const { onEpoch: _onEpoch, verbose: _verbose, device: _device, precomputedKnn: _precomputedKnn,...options } = typeof header.options === "object" && header.options !== null ? header.options : {};
+	const model = new UMAPClass(options);
+	const m = model;
+	m._a = reqFinite(sc.a, "scalars.a");
+	m._b = reqFinite(sc.b, "scalars.b");
+	if (sc.disconnection !== "inf") reqFinite(sc.disconnection, "scalars.disconnection");
+	m._disconnection = sc.disconnection === "inf" ? Infinity : sc.disconnection;
+	m._smallData = reqBool(sc.smallData, "scalars.smallData");
+	m._supervised = reqBool(sc.supervised, "scalars.supervised");
+	if (sc.inputHash !== null && typeof sc.inputHash !== "string") fail("scalars.inputHash must be a string or null");
+	m._inputHash = sc.inputHash;
+	const embRows = reqInt(sc.embedding?.rows, "embedding.rows", 1);
+	const embCols = reqInt(sc.embedding?.cols, "embedding.cols", 1);
+	const embData = need("embedding", "f32");
+	if (embData.length !== embRows * embCols) fail("embedding data does not match rows*cols");
+	m._embedding = {
+		data: embData,
+		rows: embRows,
+		cols: embCols
+	};
+	const gRows = reqInt(sc.graph?.rows, "graph.rows", 1);
+	const gCols = reqInt(sc.graph?.cols, "graph.cols", 1);
+	if (gRows !== gCols) fail("graph must be square");
+	const gData = need("graph.data", "f64");
+	const gIndices = need("graph.indices", "i32");
+	const gIndptr = need("graph.indptr", "i32");
+	if (gIndices.length !== gData.length) fail("graph indices/data length mismatch");
+	checkIndptr(gIndptr, gRows, gData.length, "graph.indptr");
+	checkIndexRange(gIndices, 0, gCols, "graph.indices");
+	m._graph = {
+		data: gData,
+		indices: gIndices,
+		indptr: gIndptr,
+		rows: gRows,
+		cols: gCols
+	};
+	m._nNeighborsUsed = reqInt(sc.nNeighborsUsed, "scalars.nNeighborsUsed", 1);
+	if (m._nNeighborsUsed > gRows) fail("nNeighborsUsed exceeds the number of training rows");
+	m._sigmas = need("sigmas", "f32");
+	m._rhos = need("rhos", "f32");
+	if (m._sigmas.length !== gRows || m._rhos.length !== gRows) fail("sigmas/rhos length must equal graph.rows");
+	const embUnique = optional("embeddingUnique", "f32");
+	if (embUnique && embUnique.length !== gRows * embCols) fail("embeddingUnique length must equal graph.rows * embedding.cols");
+	m._embeddingUnique = embUnique ?? m._embedding.data;
+	if (sc.knnK != null) {
+		const k = reqInt(sc.knnK, "scalars.knnK", 1);
+		const ki = need("knn.indices", "i32");
+		const kd = need("knn.distances", "f32");
+		if (ki.length !== gRows * k || kd.length !== gRows * k) fail("knn arrays must have graph.rows * k entries");
+		checkIndexRange(ki, -1, gRows, "knn.indices");
+		m._knn = {
+			indices: ki,
+			distances: kd,
+			k
+		};
+	}
+	if (sc.rawData != null) {
+		const rRows = reqInt(sc.rawData.rows, "rawData.rows", 1);
+		const rCols = reqInt(sc.rawData.cols, "rawData.cols", 1);
+		const rData = need("rawData", "f32");
+		if (rData.length !== rRows * rCols) fail("rawData does not match rows*cols");
+		if (rRows !== embRows) fail("rawData.rows must equal embedding.rows");
+		m._rawData = {
+			data: rData,
+			rows: rRows,
+			cols: rCols
+		};
+	}
+	const uniqueIndex = optional("uniqueIndex", "i32");
+	const uniqueInverse = optional("uniqueInverse", "i32");
+	if (uniqueIndex === null !== (uniqueInverse === null)) fail("uniqueIndex/uniqueInverse must be present together");
+	if (uniqueIndex && uniqueInverse) {
+		if (uniqueIndex.length !== gRows) fail("uniqueIndex length must equal graph.rows");
+		if (uniqueInverse.length !== embRows) fail("uniqueInverse length must equal embedding.rows");
+		if (m._rawData) checkIndexRange(uniqueIndex, 0, m._rawData.rows, "uniqueIndex");
+		checkIndexRange(uniqueInverse, 0, gRows, "uniqueInverse");
+	}
+	m._uniqueIndex = uniqueIndex;
+	m._uniqueInverse = uniqueInverse;
+	const radOrig = optional("radOrig", "f32");
+	const radEmb = optional("radEmb", "f32");
+	if (radOrig && radOrig.length !== embRows) fail("radOrig length must equal embedding.rows");
+	if (radEmb && radEmb.length !== embRows) fail("radEmb length must equal embedding.rows");
+	m._radOrig = radOrig;
+	m._radEmb = radEmb;
+	if (sc.searchIndex != null) {
+		const s = sc.searchIndex;
+		if (typeof s.metricName !== "string") fail("searchIndex.metricName must be a string");
+		const angular = reqBool(s.angular, "searchIndex.angular");
+		if (typeof s.minDistance !== "number" || Number.isNaN(s.minDistance)) fail("searchIndex.minDistance must be a number");
+		const siNeighbors = reqInt(s.nNeighbors, "searchIndex.nNeighbors", 1);
+		const dataRows = reqInt(s.dataRows, "searchIndex.dataRows", 1);
+		const dataCols = reqInt(s.dataCols, "searchIndex.dataCols", 1);
+		if (dataRows !== gRows) fail("searchIndex.dataRows must equal graph.rows");
+		if (m._rawData && dataCols !== m._rawData.cols) fail("searchIndex.dataCols must equal rawData.cols");
+		const siData = need("si.data", "f32");
+		if (siData.length !== dataRows * dataCols) fail("si.data does not match rows*cols");
+		const leafSize = reqInt(s.tree?.leafSize, "searchIndex.tree.leafSize", 1);
+		const nNodes = reqInt(s.tree?.nNodes, "searchIndex.tree.nNodes", 1);
+		const dim = reqInt(s.tree?.dim, "searchIndex.tree.dim", 1);
+		if (dim !== dataCols) fail("searchIndex.tree.dim must equal dataCols");
+		const hyperplanes = need("si.tree.hyperplanes", "f32");
+		const offsets = need("si.tree.offsets", "f32");
+		const children = need("si.tree.children", "i32");
+		const treeIndices = need("si.tree.indices", "i32");
+		if (hyperplanes.length !== nNodes * dim) fail("si.tree.hyperplanes size mismatch");
+		if (offsets.length !== nNodes) fail("si.tree.offsets size mismatch");
+		if (children.length !== nNodes * 2) fail("si.tree.children size mismatch");
+		if (treeIndices.length !== dataRows) fail("si.tree.indices size mismatch");
+		checkIndexRange(treeIndices, 0, dataRows, "si.tree.indices");
+		for (let i = 0; i < nNodes; i++) {
+			const c0 = children[i * 2];
+			const c1 = children[i * 2 + 1];
+			if (c0 > 0) {
+				if (c0 <= i || c0 >= nNodes || c1 <= i || c1 >= nNodes) fail(`si.tree.children node ${i} violates preorder traversal`);
+			} else {
+				const ls = -c0;
+				const le = -c1;
+				if (ls < 0 || le < ls || le > treeIndices.length) fail(`si.tree.children node ${i} has an invalid leaf range`);
+			}
+		}
+		const tree = {
+			hyperplanes,
+			offsets,
+			children,
+			indices: treeIndices,
+			leafSize,
+			nNodes,
+			dim
+		};
+		const siIndptr = need("si.indptr", "i32");
+		const siIndices = need("si.indices", "i32");
+		checkIndptr(siIndptr, dataRows, siIndices.length, "si.indptr");
+		checkIndexRange(siIndices, 0, dataRows, "si.indices");
+		const vertexOrder = need("si.vertexOrder", "i32");
+		if (vertexOrder.length !== dataRows) fail("si.vertexOrder size mismatch");
+		checkIndexRange(vertexOrder, 0, dataRows, "si.vertexOrder");
+		const searchRngState = need("si.searchRngState", "i32");
+		if (searchRngState.length !== 3) fail("si.searchRngState must have 3 words");
+		const internal = resolveInternalMetric(s.metricName, model.options.metricOptions ?? {});
+		m._searchIndex = {
+			indptr: siIndptr,
+			indices: siIndices,
+			tree,
+			vertexOrder,
+			data: {
+				data: siData,
+				rows: dataRows,
+				cols: dataCols
+			},
+			dist: (a, b) => internal.dist(a, b),
+			correction: internal.correction,
+			angular,
+			minDistance: s.minDistance,
+			searchRngState,
+			nNeighbors: siNeighbors
+		};
+	}
+	return model;
+}
+
+//#endregion
+//#region src/estimator/transform-init.ts
+/**
+* init_graph_transform (umap_.py:1337-1375): weighted mean of train embedding rows.
+* Rows with no nonzeros → NaN; a weight == 1.0 copies that train row exactly.
+*/
+function initGraphTransform(graph, embedding, dim) {
+	const nNew = graph.rows;
+	const out = new Float32Array(nNew * dim);
+	for (let row = 0; row < nNew; row++) {
+		const start = graph.indptr[row];
+		const end = graph.indptr[row + 1];
+		if (start === end) {
+			for (let d = 0; d < dim; d++) out[row * dim + d] = NaN;
+			continue;
+		}
+		let rowSum = 0;
+		let exactCol = -1;
+		for (let p = start; p < end; p++) {
+			rowSum += graph.data[p];
+			if (graph.data[p] === 1 && exactCol === -1) exactCol = graph.indices[p];
+		}
+		if (exactCol !== -1) {
+			for (let d = 0; d < dim; d++) out[row * dim + d] = embedding[exactCol * dim + d];
+			continue;
+		}
+		for (let p = start; p < end; p++) {
+			const w = graph.data[p] / rowSum;
+			const col = graph.indices[p];
+			for (let d = 0; d < dim; d++) out[row * dim + d] = out[row * dim + d] + w * embedding[col * dim + d];
+		}
+	}
+	return out;
+}
+/**
+* init_transform (umap_.py:1304-1334): constant-degree weighted mean of raw data
+* rows (used by inverseTransform).
+*/
+function initTransform(indices, weights, degree, data, dim) {
+	const nNew = indices.length / degree;
+	const out = new Float32Array(nNew * dim);
+	for (let i = 0; i < nNew; i++) for (let j = 0; j < degree; j++) {
+		const w = weights[i * degree + j];
+		const col = indices[i * degree + j];
+		for (let d = 0; d < dim; d++) out[i * dim + d] = out[i * dim + d] + w * data[col * dim + d];
+	}
+	return out;
+}
+/**
+* init_update (umap_.py:1378-1390) for update(): each new point gets the summed
+* coordinates of its OLD-point neighbors divided by (count × dim) — the pinned
+* quirk divides by the extra dim factor.
+*/
+function initUpdate(embedding, dim, originalSize, knnIndices, k) {
+	const nTotal = embedding.length / dim;
+	for (let i = originalSize; i < nTotal; i++) {
+		let count = 0;
+		for (let j = 0; j < k; j++) {
+			const nb = knnIndices[i * k + j];
+			if (nb >= 0 && nb < originalSize) {
+				count += dim;
+				for (let d = 0; d < dim; d++) embedding[i * dim + d] = embedding[i * dim + d] + embedding[nb * dim + d];
+			}
+		}
+		if (count > 0) for (let d = 0; d < dim; d++) embedding[i * dim + d] = embedding[i * dim + d] / count;
+	}
+}
+
+//#endregion
+//#region src/estimator/umap.ts
+const yieldToLoop = typeof setImmediate === "function" ? () => new Promise((r) => setImmediate(r)) : () => new Promise((r) => setTimeout(r, 0));
+/** Bound on requestAdapter/requestDevice — a broken GPU stack must fall back, not hang. */
+const GPU_ACQUIRE_TIMEOUT_MS = 5e3;
+function entropySeed() {
+	const cryptoObj = globalThis.crypto;
+	if (typeof cryptoObj?.getRandomValues !== "function") throw new UmapError("no global crypto available for entropy seeding — pass options.seed explicitly");
+	const buf = new Uint32Array(2);
+	cryptoObj.getRandomValues(buf);
+	return buf[0] + (buf[1] & 2097151) * 4294967296;
+}
+/** FNV-1a over bytes — cheap input-identity hash (same-data transform shortcut). */
+function contentHash(view) {
+	let h1 = 2166136261;
+	let h2 = 3421674724;
+	for (let i = 0; i < view.length; i++) {
+		h1 = Math.imul(h1 ^ view[i], 16777619) >>> 0;
+		h2 = Math.imul(h2 ^ view[i], 16777623) >>> 0;
+	}
+	return `${view.length}:${h1.toString(16)}:${h2.toString(16)}`;
+}
+/** Bitwise equality (confirms a contentHash match; Float32Array offsets are 4-aligned). */
+function sameFloat32Bits(a, b) {
+	if (a.length !== b.length) return false;
+	const ai = new Int32Array(a.buffer, a.byteOffset, a.length);
+	const bi = new Int32Array(b.buffer, b.byteOffset, b.length);
+	for (let i = 0; i < ai.length; i++) if (ai[i] !== bi[i]) return false;
+	return true;
+}
+var UMAP = class UMAP {
+	options;
+	logger;
+	_embedding = null;
+	_embeddingUnique = null;
+	_graph = null;
+	_sigmas = null;
+	_rhos = null;
+	_knn = null;
+	_searchIndex = null;
+	_rawData = null;
+	_rawCsr = null;
+	_uniqueIndex = null;
+	_uniqueInverse = null;
+	_a = 0;
+	_b = 0;
+	_nNeighborsUsed = 15;
+	_smallData = false;
+	_disconnection = Infinity;
+	_supervised = false;
+	_inputHash = null;
+	_radOrig = null;
+	_radEmb = null;
+	_backendInfo = {
+		knn: "none",
+		layout: "none"
+	};
+	_timings = {};
+	_parallel = null;
+	_gpu = null;
+	_gpuCtx = null;
+	_useGpuLayout = false;
+	/** name of the in-flight operation; guards against concurrent use */
+	_busy = null;
+	constructor(options = {}) {
+		this.options = { ...options };
+		this.logger = typeof options.verbose === "object" ? options.verbose : options.verbose ? consoleLogger : silentLogger;
+		this.validateOptions();
+	}
+	validateOptions() {
+		const o = this.options;
+		const positive = (name, v) => {
+			if (v !== void 0 && !(v > 0)) throw new UmapValidationError(`${name} must be > 0, got ${v}`);
+		};
+		const positiveInt = (name, v) => {
+			if (v !== void 0 && (!Number.isInteger(v) || v <= 0)) throw new UmapValidationError(`${name} must be a positive integer, got ${v}`);
+		};
+		const inUnit = (name, v) => {
+			if (v !== void 0 && !(v >= 0 && v <= 1)) throw new UmapValidationError(`${name} must be in [0, 1], got ${v}`);
+		};
+		positiveInt("nNeighbors", o.nNeighbors);
+		if (o.nNeighbors !== void 0 && o.nNeighbors < 2) throw new UmapValidationError("nNeighbors must be >= 2 (matching umap-learn)");
+		positiveInt("nComponents", o.nComponents);
+		positiveInt("negativeSampleRate", o.negativeSampleRate);
+		if (o.targetNNeighbors !== void 0 && o.targetNNeighbors !== -1) positiveInt("targetNNeighbors", o.targetNNeighbors);
+		positive("learningRate", o.learningRate);
+		positive("spread", o.spread);
+		positive("localConnectivity", o.localConnectivity);
+		if (o.repulsionStrength !== void 0 && !(o.repulsionStrength >= 0)) throw new UmapValidationError(`repulsionStrength must be >= 0, got ${o.repulsionStrength}`);
+		if (o.minDist !== void 0 && o.minDist < 0) throw new UmapValidationError(`minDist must be >= 0, got ${o.minDist}`);
+		if (o.minDist !== void 0 && o.spread !== void 0 && o.minDist > o.spread) throw new UmapValidationError("minDist must be <= spread");
+		inUnit("setOpMixRatio", o.setOpMixRatio);
+		inUnit("targetWeight", o.targetWeight);
+		inUnit("densFrac", o.densFrac);
+		inUnit("densVarShift", o.densVarShift);
+		if (o.nEpochs !== void 0 && (o.nEpochs < 0 || !Number.isInteger(o.nEpochs))) throw new UmapValidationError("nEpochs must be a nonnegative integer");
+		if (o.a === void 0 !== (o.b === void 0)) throw new UmapValidationError("a and b must be provided together (or both derived)");
+		if (o.concurrency !== void 0 && o.concurrency !== "auto") positiveInt("concurrency", o.concurrency);
+		if (o.backend !== void 0 && o.backend !== "auto" && o.backend !== "cpu" && o.backend !== "webgpu") throw new UmapValidationError(`backend must be 'auto' | 'cpu' | 'webgpu' (custom Backend instances are not supported yet), got ${JSON.stringify(o.backend)}`);
+		if (typeof o.metric === "string" && o.metric !== "precomputed" && !isNamedMetric(o.metric)) throw new UmapValidationError(`unknown metric '${o.metric}'`);
+		if (o.targetMetric !== void 0 && o.targetMetric !== "categorical" && !isNamedMetric(o.targetMetric)) throw new UmapValidationError(`unknown targetMetric '${o.targetMetric}'`);
+		if (o.outputMetric === "precomputed") throw new UmapValidationError("outputMetric cannot be precomputed");
+		if (o.outputMetric !== void 0 && !isEuclideanOutput(o.outputMetric)) resolveOutputMetricGrad(o.outputMetric);
+		if (o.outputMetricOptions && Object.keys(o.outputMetricOptions).length > 0) throw new UmapValidationError("outputMetricOptions is not consumed by any named output metric in this port; remove it rather than have it silently ignored");
+		if (o.densMap && o.outputMetric && !isEuclideanOutput(o.outputMetric)) throw new UmapValidationError("densMap requires euclidean output metric");
+		if (o.unique && o.metric === "precomputed") throw new UmapValidationError("unique is poorly defined on a precomputed metric");
+		if (o.unique && o.precomputedKnn) throw new UmapValidationError("unique cannot be used with precomputedKnn");
+	}
+	get embedding() {
+		if (!this._embedding) throw new UmapError("model is not fitted");
+		return this._embedding;
+	}
+	/** CSR fuzzy graph over the training data (unique rows when unique=true). */
+	get graph() {
+		if (!this._graph) throw new UmapError("model is not fitted");
+		return this._graph;
+	}
+	get densities() {
+		if (!this._radOrig || !this._radEmb) throw new UmapError("densities require fitting with outputDens: true");
+		return {
+			original: this._radOrig,
+			embedded: this._radEmb
+		};
+	}
+	/** Which backend actually executed each stage (§5.2). */
+	get backendInfo() {
+		return { ...this._backendInfo };
+	}
+	get phaseTimings() {
+		return { ...this._timings };
+	}
+	resolveMetricName() {
+		const m = this.options.metric ?? "euclidean";
+		return typeof m === "function" ? "<custom>" : m;
+	}
+	/** Serialize operations on one instance: concurrent calls are a caller bug. */
+	async withBusy(name, fn) {
+		if (this._busy) throw new UmapError(`cannot ${name}: ${this._busy}() is already in progress on this estimator`);
+		this._busy = name;
+		try {
+			return await fn();
+		} finally {
+			this._busy = null;
+		}
+	}
+	snapshotFittedState() {
+		return {
+			_embedding: this._embedding,
+			_embeddingUnique: this._embeddingUnique,
+			_graph: this._graph,
+			_sigmas: this._sigmas,
+			_rhos: this._rhos,
+			_knn: this._knn,
+			_searchIndex: this._searchIndex,
+			_rawData: this._rawData,
+			_rawCsr: this._rawCsr,
+			_uniqueIndex: this._uniqueIndex,
+			_uniqueInverse: this._uniqueInverse,
+			_radOrig: this._radOrig,
+			_radEmb: this._radEmb,
+			_inputHash: this._inputHash,
+			_a: this._a,
+			_b: this._b,
+			_nNeighborsUsed: this._nNeighborsUsed,
+			_smallData: this._smallData,
+			_disconnection: this._disconnection,
+			_supervised: this._supervised,
+			_useGpuLayout: this._useGpuLayout,
+			_backendInfo: { ...this._backendInfo },
+			_timings: { ...this._timings }
+		};
+	}
+	restoreFittedState(snapshot) {
+		Object.assign(this, snapshot);
+	}
+	/** Discard fitted state so a running fit never exposes a mixed old/new model. */
+	resetFittedState() {
+		this._embedding = null;
+		this._embeddingUnique = null;
+		this._graph = null;
+		this._sigmas = null;
+		this._rhos = null;
+		this._knn = null;
+		this._searchIndex = null;
+		this._rawData = null;
+		this._rawCsr = null;
+		this._uniqueIndex = null;
+		this._uniqueInverse = null;
+		this._radOrig = null;
+		this._radEmb = null;
+		this._inputHash = null;
+		this._supervised = false;
+		this._useGpuLayout = false;
+		this._backendInfo = {
+			knn: "none",
+			layout: "none"
+		};
+		this._timings = {};
+	}
+	/** Stop using the GPU for the rest of this fit (typed failure → CPU, D-017). */
+	dropGpu() {
+		if (this._gpuCtx && !this._gpuCtx.injected) try {
+			this._gpuCtx.device.destroy();
+		} catch {}
+		this._gpuCtx = null;
+		this._gpu = null;
+		this._useGpuLayout = false;
+	}
+	/** Always runs after fit (success, error, or abort): no leaked workers/devices. */
+	async releaseBackends() {
+		if (this._parallel) {
+			const pool = this._parallel.pool;
+			this._parallel = null;
+			await pool.terminate();
+		}
+		if (this._gpuCtx && !this._gpuCtx.injected) {
+			this._gpuCtx.device.destroy();
+			this._gpuCtx = null;
+			this._gpu = null;
+			this._useGpuLayout = false;
+		}
+	}
+	async fit(X, y, { signal } = {}) {
+		return this.withBusy("fit", async () => {
+			throwIfAborted(signal);
+			const snapshot = this.snapshotFittedState();
+			this.resetFittedState();
+			try {
+				return await this.fitInner(X, y, signal);
+			} catch (e) {
+				this.restoreFittedState(snapshot);
+				throw e;
+			} finally {
+				await this.releaseBackends();
+			}
+		});
+	}
+	async fitInner(X, y, signal) {
+		const o = this.options;
+		const nComponents = o.nComponents ?? 2;
+		const metric = o.metric ?? "euclidean";
+		const minDist = o.minDist ?? .1;
+		const spread = o.spread ?? 1;
+		const densMap = o.densMap ?? false;
+		const outputDens = o.outputDens ?? false;
+		const outputMetric = o.outputMetric ?? "euclidean";
+		const seed = o.seed ?? entropySeed();
+		const rng = Pcg32.fromSeed(seed);
+		let denseFull = null;
+		let sparse = null;
+		if (isCsrInput(X)) {
+			sparse = validateCsr(X);
+			this._rawCsr = sparse;
+		} else {
+			denseFull = toMatrix(X);
+			this._rawData = denseFull;
+		}
+		const nFull = denseFull ? denseFull.rows : sparse.rows;
+		if (nFull <= 1) throw new UmapValidationError("need at least 2 samples");
+		if (typeof metric === "string" && o.metricOptions) validateMetricOptionSizes(metric, o.metricOptions, denseFull ? denseFull.cols : sparse.cols);
+		this._inputHash = denseFull ? contentHash(new Uint8Array(denseFull.data.buffer, denseFull.data.byteOffset, denseFull.data.byteLength)) : contentHash(new Uint8Array(sparse.data.buffer, sparse.data.byteOffset, sparse.data.byteLength));
+		let dense = denseFull;
+		if (o.unique) {
+			if (!denseFull) throw new UmapValidationError("unique=true requires dense input");
+			const { index, inverse } = uniqueRows(denseFull);
+			this._uniqueIndex = index;
+			this._uniqueInverse = inverse;
+			if (index.length < nFull) this.logger.info(`unique: ${nFull} rows → ${index.length} unique`);
+			const d = denseFull.cols;
+			const data = new Float32Array(index.length * d);
+			for (let i = 0; i < index.length; i++) data.set(denseFull.data.subarray(index[i] * d, (index[i] + 1) * d), i * d);
+			dense = {
+				data,
+				rows: index.length,
+				cols: d
+			};
+		}
+		const n = dense ? dense.rows : sparse.rows;
+		let nNeighbors = o.nNeighbors ?? 15;
+		if (n - 1 < nNeighbors) {
+			this.logger.warn(`nNeighbors ${nNeighbors} is larger than dataset size ${n}; reduced to ${n - 1}`);
+			nNeighbors = n - 1;
+		}
+		this._nNeighborsUsed = nNeighbors;
+		if (o.a !== void 0 && o.b !== void 0) {
+			this._a = o.a;
+			this._b = o.b;
+		} else {
+			const ab = findABParams(spread, minDist);
+			this._a = ab.a;
+			this._b = ab.b;
+		}
+		const metricName = this.resolveMetricName();
+		this._disconnection = o.disconnectionDistance ?? DISCONNECTION_DISTANCES[metricName] ?? Infinity;
+		this._smallData = n < SMALL_DATA_CUTOFF && !(o.forceApproximation ?? false);
+		const backendOpt = o.backend ?? "auto";
+		let useGpuKnn = false;
+		let useGpuLayout = false;
+		if (backendOpt === "webgpu" && dense === null) this.logger.warn("backend \"webgpu\" requires dense input; this fit runs on the CPU");
+		if (backendOpt === "webgpu" && (o.deterministic ?? false)) this.logger.warn("deterministic: true forces the reproducible CPU path; backend \"webgpu\" is ignored (§5.5)");
+		if ((backendOpt === "webgpu" || backendOpt === "auto") && !(o.deterministic ?? false) && dense !== null) {
+			const hasGpuApi = !!globalThis.navigator?.gpu || o.device !== void 0;
+			if (backendOpt === "webgpu" && !hasGpuApi) throw new UmapBackendError("backend \"webgpu\" requested but WebGPU is unavailable");
+			if (hasGpuApi) {
+				const mod = await import("./webgpu.js");
+				const support = mod.gpuSupportsConfig({
+					...typeof metric === "string" ? { metric } : { metric },
+					outputMetric,
+					densMap,
+					nNeighbors,
+					nComponents
+				});
+				if (backendOpt === "webgpu" || support.knn || support.layout) {
+					const acquire = mod.acquireGpu(o.device);
+					acquire.catch(() => {});
+					try {
+						this._gpuCtx = await raceTimeout(acquire, GPU_ACQUIRE_TIMEOUT_MS, "WebGPU device acquisition");
+						this._gpu = mod;
+						useGpuKnn = support.knn;
+						useGpuLayout = support.layout;
+						this._useGpuLayout = support.layout;
+						if (support.reason) this.logger.warn(support.reason);
+						this.logger.info(`WebGPU: ${this._gpuCtx.adapterInfo.vendor}/${this._gpuCtx.adapterInfo.architecture}`);
+					} catch (e) {
+						acquire.then((ctx) => {
+							if (ctx && !ctx.injected) ctx.device.destroy();
+						}).catch(() => {});
+						if (backendOpt === "webgpu") throw e;
+						this.logger.warn(`WebGPU unavailable (${e.message}); using CPU`);
+					}
+				}
+			}
+		}
+		if (!(useGpuKnn && useGpuLayout) && (o.backend === void 0 || o.backend === "auto" || o.backend === "cpu") && (o.concurrency ?? 1) !== 1 && !(o.deterministic ?? false) && dense !== null && typeof metric === "string" && isNamedMetric(metric) && !o.precomputedKnn) {
+			this._parallel = await createParallelContext(dense, metric, o.metricOptions ?? {}, o.concurrency ?? "auto", o.workerUrl, this.logger);
+			if (this._parallel) this.logger.info(`worker pool: ${this._parallel.pool.size} workers (${this._parallel.sab ? "SharedArrayBuffer" : "transfer fallback"})`);
+		}
+		const t0 = performance.now();
+		let knn;
+		if (o.precomputedKnn) {
+			const pk = o.precomputedKnn;
+			if (pk.k < nNeighbors) throw new UmapValidationError(`precomputedKnn.k=${pk.k} is smaller than nNeighbors=${nNeighbors}`);
+			knn = sliceKnn(pk, n, nNeighbors);
+			if (this._disconnection !== Infinity && knn.indices === pk.indices) knn = {
+				indices: knn.indices.slice(),
+				distances: knn.distances.slice(),
+				k: knn.k
+			};
+			applyDisconnectionToKnn(knn, this._disconnection);
+			this._backendInfo.knn = "precomputed";
+			this._smallData = false;
+		} else if (metric === "precomputed") {
+			if (!dense) throw new UmapValidationError("metric 'precomputed' requires a dense matrix");
+			knn = knnFromPrecomputed(applyDisconnectionToMatrix(dense, this._disconnection), nNeighbors);
+			this._backendInfo.knn = "precomputed-matrix";
+			this._smallData = true;
+		} else if (sparse) {
+			const res = nearestNeighborsSparse(sparse, nNeighbors, metric, rng, {
+				forceApproximation: o.forceApproximation ?? false,
+				angularRpForest: o.angularRpForest ?? false,
+				disconnectionDistance: this._disconnection
+			});
+			knn = res.knn;
+			this._backendInfo.knn = `cpu-${res.method}`;
+		} else {
+			const runCpuKnn = () => {
+				const res = nearestNeighborsDense(dense, nNeighbors, metric, rng, {
+					metricOptions: o.metricOptions ?? {},
+					forceApproximation: o.forceApproximation ?? false,
+					angularRpForest: o.angularRpForest ?? false,
+					disconnectionDistance: this._disconnection
+				});
+				this._searchIndex = res.searchIndex;
+				this._backendInfo.knn = `cpu-${res.method}`;
+				return res.knn;
+			};
+			if (typeof metric === "function") {
+				knn = exactKnnDense(dense, nNeighbors, metric, { disconnectionDistance: this._disconnection });
+				this._backendInfo.knn = "cpu-exact-custom";
+				this._smallData = true;
+			} else if (useGpuKnn && this._gpuCtx && (!this._smallData || backendOpt === "webgpu")) {
+				let gpuKnnResult = null;
+				try {
+					const plan = this._gpu.gpuMetricPlan(metric);
+					gpuKnnResult = await this._gpu.gpuKnn(this._gpuCtx, dense, null, nNeighbors, plan, { ...signal ? { signal } : {} });
+				} catch (e) {
+					if (backendOpt === "webgpu" || !(e instanceof UmapBackendError)) throw e;
+					this.logger.warn(`WebGPU kNN failed (${e.message}); falling back to CPU`);
+					this.dropGpu();
+				}
+				if (gpuKnnResult) {
+					knn = gpuKnnResult;
+					applyDisconnectionToKnn(knn, this._disconnection);
+					this._backendInfo.knn = "webgpu";
+				} else knn = runCpuKnn();
+			} else if (this._parallel && !this._smallData) {
+				const angular = resolveInternalMetric(metric, o.metricOptions ?? {}).angularTrees || (o.angularRpForest ?? false);
+				const par = await parallelNnDescent(this._parallel, nNeighbors, rng, angular);
+				const prepared = prepareIndexFromParallel(dense, par.knnInternal, metric, o.metricOptions ?? {}, nNeighbors, par.searchRngState, angular);
+				knn = prepared.knn;
+				applyDisconnectionToKnn(knn, this._disconnection);
+				this._searchIndex = prepared.searchIndex;
+				this._backendInfo.knn = `cpu-workers(${this._parallel.pool.size})`;
+			} else knn = runCpuKnn();
+		}
+		this._knn = knn;
+		this._timings.knn = performance.now() - t0;
+		this.logger.info(`kNN done in ${this._timings.knn.toFixed(0)}ms (${this._backendInfo.knn})`);
+		throwIfAborted(signal);
+		o.onEpoch?.({
+			epoch: 0,
+			nEpochs: 0,
+			phase: "knn"
+		});
+		const t1 = performance.now();
+		const fss = fuzzySimplicialSet(n, nNeighbors, knn.indices, knn.distances, {
+			setOpMixRatio: o.setOpMixRatio ?? 1,
+			localConnectivity: o.localConnectivity ?? 1,
+			returnDists: densMap || outputDens
+		});
+		let graph = fss.graph;
+		this._sigmas = fss.sigmas;
+		this._rhos = fss.rhos;
+		this._supervised = y != null;
+		if (y != null) {
+			const yArr = normalizeY(y, nFull);
+			const yUnique = this._uniqueIndex ? Float64Array.from(this._uniqueIndex, (i) => yArr[i]) : yArr;
+			if (yUnique.length !== n) throw new UmapValidationError(`y length ${yArr.length} != number of samples ${nFull}`);
+			if ((o.targetMetric ?? "categorical") === "categorical") {
+				const farDist = farDistFromWeight(o.targetWeight ?? .5);
+				graph = categoricalSimplicialSetIntersection(graph, yUnique, { farDist });
+			} else {
+				const targetK = (o.targetNNeighbors ?? -1) === -1 ? nNeighbors : o.targetNNeighbors;
+				const tKnn = exactKnnDense({
+					data: Float32Array.from(yUnique),
+					rows: n,
+					cols: 1
+				}, Math.min(targetK, n - 1), "euclidean");
+				const tFss = fuzzySimplicialSet(n, Math.min(targetK, n - 1), tKnn.indices, tKnn.distances, {
+					setOpMixRatio: 1,
+					localConnectivity: 1,
+					applySetOperations: false
+				});
+				graph = generalSimplicialSetIntersection(graph, tFss.graph, o.targetWeight ?? .5);
+				graph = resetLocalConnectivity(graph);
+			}
+		}
+		this._graph = graph;
+		this._timings.graph = performance.now() - t1;
+		throwIfAborted(signal);
+		await this.embedGraph(graph, fss.dists, dense, nComponents, outputMetric, rng, {
+			densMap,
+			outputDens,
+			...signal ? { signal } : {}
+		});
+		if (this._uniqueInverse && this._embedding) {
+			const inv = this._uniqueInverse;
+			const emb = this._embedding.data;
+			this._embeddingUnique = emb;
+			const full = new Float32Array(nFull * nComponents);
+			for (let i = 0; i < nFull; i++) full.set(emb.subarray(inv[i] * nComponents, (inv[i] + 1) * nComponents), i * nComponents);
+			this._embedding = {
+				data: full,
+				rows: nFull,
+				cols: nComponents
+			};
+			const expand = (arr) => {
+				if (!arr) return null;
+				const out = new Float32Array(nFull);
+				for (let i = 0; i < nFull; i++) out[i] = arr[inv[i]];
+				return out;
+			};
+			this._radOrig = expand(this._radOrig);
+			this._radEmb = expand(this._radEmb);
+		} else this._embeddingUnique = this._embedding?.data ?? null;
+		return this;
+	}
+	async embedGraph(graph, graphDists, dense, nComponents, outputMetric, rng, { densMap, outputDens, signal, initOverride, nEpochsOverride }) {
+		const o = this.options;
+		const n = graph.rows;
+		const defEpochs = defaultNEpochs(n, densMap);
+		const nEpochs = nEpochsOverride ?? o.nEpochs ?? defEpochs;
+		const pruned = pruneGraphForEpochs(graph, nEpochs, defEpochs);
+		const nnz = pruned.indptr[n];
+		const head = new Int32Array(nnz);
+		const tail = new Int32Array(nnz);
+		const weights = new Float32Array(nnz);
+		for (let r = 0; r < n; r++) for (let p = pruned.indptr[r]; p < pruned.indptr[r + 1]; p++) {
+			head[p] = r;
+			tail[p] = pruned.indices[p];
+			weights[p] = Math.fround(pruned.data[p]);
+		}
+		const t2 = performance.now();
+		let emb;
+		if (initOverride) emb = initOverride;
+		else {
+			const initMethod = o.init ?? "spectral";
+			let gpuInit = null;
+			if (initMethod === "spectral" && this._useGpuLayout && this._gpuCtx) {
+				const mod = await import("./webgpu.js");
+				const rngBackup = rng.clone();
+				try {
+					gpuInit = await mod.gpuSpectralInit(this._gpuCtx, pruned, nComponents, rng, this.logger, signal);
+				} catch (e) {
+					if (!(e instanceof UmapBackendError) || (o.backend ?? "auto") === "webgpu") throw e;
+					this.logger.warn(`WebGPU spectral init failed (${e.message}); using the CPU init`);
+					rng.restoreFrom(rngBackup);
+					this.dropGpu();
+				}
+			}
+			emb = gpuInit?.embedding ?? initializeEmbedding(initMethod, dense, pruned, nComponents, rng, { logger: this.logger }).embedding;
+		}
+		this._timings.init = performance.now() - t2;
+		throwIfAborted(signal);
+		o.onEpoch?.({
+			epoch: 0,
+			nEpochs,
+			phase: "init"
+		});
+		const epochsPerSample = makeEpochsPerSample(weights, nEpochs);
+		const rngState = rng.tauState();
+		let densParams = null;
+		if ((densMap || outputDens) && graphDists) {
+			const radii = computeOrigRadii(head, tail, weights, graphDists, n);
+			this._radOrig = radii.ro;
+			if (densMap) densParams = {
+				lambda: o.densLambda ?? 2,
+				frac: o.densFrac ?? .3,
+				varShift: o.densVarShift ?? .1,
+				mu: weights,
+				muSum: radii.muSum,
+				R: radii.R
+			};
+		}
+		const t3 = performance.now();
+		const onEpoch = o.onEpoch;
+		const layoutOpts = {
+			gamma: o.repulsionStrength ?? 1,
+			initialAlpha: o.learningRate ?? 1,
+			negativeSampleRate: o.negativeSampleRate ?? 5,
+			moveOther: true,
+			densmap: densParams,
+			snapshotEvery: onEpoch ? 10 : 0,
+			...onEpoch ? { onEpoch: (info) => onEpoch(info) } : {},
+			...signal ? { signal } : {}
+		};
+		let gpuLayoutDone = false;
+		if (this._useGpuLayout && this._gpuCtx && isEuclideanOutput(outputMetric) && !densParams) {
+			const gpuRng = rng;
+			const rngBackup = rng.clone();
+			try {
+				await this._gpu.gpuOptimizeLayout(this._gpuCtx, emb, nComponents, head, tail, nEpochs, n, epochsPerSample, this._a, this._b, gpuRng, {
+					gamma: o.repulsionStrength ?? 1,
+					initialAlpha: o.learningRate ?? 1,
+					negativeSampleRate: o.negativeSampleRate ?? 5,
+					moveOther: true,
+					...o.gpuLayoutStrategy ? { strategy: o.gpuLayoutStrategy } : {},
+					...onEpoch ? {
+						onEpoch,
+						snapshotEvery: 10
+					} : {},
+					...signal ? { signal } : {}
+				});
+				this._backendInfo.layout = "webgpu";
+				gpuLayoutDone = true;
+			} catch (e) {
+				if (!(e instanceof UmapBackendError) || (o.backend ?? "auto") === "webgpu") throw e;
+				this.logger.warn(`WebGPU layout failed (${e.message}); falling back to CPU layout`);
+				rng.restoreFrom(rngBackup);
+				this.dropGpu();
+			}
+		}
+		if (gpuLayoutDone) {} else if (this._parallel && isEuclideanOutput(outputMetric) && !densParams) {
+			await parallelOptimizeLayout(this._parallel, emb, nComponents, head, tail, nEpochs, n, epochsPerSample, this._a, this._b, rngState, {
+				gamma: layoutOpts.gamma,
+				initialAlpha: layoutOpts.initialAlpha,
+				negativeSampleRate: layoutOpts.negativeSampleRate,
+				moveOther: true,
+				...onEpoch ? { onEpoch: layoutOpts.onEpoch } : {},
+				...signal ? { signal } : {},
+				snapshotEvery: layoutOpts.snapshotEvery
+			});
+			this._backendInfo.layout = `cpu-workers(${this._parallel.pool.size})`;
+		} else if (isEuclideanOutput(outputMetric)) {
+			await yieldToLoop();
+			optimizeLayoutEuclidean(emb, emb, nComponents, head, tail, nEpochs, n, epochsPerSample, this._a, this._b, rngState, layoutOpts);
+		} else {
+			const grad = resolveOutputMetricGrad(outputMetric);
+			await yieldToLoop();
+			optimizeLayoutGeneric(emb, emb, nComponents, head, tail, nEpochs, n, epochsPerSample, this._a, this._b, rngState, grad, layoutOpts);
+		}
+		this._timings.layout = performance.now() - t3;
+		if (!this._backendInfo.layout.startsWith("cpu-workers") && this._backendInfo.layout !== "webgpu") this._backendInfo.layout = "cpu-single";
+		this._embedding = {
+			data: emb,
+			rows: n,
+			cols: nComponents
+		};
+		if (outputDens) {
+			const embMatrix = {
+				data: emb,
+				rows: n,
+				cols: nComponents
+			};
+			const kDens = Math.min(o.nNeighbors ?? 15, n - 1);
+			const res = nearestNeighborsDense(embMatrix, kDens, "euclidean", Pcg32.fromSeed((o.seed ?? 0) + 2654435769), {});
+			const fss2 = fuzzySimplicialSet(n, kDens, res.knn.indices, res.knn.distances, { returnDists: true });
+			this._radEmb = computeEmbRadii(fss2.graph, fss2.dists, n);
+		}
+	}
+	async fitTransform(X, y, opts = {}) {
+		await this.fit(X, y, opts);
+		return this.embedding;
+	}
+	async transform(Xnew, { signal } = {}) {
+		return this.withBusy("transform", async () => {
+			const graphOrEmb = await this.transformInner(Xnew, signal);
+			if (graphOrEmb.kind === "embedding") return graphOrEmb.embedding;
+			throw new UmapError("transformMode is \"graph\"; use transformGraph() for the CSR result");
+		});
+	}
+	/** transformMode 'graph': the bipartite membership CSR (nNew × nTrain). */
+	async transformGraph(Xnew, { signal } = {}) {
+		return this.withBusy("transformGraph", async () => {
+			const res = await this.transformInner(Xnew, signal, true);
+			if (res.kind === "graph") return res.graph;
+			throw new UmapError("internal: expected graph result");
+		});
+	}
+	async transformInner(Xnew, signal, forceGraph = false) {
+		if (!this._embedding) throw new UmapError("model is not fitted");
+		if (this.options.densMap) throw new UmapError("transform is unsupported with densMap");
+		if (this._rawCsr) throw new UmapError("transform on sparse-fitted models is not supported");
+		if (!this._rawData) throw new UmapError("transform requires the training data");
+		const o = this.options;
+		const metric = o.metric ?? "euclidean";
+		const Q = toMatrix(Xnew, "Xnew");
+		if (metric !== "precomputed" && Q.cols !== this._rawData.cols) throw new UmapValidationError(`Xnew has ${Q.cols} features but the model was fitted with ${this._rawData.cols}`);
+		throwIfAborted(signal);
+		const graphMode = forceGraph || o.transformMode === "graph";
+		const qHash = contentHash(new Uint8Array(Q.data.buffer, Q.data.byteOffset, Q.data.byteLength));
+		if (!graphMode && qHash === this._inputHash && sameFloat32Bits(Q.data, this._rawData.data)) return {
+			kind: "embedding",
+			embedding: this.embedding
+		};
+		const k = this._nNeighborsUsed;
+		const nTrainUnique = this._graph.rows;
+		const trainEmb = this._embeddingUnique;
+		const nComponents = this._embedding.cols;
+		const transformSeed = o.transformSeed ?? 42;
+		const rng = Pcg32.fromSeed(transformSeed);
+		if (!this._searchIndex && !this._smallData && this._knn && typeof metric === "string") this._searchIndex = this.buildSearchIndexFromKnn(metric);
+		let qKnn;
+		if (metric === "precomputed") {
+			if (Q.cols !== nTrainUnique) throw new UmapValidationError(`precomputed transform input must be (nNew × ${nTrainUnique})`);
+			qKnn = precomputedQueryKnn(Q, k);
+		} else if (this._smallData || !this._searchIndex) qKnn = smallDataQueryKnn(Q, this.uniqueTrainMatrix(), k, typeof metric === "function" ? metric : resolveMetric(metric, o.metricOptions ?? {}));
+		else {
+			const epsilon = this._searchIndex.angular ? .24 : .12;
+			qKnn = searchKnn(this._searchIndex, Q, k, epsilon);
+		}
+		throwIfAborted(signal);
+		for (let t = 0; t < qKnn.distances.length; t++) if (qKnn.distances[t] >= this._disconnection) {
+			qKnn.indices[t] = -1;
+			qKnn.distances[t] = Infinity;
+		}
+		const adjustedLc = Math.max(0, (o.localConnectivity ?? 1) - 1);
+		const { sigmas, rhos } = smoothKnnDist(qKnn.distances, k, k, { localConnectivity: adjustedLc });
+		const { rows, cols, vals } = computeMembershipStrengths(qKnn.indices, qKnn.distances, sigmas, rhos, k, false, true);
+		let graph = csrFromCoo(Q.rows, nTrainUnique, rows, cols, vals);
+		graph = csrEliminateZeros(graph);
+		if (graphMode) return {
+			kind: "graph",
+			graph
+		};
+		const emb = initGraphTransform(graph, trainEmb, nComponents);
+		let nEpochs;
+		if (o.nEpochs === void 0) nEpochs = Q.rows <= 1e4 ? 100 : 30;
+		else nEpochs = Math.floor(o.nEpochs / 3);
+		let wMax = -Infinity;
+		for (let t = 0; t < graph.data.length; t++) if (graph.data[t] > wMax) wMax = graph.data[t];
+		const thresh = wMax / nEpochs;
+		const gData = graph.data.slice();
+		for (let t = 0; t < gData.length; t++) if (gData[t] < thresh) gData[t] = 0;
+		graph = csrEliminateZeros({
+			...graph,
+			data: gData
+		});
+		const nnz = graph.indptr[Q.rows];
+		const head = new Int32Array(nnz);
+		const tail = new Int32Array(nnz);
+		const weights = new Float32Array(nnz);
+		for (let r = 0; r < Q.rows; r++) for (let p = graph.indptr[r]; p < graph.indptr[r + 1]; p++) {
+			head[p] = r;
+			tail[p] = graph.indices[p];
+			weights[p] = Math.fround(graph.data[p]);
+		}
+		const epochsPerSample = makeEpochsPerSample(weights, nEpochs);
+		const rngState = rng.tauState();
+		const tailEmbedding = trainEmb.slice();
+		const outputMetric = o.outputMetric ?? "euclidean";
+		const layoutOpts = {
+			gamma: o.repulsionStrength ?? 1,
+			initialAlpha: (o.learningRate ?? 1) / 4,
+			negativeSampleRate: o.negativeSampleRate ?? 5,
+			moveOther: false,
+			...signal ? { signal } : {}
+		};
+		await yieldToLoop();
+		if (isEuclideanOutput(outputMetric)) optimizeLayoutEuclidean(emb, tailEmbedding, nComponents, head, tail, nEpochs, nTrainUnique, epochsPerSample, this._a, this._b, rngState, layoutOpts);
+		else optimizeLayoutGeneric(emb, tailEmbedding, nComponents, head, tail, nEpochs, nTrainUnique, epochsPerSample, this._a, this._b, rngState, resolveOutputMetricGrad(outputMetric), layoutOpts);
+		return {
+			kind: "embedding",
+			embedding: {
+				data: emb,
+				rows: Q.rows,
+				cols: nComponents
+			}
+		};
+	}
+	/**
+	* Build the prepared search structure from the stored kNN graph (D-018):
+	* used when the fit produced no index (GPU kNN path, deserialized blobs
+	* without one). Internal-space distances are recomputed exactly via the
+	* internal metric — n·k evaluations, no correction inversion. The rng for
+	* hub-tree tie-breaks/query descent derives from transformSeed on its own
+	* PCG stream, so fit-time determinism (D-013) is untouched and transforms
+	* stay reproducible for a given transformSeed.
+	*/
+	buildSearchIndexFromKnn(metricName) {
+		if (!this._knn || !this._rawData || !isNamedMetric(metricName)) return null;
+		const t0 = performance.now();
+		const X = this.uniqueTrainMatrix();
+		const internal = resolveInternalMetric(metricName, this.options.metricOptions ?? {});
+		const k = this._knn.k;
+		const n = X.rows;
+		const d = X.cols;
+		const indices = this._knn.indices;
+		const distInternal = new Float32Array(n * k);
+		for (let i = 0; i < n; i++) {
+			const xi = X.data.subarray(i * d, (i + 1) * d);
+			for (let j = 0; j < k; j++) {
+				const t = i * k + j;
+				const nb = indices[t];
+				distInternal[t] = nb < 0 ? Infinity : internal.dist(xi, X.data.subarray(nb * d, (nb + 1) * d));
+			}
+		}
+		const knnInternal = {
+			indices,
+			distances: distInternal,
+			k
+		};
+		const searchRngState = Pcg32.fromSeed(this.options.transformSeed ?? 42, 63).tauState();
+		const searchIndex = prepareSearchIndex(X, knnInternal, (a, b) => internal.dist(a, b), internal.correction, internal.angularTrees || (this.options.angularRpForest ?? false), this._nNeighborsUsed, searchRngState);
+		this.logger.info(`built the transform search index lazily in ${(performance.now() - t0).toFixed(0)}ms`);
+		return searchIndex;
+	}
+	uniqueTrainMatrix() {
+		if (!this._uniqueIndex || !this._rawData) return this._rawData;
+		const d = this._rawData.cols;
+		const data = new Float32Array(this._uniqueIndex.length * d);
+		for (let i = 0; i < this._uniqueIndex.length; i++) data.set(this._rawData.data.subarray(this._uniqueIndex[i] * d, (this._uniqueIndex[i] + 1) * d), i * d);
+		return {
+			data,
+			rows: this._uniqueIndex.length,
+			cols: d
+		};
+	}
+	async inverseTransform(points, { signal } = {}) {
+		return this.withBusy("inverseTransform", () => this.inverseTransformInner(points, signal));
+	}
+	async inverseTransformInner(points, signal) {
+		throwIfAborted(signal);
+		if (!this._embedding) throw new UmapError("model is not fitted");
+		if (this._rawCsr) throw new UmapValidationError("inverseTransform is unsupported for sparse-fitted models");
+		if (this.options.densMap) throw new UmapValidationError("inverseTransform is unsupported with densMap");
+		if (!isEuclideanOutput(this.options.outputMetric ?? "euclidean")) throw new UmapValidationError("inverseTransform requires euclidean output");
+		const metric = this.options.metric ?? "euclidean";
+		if (typeof metric !== "function" && !["euclidean", "l2"].includes(metric)) throw new UmapValidationError(`inverseTransform supports euclidean data metric in this port, got '${metric}'`);
+		const P = toMatrix(points, "points");
+		const trainEmb = this._embeddingUnique;
+		const raw = this.uniqueTrainMatrix();
+		const nTrain = raw.rows;
+		const dim = this._embedding.cols;
+		const dataDim = raw.cols;
+		if (P.cols !== dim) throw new UmapValidationError(`points must be (n × ${dim})`);
+		const rng = Pcg32.fromSeed(this.options.transformSeed ?? 42);
+		const minVertices = Math.min(dataDim, nTrain);
+		const nn = smallDataQueryKnn(P, {
+			data: trainEmb,
+			rows: nTrain,
+			cols: dim
+		}, minVertices, resolveMetric("euclidean"));
+		throwIfAborted(signal);
+		const weights = new Float32Array(P.rows * minVertices);
+		for (let i = 0; i < P.rows; i++) {
+			let rowSum = 0;
+			for (let j = 0; j < minVertices; j++) {
+				const d = nn.distances[i * minVertices + j];
+				const w = 1 / (1 + this._a * d ** (2 * this._b));
+				weights[i * minVertices + j] = w;
+				rowSum += w;
+			}
+			for (let j = 0; j < minVertices; j++) weights[i * minVertices + j] = weights[i * minVertices + j] / rowSum;
+		}
+		const inv = initTransform(nn.indices, weights, minVertices, raw.data, dataDim);
+		let nEpochs;
+		if (this.options.nEpochs === void 0) nEpochs = P.rows <= 1e4 ? 100 : 30;
+		else nEpochs = Math.floor(this.options.nEpochs / 3);
+		const kernelW = new Float32Array(P.rows * minVertices);
+		for (let i = 0; i < P.rows; i++) for (let j = 0; j < minVertices; j++) {
+			const d = nn.distances[i * minVertices + j];
+			kernelW[i * minVertices + j] = Math.fround(1 / (1 + this._a * d ** (2 * this._b)));
+		}
+		const head = new Int32Array(P.rows * minVertices);
+		const tail = new Int32Array(P.rows * minVertices);
+		for (let i = 0; i < P.rows; i++) for (let j = 0; j < minVertices; j++) {
+			head[i * minVertices + j] = i;
+			tail[i * minVertices + j] = nn.indices[i * minVertices + j];
+		}
+		const epochsPerSample = makeEpochsPerSample(kernelW, nEpochs);
+		const rngState = rng.tauState();
+		await yieldToLoop();
+		optimizeLayoutInverse(inv, raw.data, dataDim, head, tail, kernelW, this._sigmas, this._rhos, nEpochs, nTrain, epochsPerSample, rngState, resolveOutputMetricGrad("euclidean"), {
+			gamma: this.options.repulsionStrength ?? 1,
+			initialAlpha: (this.options.learningRate ?? 1) / 4,
+			negativeSampleRate: this.options.negativeSampleRate ?? 5,
+			...signal ? { signal } : {}
+		});
+		return {
+			data: inv,
+			rows: P.rows,
+			cols: dataDim
+		};
+	}
+	async update(Xmore, { signal } = {}) {
+		return this.withBusy("update", async () => {
+			const snapshot = this.snapshotFittedState();
+			try {
+				return await this.updateInner(Xmore, signal);
+			} catch (e) {
+				this.restoreFittedState(snapshot);
+				throw e;
+			}
+		});
+	}
+	async updateInner(Xmore, signal) {
+		throwIfAborted(signal);
+		if (!this._embedding) throw new UmapError("model is not fitted");
+		if (this.options.metric === "precomputed") throw new UmapValidationError("update is unsupported with a precomputed metric");
+		if (this._supervised) throw new UmapValidationError("update is unsupported for supervised models");
+		if (this._uniqueIndex) throw new UmapError("update after unique=true is unsupported");
+		if (this._rawCsr) throw new UmapError("update on sparse-fitted models is unsupported");
+		const o = this.options;
+		const Xn = toMatrix(Xmore, "Xmore");
+		if (Xn.cols !== this._rawData.cols) throw new UmapValidationError("Xmore feature count differs from training data");
+		const originalSize = this._rawData.rows;
+		const merged = new Float32Array((originalSize + Xn.rows) * Xn.cols);
+		merged.set(this._rawData.data, 0);
+		merged.set(Xn.data, originalSize * Xn.cols);
+		const X = {
+			data: merged,
+			rows: originalSize + Xn.rows,
+			cols: Xn.cols
+		};
+		this._rawData = X;
+		const n = X.rows;
+		const rng = Pcg32.fromSeed(this.options.transformSeed ?? 42);
+		const metric = o.metric ?? "euclidean";
+		const nNeighbors = this._nNeighborsUsed;
+		const res = nearestNeighborsDense(X, nNeighbors, metric, rng, {
+			metricOptions: o.metricOptions ?? {},
+			forceApproximation: (o.forceApproximation ?? false) || !this._smallData,
+			angularRpForest: o.angularRpForest ?? false,
+			disconnectionDistance: this._disconnection
+		});
+		this._smallData = res.method === "exact";
+		this._searchIndex = res.searchIndex;
+		this._knn = res.knn;
+		const fss = fuzzySimplicialSet(n, nNeighbors, res.knn.indices, res.knn.distances, {
+			setOpMixRatio: o.setOpMixRatio ?? 1,
+			localConnectivity: o.localConnectivity ?? 1,
+			returnDists: (o.densMap ?? false) || (o.outputDens ?? false)
+		});
+		this._graph = fss.graph;
+		this._sigmas = fss.sigmas;
+		this._rhos = fss.rhos;
+		const nComponents = this._embedding.cols;
+		const init = new Float32Array(n * nComponents);
+		init.set(this._embedding.data, 0);
+		initUpdate(init, nComponents, originalSize, res.knn.indices, nNeighbors);
+		const nEpochs = o.nEpochs === void 0 ? 0 : o.nEpochs;
+		await this.embedGraph(fss.graph, fss.dists, X, nComponents, o.outputMetric ?? "euclidean", rng, {
+			densMap: o.densMap ?? false,
+			outputDens: o.outputDens ?? false,
+			initOverride: init,
+			nEpochsOverride: nEpochs,
+			...signal ? { signal } : {}
+		});
+		this._embeddingUnique = this._embedding.data;
+		this._inputHash = contentHash(new Uint8Array(X.data.buffer, X.data.byteOffset, X.data.byteLength));
+		return this;
+	}
+	serialize() {
+		return serializeModel(this);
+	}
+	static deserialize(blob) {
+		return deserializeModel(blob, UMAP);
+	}
+};
+function normalizeY(y, n) {
+	const arr = new Float64Array(n);
+	const src = y;
+	if (src.length !== n) throw new UmapValidationError(`y length ${src.length} != number of samples ${n}`);
+	for (let i = 0; i < n; i++) {
+		const v = src[i];
+		if (!Number.isFinite(v)) throw new UmapValidationError("y contains a non-finite value");
+		arr[i] = v;
+	}
+	return arr;
+}
+function uniqueRows(X) {
+	const seen = /* @__PURE__ */ new Map();
+	const index = [];
+	const inverse = new Int32Array(X.rows);
+	for (let i = 0; i < X.rows; i++) {
+		const key = Array.prototype.join.call(X.data.subarray(i * X.cols, (i + 1) * X.cols), ",");
+		let u = seen.get(key);
+		if (u === void 0) {
+			u = index.length;
+			seen.set(key, u);
+			index.push(i);
+		}
+		inverse[i] = u;
+	}
+	return {
+		index: Int32Array.from(index),
+		inverse
+	};
+}
+function sliceKnn(pk, n, k) {
+	if (pk.indices.length !== n * pk.k || pk.distances.length !== n * pk.k) throw new UmapValidationError(`precomputedKnn arrays must have n*k = ${n * pk.k} entries (indices: ${pk.indices.length}, distances: ${pk.distances.length})`);
+	if (pk.k === k) return {
+		indices: pk.indices,
+		distances: pk.distances,
+		k
+	};
+	const indices = new Int32Array(n * k);
+	const distances = new Float32Array(n * k);
+	for (let i = 0; i < n; i++) {
+		indices.set(pk.indices.subarray(i * pk.k, i * pk.k + k), i * k);
+		distances.set(pk.distances.subarray(i * pk.k, i * pk.k + k), i * k);
+	}
+	return {
+		indices,
+		distances,
+		k
+	};
+}
+function applyDisconnectionToKnn(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;
+	}
+}
+function applyDisconnectionToMatrix(X, dc) {
+	if (dc === Infinity) return X;
+	const data = X.data.slice();
+	for (let i = 0; i < data.length; i++) if (data[i] >= dc) data[i] = Infinity;
+	return {
+		data,
+		rows: X.rows,
+		cols: X.cols
+	};
+}
+/** Query kNN of Q against T by brute force (transform small-data path). */
+function smallDataQueryKnn(Q, T, k, metric) {
+	const nq = Q.rows;
+	const nt = T.rows;
+	const d = Q.cols;
+	const indices = new Int32Array(nq * k);
+	const distances = new Float32Array(nq * k);
+	const row = new Float64Array(nt);
+	const heapIdx = new Int32Array(k);
+	const heapDst = new Float64Array(k);
+	for (let i = 0; i < nq; i++) {
+		const qi = Q.data.subarray(i * d, (i + 1) * d);
+		for (let j = 0; j < nt; j++) row[j] = metric(qi, T.data.subarray(j * d, (j + 1) * d));
+		selectK(row, nt, k, heapIdx, heapDst);
+		for (let j = 0; j < k; j++) {
+			indices[i * k + j] = heapIdx[j];
+			distances[i * k + j] = heapDst[j];
+		}
+	}
+	return {
+		indices,
+		distances,
+		k
+	};
+}
+function selectK(rowDist, n, k, outIdx, outDst) {
+	const gt = (d1, i1, d2, i2) => d1 > d2 || d1 === d2 && i1 > i2;
+	let count = 0;
+	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])) {
+					const td = outDst[c];
+					outDst[c] = outDst[parent];
+					outDst[parent] = td;
+					const ti = outIdx[c];
+					outIdx[c] = outIdx[parent];
+					outIdx[parent] = ti;
+					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;
+				const td = outDst[c];
+				outDst[c] = outDst[m];
+				outDst[m] = td;
+				const ti = outIdx[c];
+				outIdx[c] = outIdx[m];
+				outIdx[m] = ti;
+				c = m;
+			}
+		}
+	}
+	for (let j = count; j < k; j++) {
+		outDst[j] = Infinity;
+		outIdx[j] = -1;
+	}
+	const idxArr = Array.from({ length: k }, (_, j) => j).sort((a, b) => outDst[a] - outDst[b] || outIdx[a] - outIdx[b]);
+	const tmpD = Float64Array.from(idxArr, (j) => outDst[j]);
+	const tmpI = Int32Array.from(idxArr, (j) => outIdx[j]);
+	outDst.set(tmpD);
+	outIdx.set(tmpI);
+}
+/** transform with metric='precomputed': rows are distances to train points. */
+function precomputedQueryKnn(Q, k) {
+	const indices = new Int32Array(Q.rows * k);
+	const distances = new Float32Array(Q.rows * k);
+	const row = new Float64Array(Q.cols);
+	const heapIdx = new Int32Array(k);
+	const heapDst = new Float64Array(k);
+	for (let i = 0; i < Q.rows; i++) {
+		for (let j = 0; j < Q.cols; j++) row[j] = Q.data[i * Q.cols + j];
+		selectK(row, Q.cols, k, heapIdx, heapDst);
+		for (let j = 0; j < k; j++) {
+			indices[i * k + j] = heapIdx[j];
+			distances[i * k + j] = heapDst[j];
+		}
+	}
+	return {
+		indices,
+		distances,
+		k
+	};
+}
+
+//#endregion
+//#region src/estimator/aligned.ts
+function relGet(rel, k) {
+	return rel instanceof Map ? rel.get(k) : rel[k];
+}
+/** expand_relations (aligned_umap.py:43-82). */
+function expandRelations(relations, windowSize, sliceSizes) {
+	const nSlices = relations.length + 1;
+	const maxN = Math.max(...sliceSizes);
+	const W = 2 * windowSize + 1;
+	const out = [];
+	for (let i = 0; i < nSlices; i++) {
+		const arr = new Int32Array(W * maxN).fill(-1);
+		for (let off = -windowSize; off <= windowSize; off++) {
+			const t = i + off;
+			if (t < 0 || t >= nSlices || off === 0) {
+				if (off === 0) for (let v = 0; v < sliceSizes[i]; v++) arr[(windowSize + 0) * maxN + v] = v;
+				continue;
+			}
+			for (let v = 0; v < sliceSizes[i]; v++) {
+				let cur = v;
+				let ok = true;
+				if (off > 0) for (let s = i; s < i + off; s++) {
+					const nxt = relGet(relations[s], cur);
+					if (nxt === void 0) {
+						ok = false;
+						break;
+					}
+					cur = nxt;
+				}
+				else for (let s = i - 1; s >= i + off; s--) {
+					const rel = relations[s];
+					let found = -1;
+					if (rel instanceof Map) {
+						for (const [k2, v2] of rel) if (v2 === cur) {
+							found = k2;
+							break;
+						}
+					} else for (const k2 of Object.keys(rel)) if (rel[k2] === cur) {
+						found = Number(k2);
+						break;
+					}
+					if (found < 0) {
+						ok = false;
+						break;
+					}
+					cur = found;
+				}
+				if (ok) arr[(windowSize + off) * maxN + v] = cur;
+			}
+		}
+		out.push(arr);
+	}
+	return out;
+}
+/** build_neighborhood_similarities (aligned_umap.py:85-129): Jaccard of mapped kNN sets. */
+function buildNeighborhoodSimilarities(graphs, relations, windowSize, maxN) {
+	const nSlices = graphs.length;
+	const W = 2 * windowSize + 1;
+	const out = [];
+	for (let i = 0; i < nSlices; i++) {
+		const weights = new Float32Array(W * maxN);
+		for (let off = -windowSize; off <= windowSize; off++) {
+			const t = i + off;
+			if (t < 0 || t >= nSlices || off === 0) continue;
+			const rel = relations[i];
+			const image = /* @__PURE__ */ new Set();
+			for (let v = 0; v < maxN; v++) {
+				const m = rel[(windowSize + off) * maxN + v];
+				if (m >= 0) image.add(m);
+			}
+			for (let v = 0; v < graphs[i].rows; v++) {
+				const counterpart = rel[(windowSize + off) * maxN + v];
+				if (counterpart < 0) continue;
+				const mapped = /* @__PURE__ */ new Set();
+				for (let p = graphs[i].indptr[v]; p < graphs[i].indptr[v + 1]; p++) {
+					const nb = graphs[i].indices[p];
+					if (nb >= maxN) continue;
+					const m = rel[(windowSize + off) * maxN + nb];
+					if (m >= 0) mapped.add(m);
+				}
+				const other = /* @__PURE__ */ new Set();
+				for (let p = graphs[t].indptr[counterpart]; p < graphs[t].indptr[counterpart + 1]; p++) {
+					const nb = graphs[t].indices[p];
+					if (image.has(nb)) other.add(nb);
+				}
+				let inter = 0;
+				for (const m of mapped) if (other.has(m)) inter++;
+				const union = mapped.size + other.size - inter;
+				weights[(windowSize + off) * maxN + v] = union === 0 ? 1 : inter / union;
+			}
+		}
+		out.push(weights);
+	}
+	return out;
+}
+/** procrustes_align (aligned_umap.py:33-40): rotation-only via SVD of subset2ᵀ·subset1. */
+function procrustesRotate(embedding, dim, anchorsSelf, anchorsPrev, prev) {
+	const d = dim;
+	const M = new Float64Array(d * d);
+	for (let t = 0; t < anchorsSelf.length; t++) {
+		const a = anchorsSelf[t];
+		const b = anchorsPrev[t];
+		for (let r = 0; r < d; r++) for (let c = 0; c < d; c++) M[r * d + c] = M[r * d + c] + embedding[a * d + r] * prev[b * d + c];
+	}
+	const MtM = new Float64Array(d * d);
+	for (let r = 0; r < d; r++) for (let c = 0; c < d; c++) {
+		let s = 0;
+		for (let k2 = 0; k2 < d; k2++) s += M[k2 * d + r] * M[k2 * d + c];
+		MtM[r * d + c] = s;
+	}
+	const eig = symmetricEigen(MtM, d);
+	const U = new Float64Array(d * d);
+	const V = new Float64Array(d * d);
+	for (let c = 0; c < d; c++) {
+		const col = d - 1 - c;
+		const sigma = Math.sqrt(Math.max(eig.values[col], 1e-30));
+		for (let r = 0; r < d; r++) V[r * d + c] = eig.vectors[col * d + r];
+		for (let r = 0; r < d; r++) {
+			let s = 0;
+			for (let k2 = 0; k2 < d; k2++) s += M[r * d + k2] * V[k2 * d + c];
+			U[r * d + c] = s / sigma;
+		}
+	}
+	const R = new Float64Array(d * d);
+	for (let r = 0; r < d; r++) for (let c = 0; c < d; c++) {
+		let s = 0;
+		for (let k2 = 0; k2 < d; k2++) s += U[r * d + k2] * V[c * d + k2];
+		R[r * d + c] = s;
+	}
+	const n = embedding.length / d;
+	const tmp = new Float64Array(d);
+	for (let i = 0; i < n; i++) {
+		for (let c = 0; c < d; c++) {
+			let s = 0;
+			for (let k2 = 0; k2 < d; k2++) s += embedding[i * d + k2] * R[k2 * d + c];
+			tmp[c] = s;
+		}
+		for (let c = 0; c < d; c++) embedding[i * d + c] = tmp[c];
+	}
+}
+var AlignedUMAP = class {
+	options;
+	_embeddings = null;
+	_mappers = [];
+	_relations = [];
+	constructor(options = {}) {
+		this.options = { ...options };
+	}
+	get embeddings() {
+		if (!this._embeddings) throw new UmapError("model is not fitted");
+		return this._embeddings;
+	}
+	async fit(XList, yList, relations, { signal } = {}) {
+		throwIfAborted(signal);
+		if (!relations || relations.length !== XList.length - 1) throw new UmapValidationError("relations must have length len(X) - 1");
+		this._relations = relations;
+		const o = this.options;
+		const windowSize = o.alignmentWindowSize ?? 3;
+		const lambda = o.alignmentRegularisation ?? .01;
+		const nComponents = o.nComponents ?? 2;
+		const nEpochs = o.nEpochs ?? 200;
+		const slices = XList.map((X, i) => toMatrix(X, `X[${i}]`));
+		const sliceSizes = slices.map((s) => s.rows);
+		const maxN = Math.max(...sliceSizes);
+		this._mappers = [];
+		for (let i = 0; i < slices.length; i++) {
+			const { alignmentRegularisation: _ar, alignmentWindowSize: _aw, nEpochs: _ne,...umapOpts } = o;
+			const mapper = new UMAP({
+				...umapOpts,
+				nComponents
+			});
+			await mapper.fit(slices[i], yList?.[i] ?? null, signal ? { signal } : {});
+			this._mappers.push(mapper);
+		}
+		const graphs = this._mappers.map((m) => m.graph);
+		throwIfAborted(signal);
+		const expanded = expandRelations(relations, windowSize, sliceSizes);
+		const regWeights = buildNeighborhoodSimilarities(graphs, expanded, windowSize, maxN);
+		const heads = [];
+		const tails = [];
+		const epochsPerSamples = [];
+		for (const g of graphs) {
+			const nnz = g.indptr[g.rows];
+			const h = new Int32Array(nnz);
+			const t = new Int32Array(nnz);
+			const w = new Float32Array(nnz);
+			for (let r = 0; r < g.rows; r++) for (let p = g.indptr[r]; p < g.indptr[r + 1]; p++) {
+				h[p] = r;
+				t[p] = g.indices[p];
+				w[p] = Math.fround(g.data[p]);
+			}
+			heads.push(h);
+			tails.push(t);
+			epochsPerSamples.push(makeEpochsPerSample(w, nEpochs));
+		}
+		const seed = o.seed ?? 42;
+		const rng = Pcg32.fromSeed(seed);
+		const embeddings = [];
+		for (let i = 0; i < slices.length; i++) {
+			const res = spectralLayout(slices[i], graphs[i], nComponents, rng);
+			let mx = 0;
+			for (const v of res.embedding) mx = Math.max(mx, Math.abs(v));
+			const expansion = mx > 0 ? 10 / mx : 1;
+			const emb = new Float32Array(res.embedding.length);
+			for (let t = 0; t < emb.length; t++) emb[t] = Math.fround(res.embedding[t] * expansion);
+			if (i > 0) {
+				const anchorsPrev = [];
+				const anchorsSelf = [];
+				const rel = relations[i - 1];
+				const entries = rel instanceof Map ? rel.entries() : Object.entries(rel);
+				for (const [kRaw, v] of entries) {
+					anchorsPrev.push(Number(kRaw));
+					anchorsSelf.push(v);
+				}
+				procrustesRotate(emb, nComponents, Int32Array.from(anchorsSelf), Int32Array.from(anchorsPrev), embeddings[i - 1]);
+			}
+			embeddings.push(emb);
+		}
+		optimizeLayoutAlignedEuclidean(embeddings, nComponents, heads, tails, nEpochs, epochsPerSamples, regWeights, expanded, windowSize, maxN, Pcg32.fromSeed(o.transformSeed ?? 42).tauState(), {
+			lambda,
+			a: 1.576943460405378,
+			b: .8950608781227859,
+			gamma: o.repulsionStrength ?? 1,
+			initialAlpha: o.learningRate ?? 1,
+			negativeSampleRate: o.negativeSampleRate ?? 5,
+			moveOther: true,
+			...signal ? { signal } : {}
+		});
+		this._embeddings = embeddings.map((e, i) => ({
+			data: e,
+			rows: sliceSizes[i],
+			cols: nComponents
+		}));
+		return this;
+	}
+	async fitTransform(XList, yList, relations, opts = {}) {
+		await this.fit(XList, yList, relations, opts);
+		return this.embeddings;
+	}
+	/** Append a new slice (aligned_umap.py:446-562): old slices frozen except pulls. */
+	async update(Xnew, relation, { signal } = {}) {
+		throwIfAborted(signal);
+		if (!this._embeddings) throw new UmapError("model is not fitted");
+		const o = this.options;
+		const windowSize = o.alignmentWindowSize ?? 3;
+		const lambda = o.alignmentRegularisation ?? .01;
+		const nComponents = o.nComponents ?? 2;
+		const nEpochs = o.nEpochs ?? 200;
+		const X = toMatrix(Xnew, "Xnew");
+		const { alignmentRegularisation: _ar, alignmentWindowSize: _aw, nEpochs: _ne,...umapOpts } = o;
+		const mapper = new UMAP({
+			...umapOpts,
+			nComponents
+		});
+		await mapper.fit(X, null, signal ? { signal } : {});
+		this._mappers.push(mapper);
+		this._relations.push(relation);
+		const graphs = this._mappers.map((m) => m.graph);
+		const sliceSizes = graphs.map((g) => g.rows);
+		const maxN = Math.max(...sliceSizes);
+		const expanded = expandRelations(this._relations, windowSize, sliceSizes);
+		const regWeights = buildNeighborhoodSimilarities(graphs, expanded, windowSize, maxN);
+		const heads = [];
+		const tails = [];
+		const epochsPerSamples = [];
+		for (let i = 0; i < graphs.length; i++) {
+			const g = graphs[i];
+			if (i < graphs.length - 1) {
+				heads.push(new Int32Array(0));
+				tails.push(new Int32Array(0));
+				epochsPerSamples.push(new Float64Array(0));
+				continue;
+			}
+			const nnz = g.indptr[g.rows];
+			const h = new Int32Array(nnz);
+			const t = new Int32Array(nnz);
+			const w = new Float32Array(nnz);
+			for (let r = 0; r < g.rows; r++) for (let p = g.indptr[r]; p < g.indptr[r + 1]; p++) {
+				h[p] = r;
+				t[p] = g.indices[p];
+				w[p] = Math.fround(g.data[p]);
+			}
+			heads.push(h);
+			tails.push(t);
+			epochsPerSamples.push(makeEpochsPerSample(w, nEpochs));
+		}
+		const prev = this._embeddings[this._embeddings.length - 1];
+		const rng = Pcg32.fromSeed(o.transformSeed ?? 42);
+		const emb = new Float32Array(X.rows * nComponents);
+		for (let v = 0; v < X.rows; v++) {
+			let src = -1;
+			const entries = relation instanceof Map ? relation.entries() : Object.entries(relation);
+			for (const [kRaw, val] of entries) if (val === v) {
+				src = Number(kRaw);
+				break;
+			}
+			if (src >= 0) for (let c = 0; c < nComponents; c++) emb[v * nComponents + c] = prev.data[src * nComponents + c];
+			else for (let c = 0; c < nComponents; c++) emb[v * nComponents + c] = rng.uniform(-10, 10);
+		}
+		const embeddings = [...this._embeddings.map((e) => e.data), emb];
+		optimizeLayoutAlignedEuclidean(embeddings, nComponents, heads, tails, nEpochs, epochsPerSamples, regWeights, expanded, windowSize, maxN, rng.tauState(), {
+			lambda,
+			a: 1.576943460405378,
+			b: .8950608781227859,
+			gamma: o.repulsionStrength ?? 1,
+			initialAlpha: o.learningRate ?? 1,
+			negativeSampleRate: o.negativeSampleRate ?? 5,
+			moveOther: false,
+			...signal ? { signal } : {}
+		});
+		this._embeddings = embeddings.map((e, i) => ({
+			data: e,
+			rows: sliceSizes[i],
+			cols: nComponents
+		}));
+		return this;
+	}
+};
+/** optimize_layout_aligned_euclidean (layouts.py:877-1104; notes §19.4). */
+function optimizeLayoutAlignedEuclidean(embeddings, dim, heads, tails, nEpochs, epochsPerSamples, regWeights, relations, windowSize, maxN, rngState, P) {
+	const nEmbeddings = embeddings.length;
+	const { a, b, gamma, lambda, negativeSampleRate, moveOther } = P;
+	let alpha = P.initialAlpha;
+	const epochsPerNegative = epochsPerSamples.map((eps) => {
+		const out = new Float64Array(eps.length);
+		for (let i = 0; i < eps.length; i++) out[i] = eps[i] / negativeSampleRate;
+		return out;
+	});
+	const epochOfNext = epochsPerSamples.map((eps) => eps.slice());
+	const epochOfNextNeg = epochsPerNegative.map((e) => e.slice());
+	const maxNEdges = Math.max(...epochsPerSamples.map((e) => e.length));
+	const order = new Int32Array(nEmbeddings);
+	const applyRegularisation = (m, vertex, d, coord) => {
+		let g = 0;
+		for (let offset = -windowSize; offset < windowSize; offset++) {
+			const nm = m + offset;
+			if (offset === 0 || nm < 0 || nm >= nEmbeddings) continue;
+			const identified = relations[m][(windowSize + offset) * maxN + vertex];
+			if (identified < 0) continue;
+			g -= clip(lambda * Math.exp(-(Math.abs(offset) - 1)) * regWeights[m][(windowSize + offset) * maxN + vertex] * (coord - embeddings[nm][identified * dim + d]));
+		}
+		return g;
+	};
+	for (let n = 0; n < nEpochs; n++) {
+		throwIfAborted(P.signal);
+		for (let i2 = 0; i2 < nEmbeddings; i2++) order[i2] = i2;
+		Pcg32.fromSeed(Math.abs(rngState[0])).shuffle(order);
+		for (let i = 0; i < maxNEdges; i++) for (const m of order) {
+			const eons = epochOfNext[m];
+			if (i >= eons.length || eons[i] > n) continue;
+			const emb = embeddings[m];
+			const j = heads[m][i];
+			let k = tails[m][i];
+			const jb = j * dim;
+			let kb = k * dim;
+			let d2 = 0;
+			for (let d = 0; d < dim; d++) {
+				const diff = emb[jb + d] - emb[kb + d];
+				d2 += diff * diff;
+			}
+			let gradCoeff = 0;
+			if (d2 > 0) gradCoeff = -2 * a * b * d2 ** (b - 1) / (a * d2 ** b + 1);
+			for (let d = 0; d < dim; d++) {
+				let gradD = clip(gradCoeff * (emb[jb + d] - emb[kb + d]));
+				gradD += applyRegularisation(m, j, d, emb[jb + d]);
+				emb[jb + d] = emb[jb + d] + clip(gradD) * alpha;
+				if (moveOther) {
+					let otherGrad = clip(gradCoeff * (emb[kb + d] - emb[jb + d]));
+					otherGrad += applyRegularisation(m, k, d, emb[kb + d]);
+					emb[kb + d] = emb[kb + d] + clip(otherGrad) * alpha;
+				}
+			}
+			eons[i] = eons[i] + epochsPerSamples[m][i];
+			const epn = epochsPerNegative[m][i];
+			let nNeg = 0;
+			if (epn > 0) nNeg = Math.trunc((n - epochOfNextNeg[m][i]) / epn);
+			const nVertices = emb.length / dim;
+			for (let p = 0; p < nNeg; p++) {
+				const r = tauRandInt(rngState);
+				k = r % nVertices + (r % nVertices < 0 ? nVertices : 0);
+				kb = k * dim;
+				let dn = 0;
+				for (let d = 0; d < dim; d++) {
+					const diff = emb[jb + d] - emb[kb + d];
+					dn += diff * diff;
+				}
+				let repCoeff = 0;
+				if (dn > 0) repCoeff = 2 * gamma * b / ((.001 + dn) * (a * dn ** b + 1));
+				else if (j === k) continue;
+				for (let d = 0; d < dim; d++) {
+					let gradD = 0;
+					if (repCoeff > 0) gradD = clip(repCoeff * (emb[jb + d] - emb[kb + d]));
+					gradD += applyRegularisation(m, j, d, emb[jb + d]);
+					emb[jb + d] = emb[jb + d] + clip(gradD) * alpha;
+				}
+			}
+			epochOfNextNeg[m][i] = epochOfNextNeg[m][i] + nNeg * epn;
+		}
+		alpha = P.initialAlpha * (1 - n / nEpochs);
+	}
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* umap-web — standalone TypeScript UMAP for browsers and Node.js.
+*
+* Public entry point. See `umap-web/core` for the low-level functional API.
+*/
+const VERSION = "0.1.0";
+
+//#endregion
+export { ANGULAR_METRICS, AlignedUMAP, DISCONNECTION_DISTANCES, MIN_K_DIST_SCALE, NAMED_METRICS, Pcg32, SMALL_DATA_CUTOFF, SMOOTH_K_TOLERANCE, UMAP, UmapBackendError, UmapConvergenceWarning, UmapError, UmapValidationError, VERSION, canonicalMetricName, computeMembershipStrengths, connectedComponents, csrBinaryOp, csrCopy, csrEliminateZeros, csrForEach, csrFromCoo, csrMapValues, csrMaxAbsDiff, csrNnz, csrRowNormalizeMax, csrTranspose, defaultNEpochs, degreeInvSqrt, exactKnnDense, exactKnnSparse, finalInitRescale, findABParams, floorMod, fuzzySimplicialSet, initializeEmbedding, isNamedMetric, knnFromPrecomputed, lobpcgSmallest, makeEpochsPerSample, metrics_exports as metrics, mgsOrthonormalize, nearestNeighborsDense, nearestNeighborsSparse, nnDescent, noisyScaleCoords, pcaScores, pruneGraphForEpochs, resolveMetric, searchKnn, smoothKnnDist, spectralLayout, symmetricEigen, tauRand, tauRandInt, toMatrix, umapNnDescentParams };
+//# sourceMappingURL=index.js.map