umap-web 0.2.0

package/dist/core-IHdw-3yY.d.ts

@@ -0,0 +1,373 @@
+import { S as Matrix, _ as DenseInput, f as Pcg32, g as CSRInput, t as Csr, v as Embedding, x as Logger, y as KnnGraph } from "./sparse-BxSeVhO4.js";
+
+//#region src/graph/ab.d.ts
+
+/**
+ * find_ab_params (umap_.py:1393-1408): least-squares fit of
+ * curve(x) = 1 / (1 + a·x^(2b)) to the fuzzy-membership target built from
+ * (spread, minDist), via Levenberg–Marquardt from p0 = (1, 1) — mirroring
+ * scipy.optimize.curve_fit's default solver on the same 300-point grid.
+ */
+interface ABParams {
+  a: number;
+  b: number;
+}
+declare function findABParams(spread: number, minDist: number): ABParams;
+//#endregion
+//#region src/graph/epochs.d.ts
+declare function makeEpochsPerSample(weights: Float64Array | Float32Array, nEpochs: number): Float64Array;
+/** Default epoch rule: 500 for n<=10000 else 200; +200 when densMAP (notes §6.2). */
+declare function defaultNEpochs(nVertices: number, densmap: boolean): number;
+/**
+ * Prune graph weights below max/n_epochs (in place on a copy) exactly like
+ * simplicial_set_embedding, returning the pruned graph.
+ */
+declare function pruneGraphForEpochs(graph: Csr, nEpochsMax: number, defaultEpochs: number): Csr;
+//#endregion
+//#region src/graph/fuzzy.d.ts
+interface MembershipStrengths {
+  rows: Int32Array;
+  cols: Int32Array;
+  vals: Float32Array;
+  dists: Float32Array | null;
+}
+declare function computeMembershipStrengths(knnIndices: Int32Array, knnDists: Float32Array, sigmas: Float32Array, rhos: Float32Array, nNeighbors: number, returnDists?: boolean, bipartite?: boolean): MembershipStrengths;
+interface FuzzySimplicialSetResult {
+  graph: Csr;
+  sigmas: Float32Array;
+  rhos: Float32Array;
+  /** symmetrized (max) distances, only when returnDists */
+  dists: Csr | null;
+}
+interface FuzzySimplicialSetOptions {
+  setOpMixRatio?: number;
+  localConnectivity?: number;
+  applySetOperations?: boolean;
+  returnDists?: boolean;
+  bipartite?: boolean;
+}
+/**
+ * Build the fuzzy simplicial set from a kNN graph (knn indices+distances required;
+ * the estimator computes them per §5.2 backends).
+ */
+declare function fuzzySimplicialSet(nSamples: number, nNeighbors: number, knnIndices: Int32Array, knnDists: Float32Array, {
+  setOpMixRatio,
+  localConnectivity,
+  applySetOperations,
+  returnDists
+}?: FuzzySimplicialSetOptions): FuzzySimplicialSetResult;
+//#endregion
+//#region src/graph/smooth.d.ts
+/**
+ * smooth_knn_dist — sigma/rho computation (umap_.py:143-253; notes §1).
+ *
+ * Python runs this in float32 fastmath; we compute in float64 (matches to ~1e-6,
+ * within the §3.3 tolerance policy).
+ */
+declare const SMOOTH_K_TOLERANCE = 0.00001;
+declare const MIN_K_DIST_SCALE = 0.001;
+interface SmoothKnnResult {
+  sigmas: Float32Array;
+  rhos: Float32Array;
+}
+interface SmoothKnnOptions {
+  nIter?: number;
+  localConnectivity?: number;
+  bandwidth?: number;
+}
+/**
+ * @param distances (nSamples × nNeighbors) row-major, each row sorted ascending
+ *                  (includes self at column 0 for standard kNN).
+ * @param k the float number of neighbors (callers pass the integer k).
+ */
+declare function smoothKnnDist(distances: Float32Array, nNeighbors: number, k: number, {
+  nIter,
+  localConnectivity,
+  bandwidth
+}?: SmoothKnnOptions): SmoothKnnResult;
+//#endregion
+//#region src/init/index.d.ts
+type InitMethod = 'spectral' | 'random' | 'pca' | Embedding;
+/** noisy_scale_coords (umap_.py:928-935): scale abs-max to maxCoord, add N(0, noise). */
+declare function noisyScaleCoords(coords: Float64Array, rng: Pcg32, maxCoord?: number, noise?: number): void;
+/** Final rescale applied to EVERY init (umap_.py:1188-1192): per-dim min-max → [0,10]. */
+declare function finalInitRescale(embedding: Float64Array, n: number, dim: number): Float32Array;
+interface InitializeOptions {
+  logger?: Logger;
+}
+interface InitializeResult {
+  embedding: Float32Array;
+  spectralFallback: boolean;
+}
+/**
+ * Produce the initial embedding for `graph` (pruned fuzzy graph) and `data`.
+ * Data may be null when init doesn't need it (random / spectral without
+ * multi-component meta layout data).
+ */
+declare function initializeEmbedding(init: InitMethod, data: Matrix | null, graph: Csr, dim: number, rng: Pcg32, {
+  logger
+}?: InitializeOptions): InitializeResult;
+//#endregion
+//#region src/init/pca.d.ts
+declare function pcaScores(X: Matrix, dim: number, rng: Pcg32, center?: boolean): Float64Array;
+//#endregion
+//#region src/init/spectral.d.ts
+interface SpectralResult {
+  embedding: Float64Array;
+  usedFallback: boolean;
+}
+/** Connected components via BFS over an undirected CSR graph. */
+declare function connectedComponents(graph: Csr): {
+  count: number;
+  labels: Int32Array;
+};
+interface LobpcgResult {
+  values: Float64Array;
+  /** col-major eigenvectors (m columns of length n) */
+  vectors: Float64Array;
+  converged: boolean;
+  iterations: number;
+  residuals: Float64Array;
+}
+/**
+ * LOBPCG for the m smallest eigenpairs of the normalized Laplacian of `graph`,
+ * with diagonal (Jacobi) preconditioner. X0 is col-major n×m.
+ */
+declare function lobpcgSmallest(graph: Csr, dinvsqrt: Float64Array, X0: Float64Array, m: number, tol?: number, maxIter?: number): LobpcgResult;
+/** Degree vector d_i = Σ_j A_ij and its inverse sqrt. */
+declare function degreeInvSqrt(graph: Csr): {
+  deg: Float64Array;
+  dinvsqrt: Float64Array;
+};
+/**
+ * spectral_layout: normalized-Laplacian eigenmaps of the fuzzy graph with
+ * multi-component handling. Returns n×dim float64 (caller scales/noises/casts).
+ */
+declare function spectralLayout(data: Matrix | null, graph: Csr, dim: number, rng: Pcg32, logger?: Logger): SpectralResult;
+declare namespace metrics_d_exports {
+  export { ANGULAR_METRICS, MetricImpl, MetricOptions, NAMED_METRICS, Vec, brayCurtis, canberra, canonicalMetricName, chebyshev, correlation, cosine, dice, euclidean, hamming, haversine, hellinger, isNamedMetric, jaccard, kulsinski, llDirichlet, mahalanobis, manhattan, matching, minkowski, resolveMetric, rogersTanimoto, russellrao, sokalMichener, sokalSneath, sqeuclidean, standardisedEuclidean, symmetricKl, validateMetricOptionSizes, weightedMinkowski, yule };
+}
+/**
+ * Named distance metrics — faithful ports of `umap.distances` (vendored 0.5.9.post2).
+ * Every formula, branch, and edge case mirrors the Python source (see
+ * reference/notes/umap-internals.md and DECISIONS.md D-004 for the requirement set).
+ *
+ * Computation is float64 (JS Number); inputs are typically Float32Array views.
+ */
+type Vec = Float32Array | Float64Array;
+type MetricImpl = (x: Vec, y: Vec) => number;
+interface MetricOptions {
+  /** minkowski / wminkowski exponent */
+  p?: number;
+  /** seuclidean variance vector */
+  V?: ArrayLike<number>;
+  /** wminkowski weight vector */
+  w?: ArrayLike<number>;
+  /** mahalanobis inverse covariance (row-major cols×cols) */
+  VInv?: ArrayLike<number>;
+}
+declare function euclidean(x: Vec, y: Vec): number;
+/** Squared euclidean — used internally by the optimizer (rdist). */
+declare function sqeuclidean(x: Vec, y: Vec): number;
+declare function standardisedEuclidean(x: Vec, y: Vec, sigma: ArrayLike<number>): number;
+declare function manhattan(x: Vec, y: Vec): number;
+declare function chebyshev(x: Vec, y: Vec): number;
+declare function minkowski(x: Vec, y: Vec, p: number): number;
+declare function weightedMinkowski(x: Vec, y: Vec, w: ArrayLike<number>, p: number): number;
+declare function mahalanobis(x: Vec, y: Vec, vinv: ArrayLike<number>): number;
+declare function hamming(x: Vec, y: Vec): number;
+declare function canberra(x: Vec, y: Vec): number;
+declare function brayCurtis(x: Vec, y: Vec): number;
+declare function jaccard(x: Vec, y: Vec): number;
+declare function matching(x: Vec, y: Vec): number;
+declare function dice(x: Vec, y: Vec): number;
+declare function kulsinski(x: Vec, y: Vec): number;
+declare function rogersTanimoto(x: Vec, y: Vec): number;
+declare function russellrao(x: Vec, y: Vec): number;
+declare function sokalMichener(x: Vec, y: Vec): number;
+declare function sokalSneath(x: Vec, y: Vec): number;
+declare function yule(x: Vec, y: Vec): number;
+declare function cosine(x: Vec, y: Vec): number;
+declare function correlation(x: Vec, y: Vec): number;
+declare function hellinger(x: Vec, y: Vec): number;
+declare function llDirichlet(data1: Vec, data2: Vec): number;
+/**
+ * Symmetrized KL divergence. NOTE: the Python source mutates its inputs (adds z,
+ * normalizes in place); we copy to preserve the same numerics without side effects.
+ */
+declare function symmetricKl(x: Vec, y: Vec, z?: number): number;
+declare function haversine(x: Vec, y: Vec): number;
+declare const NAMED_METRICS: readonly string[];
+/** Metrics that auto-enable angular RP-forest (umap_.py:1938-1946). */
+declare const ANGULAR_METRICS: Set<string>;
+declare function isNamedMetric(name: string): boolean;
+declare function canonicalMetricName(name: string): string;
+declare function resolveMetric(name: string, options?: MetricOptions): MetricImpl;
+/**
+ * Size/positivity checks for metricOptions once the data dimension is known —
+ * a wrong-sized V/w/VInv would otherwise read undefined and silently poison
+ * every distance with NaN.
+ */
+declare function validateMetricOptionSizes(name: string, options: MetricOptions, dim: number): void;
+//#endregion
+//#region src/knn/exact.d.ts
+interface ExactKnnOptions {
+  metricOptions?: MetricOptions;
+  /** distances >= this become inf / index -1 (disconnection pruning) */
+  disconnectionDistance?: number;
+}
+/** Row-wise exact kNN for dense data. Accepts a named metric or a custom MetricFn. */
+declare function exactKnnDense(X: Matrix, k: number, metricName: string | ((a: Float32Array, b: Float32Array) => number), {
+  metricOptions,
+  disconnectionDistance
+}?: ExactKnnOptions): KnnGraph;
+/** Exact kNN for CSR input (euclidean or cosine). */
+declare function exactKnnSparse(X: CSRInput, k: number, metricName: string): KnnGraph;
+/**
+ * metric='precomputed': X is a dense n×n distance matrix; per-row argsort prefix
+ * (umap_.py:312-324); infinite distances → index -1.
+ */
+declare function knnFromPrecomputed(X: Matrix, k: number): KnnGraph;
+//#endregion
+//#region src/knn/rpforest.d.ts
+interface FlatTree {
+  /** nNodes × dim hyperplane vectors (dense) */
+  hyperplanes: Float32Array;
+  offsets: Float32Array;
+  /** nNodes × 2; internal: child node ids (>0); leaf: (-leafStart, -leafEnd) */
+  children: Int32Array;
+  /** concatenated leaf point indices (a permutation of all points) */
+  indices: Int32Array;
+  leafSize: number;
+  nNodes: number;
+  dim: number;
+}
+//#endregion
+//#region src/knn/search.d.ts
+type PairDist = (a: Float32Array, b: Float32Array) => number;
+interface SearchIndex {
+  /** reordered connectivity graph (uint8 semantics: indices only) */
+  indptr: Int32Array;
+  indices: Int32Array;
+  tree: FlatTree;
+  /** reordered row idx → original idx */
+  vertexOrder: Int32Array;
+  /** reordered data rows */
+  data: Matrix;
+  dist: PairDist;
+  correction: (d: number) => number;
+  angular: boolean;
+  minDistance: number;
+  searchRngState: Int32Array;
+  nNeighbors: number;
+}
+/**
+ * Dense query (notes §7): tree init + random top-up + best-first expansion with
+ * bound d_k + ε(d_k − minDistance). Returns ORIGINAL indices and CORRECTED distances.
+ */
+declare function searchKnn(index: SearchIndex, Q: Matrix, k: number, epsilon: number): KnnGraph;
+//#endregion
+//#region src/knn/index.d.ts
+declare const SMALL_DATA_CUTOFF = 4096;
+interface NearestNeighborsResult {
+  knn: KnnGraph;
+  /** present only for the approximate (NNDescent) dense path */
+  searchIndex: SearchIndex | null;
+  /** which path ran */
+  method: 'exact' | 'nndescent';
+}
+interface NearestNeighborsOptions {
+  metricOptions?: MetricOptions;
+  forceApproximation?: boolean;
+  /** accepted and ignored, matching the pinned pynndescent 0.6.0 (D-007) */
+  lowMemory?: boolean;
+  /** force angular RP-tree splits; ORed with the metric family like Python */
+  angularRpForest?: boolean;
+  disconnectionDistance?: number;
+}
+declare function nearestNeighborsDense(X: Matrix, nNeighbors: number, metricName: string, rng: Pcg32, {
+  metricOptions,
+  forceApproximation,
+  angularRpForest,
+  disconnectionDistance
+}?: NearestNeighborsOptions): NearestNeighborsResult;
+declare function nearestNeighborsSparse(X: CSRInput, nNeighbors: number, metricName: string, rng: Pcg32, {
+  forceApproximation,
+  angularRpForest,
+  disconnectionDistance
+}?: NearestNeighborsOptions): NearestNeighborsResult;
+//#endregion
+//#region src/knn/heap.d.ts
+/**
+ * pynndescent heap structure (utils.py:130-218, 352-533): per-row max-heap on
+ * distance rooted at column 0 (root = current worst). Rows: indices int32 (-1 empty),
+ * distances float32 (+inf empty), flags uint8.
+ */
+interface NeighborHeap {
+  indices: Int32Array;
+  distances: Float32Array;
+  flags: Uint8Array;
+  n: number;
+  size: number;
+}
+//#endregion
+//#region src/knn/nndescent.d.ts
+type DistFn = (i: number, j: number) => number;
+interface NnDescentOptions {
+  maxCandidates?: number;
+  nIters?: number;
+  delta?: number;
+  /** dense leaf init: d < max(tp,tq); sparse: d < tp or d < tq (notes §9) */
+  leafAcceptance?: 'max' | 'either';
+  /** per-iteration progress hook (the library never writes to the console) */
+  onIteration?: (iter: number, c: number) => void;
+}
+/**
+ * Full NN-descent. `leafArray` from the RP forest (or null to skip tree init).
+ * Returns the heap AFTER deheap_sort: ascending distances, (-1, inf) tails.
+ * Distances are in the INTERNAL metric space (corrections applied by the caller).
+ */
+declare function nnDescent(n: number, nNeighbors: number, dist: DistFn, rngState: Int32Array, leafArray: {
+  data: Int32Array;
+  rows: number;
+  cols: number;
+} | null, {
+  maxCandidates,
+  nIters,
+  delta,
+  leafAcceptance,
+  onIteration
+}?: NnDescentOptions): NeighborHeap;
+/** umap's NNDescent parameter rules (umap_.py:327-328). */
+declare function umapNnDescentParams(n: number): {
+  nTrees: number;
+  nIters: number;
+};
+//#endregion
+//#region src/linalg.d.ts
+/**
+ * Small dense linear algebra (float64): cyclic Jacobi eigensolver for symmetric
+ * matrices, modified Gram–Schmidt, and dense helpers. Used by LOBPCG's Rayleigh–Ritz
+ * step (block sizes ≤ ~12) and the multi-component meta layout.
+ */
+interface EigResult {
+  /** ascending eigenvalues */
+  values: Float64Array;
+  /** column-major eigenvectors: vectors[c * n + r] = component r of eigenvector c */
+  vectors: Float64Array;
+}
+/** Cyclic Jacobi for a symmetric n×n matrix (row-major input, not modified). */
+declare function symmetricEigen(A: Float64Array, n: number, maxSweeps?: number): EigResult;
+/**
+ * Modified Gram–Schmidt over columns stored contiguously (col-major: X[c*n..c*n+n)).
+ * Columns with norm below dropTol (relative to their original norm) are dropped.
+ * Returns the number of retained columns (retained columns are compacted in place).
+ */
+declare function mgsOrthonormalize(X: Float64Array, n: number, cols: number, dropTol?: number): number;
+//#endregion
+//#region src/util.d.ts
+/** Convert any DenseInput to a canonical float32 Matrix, validating finiteness (§4.1). */
+declare function toMatrix(input: DenseInput, what?: string): Matrix;
+//#endregion
+export { noisyScaleCoords as A, degreeInvSqrt as C, InitMethod as D, pcaScores as E, fuzzySimplicialSet as F, defaultNEpochs as I, makeEpochsPerSample as L, SMOOTH_K_TOLERANCE as M, smoothKnnDist as N, finalInitRescale as O, computeMembershipStrengths as P, pruneGraphForEpochs as R, connectedComponents as S, spectralLayout as T, NAMED_METRICS as _, umapNnDescentParams as a, metrics_d_exports as b, nearestNeighborsDense as c, searchKnn as d, exactKnnDense as f, MetricOptions as g, ANGULAR_METRICS as h, nnDescent as i, MIN_K_DIST_SCALE as j, initializeEmbedding as k, nearestNeighborsSparse as l, knnFromPrecomputed as m, mgsOrthonormalize as n, NearestNeighborsResult as o, exactKnnSparse as p, symmetricEigen as r, SMALL_DATA_CUTOFF as s, toMatrix as t, SearchIndex as u, canonicalMetricName as v, lobpcgSmallest as w, resolveMetric as x, isNamedMetric as y, findABParams as z };
+//# sourceMappingURL=core-IHdw-3yY.d.ts.map

package/dist/core.d.ts

@@ -0,0 +1,3 @@
+import { a as csrForEach, c as csrMaxAbsDiff, d as csrTranspose, f as Pcg32, h as tauRandInt, i as csrEliminateZeros, l as csrNnz, m as tauRand, n as csrBinaryOp, o as csrFromCoo, p as floorMod, r as csrCopy, s as csrMapValues, t as Csr, u as csrRowNormalizeMax } from "./sparse-BxSeVhO4.js";
+import { A as noisyScaleCoords, C as degreeInvSqrt, D as InitMethod, E as pcaScores, F as fuzzySimplicialSet, I as defaultNEpochs, L as makeEpochsPerSample, M as SMOOTH_K_TOLERANCE, N as smoothKnnDist, O as finalInitRescale, P as computeMembershipStrengths, R as pruneGraphForEpochs, S as connectedComponents, T as spectralLayout, _ as NAMED_METRICS, a as umapNnDescentParams, b as metrics_d_exports, c as nearestNeighborsDense, d as searchKnn, f as exactKnnDense, h as ANGULAR_METRICS, i as nnDescent, j as MIN_K_DIST_SCALE, k as initializeEmbedding, l as nearestNeighborsSparse, m as knnFromPrecomputed, n as mgsOrthonormalize, o as NearestNeighborsResult, p as exactKnnSparse, r as symmetricEigen, s as SMALL_DATA_CUTOFF, t as toMatrix, u as SearchIndex, v as canonicalMetricName, w as lobpcgSmallest, x as resolveMetric, y as isNamedMetric, z as findABParams } from "./core-IHdw-3yY.js";
+export { ANGULAR_METRICS, Csr, InitMethod, MIN_K_DIST_SCALE, NAMED_METRICS, NearestNeighborsResult, Pcg32, SMALL_DATA_CUTOFF, SMOOTH_K_TOLERANCE, SearchIndex, 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_d_exports as metrics, mgsOrthonormalize, nearestNeighborsDense, nearestNeighborsSparse, nnDescent, noisyScaleCoords, pcaScores, pruneGraphForEpochs, resolveMetric, searchKnn, smoothKnnDist, spectralLayout, symmetricEigen, tauRand, tauRandInt, toMatrix, umapNnDescentParams };

package/dist/core.js

@@ -0,0 +1,4 @@
+import { B as csrCopy, 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, d as umapNnDescentParams, g as Pcg32, j as computeMembershipStrengths, k as resolveMetric, l as searchKnn, o as nearestNeighborsDense, q as csrRowNormalizeMax, r as toMatrix, s as nearestNeighborsSparse, 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 { a as degreeInvSqrt, c as spectralLayout, d as symmetricEigen, i as connectedComponents, l as pcaScores, n as initializeEmbedding, o as lobpcgSmallest, r as noisyScaleCoords, t as finalInitRescale, u as mgsOrthonormalize } from "./init-DLiEtGpx.js";
+
+export { ANGULAR_METRICS, MIN_K_DIST_SCALE, NAMED_METRICS, Pcg32, SMALL_DATA_CUTOFF, SMOOTH_K_TOLERANCE, 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 };

package/dist/index.d.ts

@@ -0,0 +1,261 @@
+import { C as MetricFn, D as UmapError, E as UmapConvergenceWarning, O as UmapValidationError, S as Matrix, T as UmapBackendError, _ as DenseInput, a as csrForEach, b as Labels, c as csrMaxAbsDiff, d as csrTranspose, f as Pcg32, g as CSRInput, h as tauRandInt, i as csrEliminateZeros, l as csrNnz, m as tauRand, n as csrBinaryOp, o as csrFromCoo, p as floorMod, r as csrCopy, s as csrMapValues, t as Csr, u as csrRowNormalizeMax, v as Embedding, w as Target, x as Logger, y as KnnGraph } from "./sparse-BxSeVhO4.js";
+import { A as noisyScaleCoords, C as degreeInvSqrt, D as InitMethod, E as pcaScores, F as fuzzySimplicialSet, I as defaultNEpochs, L as makeEpochsPerSample, M as SMOOTH_K_TOLERANCE, N as smoothKnnDist, O as finalInitRescale, P as computeMembershipStrengths, R as pruneGraphForEpochs, S as connectedComponents, T as spectralLayout, _ as NAMED_METRICS, a as umapNnDescentParams, b as metrics_d_exports, c as nearestNeighborsDense, d as searchKnn, f as exactKnnDense, g as MetricOptions, h as ANGULAR_METRICS, i as nnDescent, j as MIN_K_DIST_SCALE, k as initializeEmbedding, l as nearestNeighborsSparse, m as knnFromPrecomputed, n as mgsOrthonormalize, o as NearestNeighborsResult, p as exactKnnSparse, r as symmetricEigen, s as SMALL_DATA_CUTOFF, t as toMatrix, u as SearchIndex, v as canonicalMetricName, w as lobpcgSmallest, x as resolveMetric, y as isNamedMetric, z as findABParams } from "./core-IHdw-3yY.js";
+
+//#region src/estimator/options.d.ts
+
+interface UmapOptions {
+  nNeighbors?: number;
+  nComponents?: number;
+  metric?: string | MetricFn;
+  metricOptions?: MetricOptions;
+  outputMetric?: string;
+  outputMetricOptions?: Record<string, number>;
+  nEpochs?: number;
+  learningRate?: number;
+  init?: InitMethod;
+  minDist?: number;
+  spread?: number;
+  lowMemory?: boolean;
+  concurrency?: number | 'auto';
+  setOpMixRatio?: number;
+  localConnectivity?: number;
+  repulsionStrength?: number;
+  negativeSampleRate?: number;
+  transformQueueSize?: number;
+  a?: number;
+  b?: number;
+  seed?: number;
+  angularRpForest?: boolean;
+  targetNNeighbors?: number;
+  targetMetric?: string;
+  targetMetricOptions?: MetricOptions;
+  targetWeight?: number;
+  transformSeed?: number;
+  transformMode?: 'embedding' | 'graph';
+  forceApproximation?: boolean;
+  verbose?: boolean | Logger;
+  unique?: boolean;
+  densMap?: boolean;
+  densLambda?: number;
+  densFrac?: number;
+  densVarShift?: number;
+  outputDens?: boolean;
+  disconnectionDistance?: number;
+  precomputedKnn?: {
+    indices: Int32Array;
+    distances: Float32Array;
+    k: number;
+  };
+  backend?: 'auto' | 'cpu' | 'webgpu';
+  device?: unknown;
+  /**
+   * Explicit worker entry for the parallel CPU backend, for bundlers that do
+   * not detect the library's inline `new Worker(new URL(...))` pattern.
+   * Browser: an absolute URL/string (e.g. Vite's `'umap-web/worker?worker&url'`
+   * import). Node: a file:// URL or absolute path. When spawning from this URL
+   * fails, fit() warns and continues single-threaded. See README
+   * "Workers & bundlers".
+   */
+  workerUrl?: URL | string;
+  deterministic?: boolean;
+  /** GPU SGD accumulation strategy (§A2, D-011); default from measurements */
+  gpuLayoutStrategy?: 'vertexGather' | 'edgeAtomic';
+  onEpoch?: (e: {
+    epoch: number;
+    nEpochs: number;
+    phase: string;
+    embedding?: Float32Array;
+  }) => void;
+}
+/** DISCONNECTION_DISTANCES (umap_.py:61-68). */
+declare const DISCONNECTION_DISTANCES: Record<string, number>;
+interface FitCallOptions {
+  signal?: AbortSignal;
+}
+//#endregion
+//#region src/estimator/aligned.d.ts
+interface AlignedUmapOptions extends UmapOptions {
+  alignmentRegularisation?: number;
+  alignmentWindowSize?: number;
+}
+/** Row-index mapping from slice i to slice i+1. */
+type Relation = Record<number, number> | Map<number, number>;
+declare class AlignedUMAP {
+  readonly options: AlignedUmapOptions;
+  private _embeddings;
+  private _mappers;
+  private _relations;
+  constructor(options?: AlignedUmapOptions);
+  get embeddings(): Embedding[];
+  fit(XList: DenseInput[], yList?: (Labels | null)[] | null, relations?: Relation[], {
+    signal
+  }?: FitCallOptions): Promise<this>;
+  fitTransform(XList: DenseInput[], yList?: (Labels | null)[] | null, relations?: Relation[], opts?: FitCallOptions): Promise<Embedding[]>;
+  /** Append a new slice (aligned_umap.py:446-562): old slices frozen except pulls. */
+  update(Xnew: DenseInput, relation: Relation, {
+    signal
+  }?: FitCallOptions): Promise<this>;
+}
+//#endregion
+//#region src/backends/cpu/pool.d.ts
+type AnyRec = Record<string, any>;
+/**
+ * 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).
+ */
+
+declare class WorkerPool {
+  private workers;
+  private pending;
+  private nextId;
+  private failure;
+  private terminating;
+  private cleanup;
+  readonly size: number;
+  private constructor();
+  /**
+   * 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 create(size: number, source?: URL | string, cleanup?: () => void): Promise<WorkerPool>;
+  /** A worker died: poison the pool and reject everything in flight. */
+  private markFailed;
+  private dispatch;
+  call<T>(worker: number, method: string, args: AnyRec, transfers?: Transferable[]): Promise<T>;
+  /** Run `method` on every worker with per-worker args; await all. */
+  mapAll<T>(method: string, argsFor: (w: number) => AnyRec, transfersFor?: (w: number) => Transferable[]): Promise<T[]>;
+  terminate(): Promise<void>;
+}
+//#endregion
+//#region src/backends/cpu/workers.d.ts
+interface ParallelContext {
+  pool: WorkerPool;
+  sab: boolean;
+  data: Float32Array;
+  rows: number;
+  cols: number;
+  dist: (a: Float32Array, b: Float32Array) => number;
+}
+//#endregion
+//#region src/estimator/umap.d.ts
+interface ResolvedBackendInfo {
+  knn: string;
+  layout: string;
+}
+declare class UMAP {
+  readonly options: UmapOptions;
+  protected logger: Logger;
+  _embedding: Embedding | null;
+  _embeddingUnique: Float32Array | null;
+  _graph: Csr | null;
+  _sigmas: Float32Array | null;
+  _rhos: Float32Array | null;
+  _knn: KnnGraph | null;
+  _searchIndex: SearchIndex | null;
+  _rawData: Matrix | null;
+  _rawCsr: CSRInput | null;
+  _uniqueIndex: Int32Array | null;
+  _uniqueInverse: Int32Array | null;
+  _a: number;
+  _b: number;
+  _nNeighborsUsed: number;
+  _smallData: boolean;
+  _disconnection: number;
+  _supervised: boolean;
+  _inputHash: string | null;
+  _radOrig: Float32Array | null;
+  _radEmb: Float32Array | null;
+  protected _backendInfo: ResolvedBackendInfo;
+  protected _timings: Record<string, number>;
+  protected _parallel: ParallelContext | null;
+  protected _gpu: any;
+  protected _gpuCtx: any;
+  protected _useGpuLayout: boolean;
+  /** name of the in-flight operation; guards against concurrent use */
+  private _busy;
+  constructor(options?: UmapOptions);
+  private validateOptions;
+  get embedding(): Embedding;
+  /** CSR fuzzy graph over the training data (unique rows when unique=true). */
+  get graph(): Csr;
+  get densities(): {
+    original: Float32Array;
+    embedded: Float32Array;
+  };
+  /** Which backend actually executed each stage (§5.2). */
+  get backendInfo(): ResolvedBackendInfo;
+  get phaseTimings(): Record<string, number>;
+  protected resolveMetricName(): string;
+  /** Serialize operations on one instance: concurrent calls are a caller bug. */
+  private withBusy;
+  private snapshotFittedState;
+  private restoreFittedState;
+  /** Discard fitted state so a running fit never exposes a mixed old/new model. */
+  private resetFittedState;
+  /** Stop using the GPU for the rest of this fit (typed failure → CPU, D-017). */
+  private dropGpu;
+  /** Always runs after fit (success, error, or abort): no leaked workers/devices. */
+  private releaseBackends;
+  fit(X: DenseInput | CSRInput, y?: Labels | Target | null, {
+    signal
+  }?: FitCallOptions): Promise<this>;
+  private fitInner;
+  protected embedGraph(graph: Csr, graphDists: Csr | null, dense: Matrix | null, nComponents: number, outputMetric: string, rng: Pcg32, {
+    densMap,
+    outputDens,
+    signal,
+    initOverride,
+    nEpochsOverride
+  }: {
+    densMap: boolean;
+    outputDens: boolean;
+    signal?: AbortSignal;
+    initOverride?: Float32Array;
+    nEpochsOverride?: number;
+  }): Promise<void>;
+  fitTransform(X: DenseInput | CSRInput, y?: Labels | Target | null, opts?: FitCallOptions): Promise<Embedding>;
+  transform(Xnew: DenseInput, {
+    signal
+  }?: FitCallOptions): Promise<Embedding>;
+  /** transformMode 'graph': the bipartite membership CSR (nNew × nTrain). */
+  transformGraph(Xnew: DenseInput, {
+    signal
+  }?: FitCallOptions): Promise<Csr>;
+  private transformInner;
+  /**
+   * 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.
+   */
+  private buildSearchIndexFromKnn;
+  private uniqueTrainMatrix;
+  inverseTransform(points: DenseInput, {
+    signal
+  }?: FitCallOptions): Promise<Embedding>;
+  private inverseTransformInner;
+  update(Xmore: DenseInput, {
+    signal
+  }?: FitCallOptions): Promise<this>;
+  private updateInner;
+  serialize(): Uint8Array;
+  static deserialize(blob: Uint8Array): UMAP;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * umap-web — standalone TypeScript UMAP for browsers and Node.js.
+ *
+ * Public entry point. See `umap-web/core` for the low-level functional API.
+ */
+declare const VERSION = "0.1.0";
+//#endregion
+export { ANGULAR_METRICS, AlignedUMAP, type AlignedUmapOptions, type CSRInput, Csr, DISCONNECTION_DISTANCES, type DenseInput, type Embedding, type FitCallOptions, InitMethod, type KnnGraph, type Labels, type Logger, MIN_K_DIST_SCALE, type MetricFn, NAMED_METRICS, NearestNeighborsResult, Pcg32, type Relation, SMALL_DATA_CUTOFF, SMOOTH_K_TOLERANCE, SearchIndex, type Target, UMAP, UmapBackendError, UmapConvergenceWarning, UmapError, type UmapOptions, 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_d_exports as metrics, mgsOrthonormalize, nearestNeighborsDense, nearestNeighborsSparse, nnDescent, noisyScaleCoords, pcaScores, pruneGraphForEpochs, resolveMetric, searchKnn, smoothKnnDist, spectralLayout, symmetricEigen, tauRand, tauRandInt, toMatrix, umapNnDescentParams };
+//# sourceMappingURL=index.d.ts.map