Distance metric ("euclidean", "cosine", etc.). Default: "euclidean".

Number of negative samples per positive sample. Default: 5.

Scale embedding coordinates and add noise to avoid local minima.

Optimizer to use for the layout SGD. Default: [`Optimizer::Sgd`].

Orthonormalize columns via modified Gram-Schmidt. Columns with norm below `eps` are replaced with zero vectors. Returns false only if all columns are

Stages 1–7: nearest neighbors, fuzzy graph, prune, init, edge schedule. Shared by [`build_async`](Self::build_async) and [`setup_async`](Self::setup_a

Push (enter) a stage. Reports progress at stage start.

Random i64 in [lo, hi).

Subtract `base` from both schedule-counter buffers (keeps the f32 epoch coordinate precise over indefinitely long runs).

Replace the embedding and reset the schedule, epoch, and velocity — i.e. a full restart of the layout optimization from a new initial position.

Return the report HTML path for a benchmark suite.

(Re)seed the per-edge negative-sample counters for the current rate so the next negative sample for each edge falls ~`epn` epochs after `from_epoch`.

Reset the per-edge schedule counters (eons = eps, eonns = eps/rate) and clear the gradient accumulator.

* Detect the `features` column kind (string-list vs struct-list) via a cheap * DESCRIBE. Pure detection — callers commit the result to `this.featur

* Turn a user-specified state (from the API) into an internal state. * An InternalState is just a EmbeddingAtlasState with all fields non-optional *

Return the results CSV path for a benchmark suite.

Compute row sums (degree vector).

Run all UMAP benchmarks.

Run a benchmark command that writes a JSON result file. Returns the parsed result dict with 'threads' added, or None on failure.

Run one CPU epoch in place at the current parameters.

Run one epoch on the GPU at the given (already-decayed) parameters. SGD splits the epoch into `n_sub` accumulate→apply rounds so later sub-batches se

Return path to a compiled Rust benchmark binary.

Run a single filter/info pass and return spans per text, aligned by index.

Switch optimizer. Resets the velocity buffer. Queued; runs in order after any in-flight `step`/`run`.

* Update live parameters. `learningRate` is used flat by `step` and as the * decay peak by `run`. `minDist`/`spread` re-fit the output curve. Safe

* Haldane–Anscombe-corrected log-odds ratio and its signed, confidence-aware * lower bound for a 2×2 contingency table with raw cells: * * | cl

Push a value into a max-heap without checking for duplicates. Returns 1 if the value was inserted, 0 if rejected (distance too large).

* SQL expression for the parallel list of sources (VARCHAR[]). Derived from the * same base list as featureValuesExpr, so the two stay element-aligne

Compute spectral embedding of the graph using the normalized Laplacian. Uses LOBPCG (Locally Optimal Block Preconditioned Conjugate Gradient) to find

Report sub-progress within the current stage. `progress` is 0.0 to 1.0 within this stage. `status` optionally overrides the stage name in the callbac

* Publish (or update) the feature-selection clause into the global * cross-filter. Selected features combine with AND: a data row matches iff *

* Vite plugin that converts TypeScript interfaces to JSON schemas * @param {Object} options - Plugin options * @param {string} [options.tsconfig='ts

Creates a value node.

Enable verbose output. Default: false.

* Wrap a built wasm `Umap` instance in the stable JS UMAP interface. A * {@link createSequencer} mediates all wasm access so callers can safely step

Zero the velocity buffer (on optimizer switch / reinit).

Return display implementation name (rust, rust-gpu, python).

* Create the id-based mapper table `(__main_id, __aux_id)` for an auxiliary table, * derived from its relation. No-op if the table declares no rela

Build the HTML section with canvas elements for embedding visualization.

Gzip compress and base64 encode bytes.

Optimal rotation + translation (Kabsch). Returns (transformed, error).

Load, align, and normalize UMAP embeddings for all (n_points, metric, threads) groups. Returns list of dicts with gzipped+base64-encoded embeddin

Generate a random RGB image as PNG bytes.

Generate a random mono WAV file as bytes.