umap-gpu 0.2.11 → 0.2.14

package/dist/fuzzy-set.d.ts

@@ -1,6 +1,6 @@
 export interface FuzzyGraph {
-    rows: Float32Array;
-    cols: Float32Array;
+    rows: Uint32Array;
+    cols: Uint32Array;
     vals: Float32Array;
     nVertices: number;
 }

package/dist/gpu/device.d.ts

@@ -7,6 +7,23 @@
  */
 export declare function getGPUDevice(): Promise<GPUDevice | null>;
 /**
- * Check whether WebGPU is available in the current environment.
+ * Fast synchronous heuristic: returns `true` if `navigator.gpu` exists.
+ *
+ * **Caveat (Bug 13):** `navigator.gpu` being truthy does NOT guarantee that a
+ * WebGPU adapter can be acquired — `requestAdapter()` may still return `null`
+ * (no compatible hardware, or the browser has disabled WebGPU for the page).
+ * Use `checkWebGPUAvailable()` for a reliable async check, or rely on the
+ * `try/catch` around `GPUSgd.init()` in the calling code.
  */
 export declare function isWebGPUAvailable(): boolean;
+/**
+ * Reliably check whether WebGPU is usable in the current environment by
+ * attempting to acquire an adapter via `getGPUDevice()`.
+ *
+ * Unlike the synchronous `isWebGPUAvailable()`, this actually calls
+ * `navigator.gpu.requestAdapter()` and returns `false` if the adapter is
+ * unavailable (no compatible GPU, browser policy, etc.).
+ *
+ * The result is automatically cached — repeated calls are free.
+ */
+export declare function checkWebGPUAvailable(): Promise<boolean>;

package/dist/gpu/sgd.d.ts

@@ -6,11 +6,23 @@ export interface SGDParams {
 }
 /**
  * GPU-accelerated SGD optimizer for UMAP embedding.
- * Each GPU thread processes one graph edge, applying attraction and repulsion forces.
+ *
+ * Uses a two-pass design per epoch to eliminate write-write races on shared
+ * vertex positions (Bug 2 fix):
+ *   Pass 1 (sgd.wgsl):           Each thread accumulates its attraction and
+ *                                  repulsion gradients into an atomic<i32>
+ *                                  forces buffer — no direct embedding writes.
+ *   Pass 2 (apply-forces.wgsl):  Each thread applies one element's accumulated
+ *                                  force to the embedding and resets the
+ *                                  accumulator to zero for the next epoch.
+ *
+ * Both passes are submitted in the same command encoder so WebGPU guarantees
+ * sequential execution and storage-buffer visibility between them.
  */
 export declare class GPUSgd {
     private device;
-    private pipeline;
+    private sgdPipeline;
+    private applyForcesPipeline;
     init(): Promise<void>;
     /**
      * Run SGD optimization on the GPU.

package/dist/index.d.ts

@@ -2,4 +2,4 @@ export { fit, UMAP } from './umap';
 export type { UMAPOptions, ProgressCallback } from './umap';
 export type { KNNResult, HNSWOptions, HNSWSearchableIndex } from './hnsw-knn';
 export type { FuzzyGraph } from './fuzzy-set';
-export { isWebGPUAvailable } from './gpu/device';
+export { isWebGPUAvailable, checkWebGPUAvailable } from './gpu/device';

package/dist/index.js

@@ -1,104 +1,111 @@
-var H = Object.defineProperty;
-var V = (e, n, r) => n in e ? H(e, n, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[n] = r;
-var G = (e, n, r) => V(e, typeof n != "symbol" ? n + "" : n, r);
-import { loadHnswlib as C } from "hnswlib-wasm";
-async function Y(e, n, r = {}) {
-  const { M: s = 16, efConstruction: t = 200, efSearch: p = 50 } = r, f = await C(), l = e[0].length, c = e.length, a = new f.HierarchicalNSW("l2", l, "");
-  a.initIndex(c, s, t, 200), a.setEfSearch(Math.max(p, n)), a.addItems(e, !1);
-  const o = [], i = [];
-  for (let h = 0; h < c; h++) {
-    const d = a.searchKnn(e[h], n + 1, void 0), u = d.neighbors.map((g, m) => ({ idx: g, dist: d.distances[m] })).filter(({ idx: g }) => g !== h).slice(0, n);
-    o.push(u.map(({ idx: g }) => g)), i.push(u.map(({ dist: g }) => g));
+var te = Object.defineProperty;
+var ne = (e, t, f) => t in e ? te(e, t, { enumerable: !0, configurable: !0, writable: !0, value: f }) : e[t] = f;
+var C = (e, t, f) => ne(e, typeof t != "symbol" ? t + "" : t, f);
+import { loadHnswlib as H } from "hnswlib-wasm";
+async function se(e, t, f = {}) {
+  const { M: a = 16, efConstruction: s = 200, efSearch: u = 50 } = f, c = await H(), d = e[0].length, i = e.length, n = new c.HierarchicalNSW("l2", d, "");
+  n.initIndex(i, a, s, 200), n.setEfSearch(Math.max(u, t)), n.addItems(e, !1);
+  const r = [], o = [];
+  for (let h = 0; h < i; h++) {
+    const l = n.searchKnn(e[h], t + 1, void 0), p = l.neighbors.map((g, _) => ({ idx: g, dist: l.distances[_] })).filter(({ idx: g }) => g !== h).slice(0, t);
+    r.push(p.map(({ idx: g }) => g)), o.push(p.map(({ dist: g }) => Math.sqrt(g)));
   }
-  return { indices: o, distances: i };
+  return { indices: r, distances: o };
 }
-async function Q(e, n, r = {}) {
-  const { M: s = 16, efConstruction: t = 200, efSearch: p = 50 } = r, f = await C(), l = e[0].length, c = e.length, a = new f.HierarchicalNSW("l2", l, "");
-  a.initIndex(c, s, t, 200), a.setEfSearch(Math.max(p, n)), a.addItems(e, !1);
-  const o = [], i = [];
-  for (let d = 0; d < c; d++) {
-    const u = a.searchKnn(e[d], n + 1, void 0), g = u.neighbors.map((m, w) => ({ idx: m, dist: u.distances[w] })).filter(({ idx: m }) => m !== d).slice(0, n);
-    o.push(g.map(({ idx: m }) => m)), i.push(g.map(({ dist: m }) => m));
+async function ae(e, t, f = {}) {
+  const { M: a = 16, efConstruction: s = 200, efSearch: u = 50 } = f, c = await H(), d = e[0].length, i = e.length, n = new c.HierarchicalNSW("l2", d, "");
+  n.initIndex(i, a, s, 200), n.setEfSearch(Math.max(u, t)), n.addItems(e, !1);
+  const r = [], o = [];
+  for (let l = 0; l < i; l++) {
+    const p = n.searchKnn(e[l], t + 1, void 0), g = p.neighbors.map((_, m) => ({ idx: _, dist: p.distances[m] })).filter(({ idx: _ }) => _ !== l).slice(0, t);
+    r.push(g.map(({ idx: _ }) => _)), o.push(g.map(({ dist: _ }) => Math.sqrt(_)));
   }
-  return { knn: { indices: o, distances: i }, index: {
-    searchKnn(d, u) {
-      const g = [], m = [];
-      for (const w of d) {
-        const b = a.searchKnn(w, u, void 0), y = b.neighbors.map((v, x) => ({ idx: v, dist: b.distances[x] })).sort((v, x) => v.dist - x.dist).slice(0, u);
-        g.push(y.map(({ idx: v }) => v)), m.push(y.map(({ dist: v }) => v));
+  return { knn: { indices: r, distances: o }, index: {
+    searchKnn(l, p) {
+      const g = [], _ = [];
+      for (const m of l) {
+        const y = n.searchKnn(m, p, void 0), b = y.neighbors.map((x, v) => ({ idx: x, dist: y.distances[v] })).sort((x, v) => x.dist - v.dist).slice(0, p);
+        g.push(b.map(({ idx: x }) => x)), _.push(b.map(({ dist: x }) => Math.sqrt(x)));
       }
-      return { indices: g, distances: m };
+      return { indices: g, distances: _ };
     }
   } };
 }
-function D(e, n, r, s = 1) {
-  const t = e.length, { sigmas: p, rhos: f } = L(n, r), l = [], c = [], a = [];
-  for (let i = 0; i < t; i++)
-    for (let h = 0; h < e[i].length; h++) {
-      const d = n[i][h], u = d <= f[i] ? 1 : Math.exp(-((d - f[i]) / p[i]));
-      l.push(i), c.push(e[i][h]), a.push(u);
+function V(e, t, f, a = 1) {
+  const s = e.length, { sigmas: u, rhos: c } = Y(t, f), d = [], i = [], n = [];
+  for (let o = 0; o < s; o++)
+    for (let h = 0; h < e[o].length; h++) {
+      const l = t[o][h], p = l <= c[o] ? 1 : Math.exp(-((l - c[o]) / u[o]));
+      d.push(o), i.push(e[o][h]), n.push(p);
     }
-  return { ...X(l, c, a, t, s), nVertices: t };
+  return { ...oe(d, i, n, s, a), nVertices: s };
 }
-function J(e, n, r) {
-  const s = e.length, { sigmas: t, rhos: p } = L(n, r), f = [], l = [], c = [];
-  for (let a = 0; a < s; a++)
-    for (let o = 0; o < e[a].length; o++) {
-      const i = n[a][o], h = i <= p[a] ? 1 : Math.exp(-((i - p[a]) / t[a]));
-      f.push(a), l.push(e[a][o]), c.push(h);
+function re(e, t, f) {
+  const a = e.length, { sigmas: s, rhos: u } = Y(t, f), c = [], d = [], i = [];
+  for (let n = 0; n < a; n++)
+    for (let r = 0; r < e[n].length; r++) {
+      const o = t[n][r], h = o <= u[n] ? 1 : Math.exp(-((o - u[n]) / s[n]));
+      c.push(n), d.push(e[n][r]), i.push(h);
     }
   return {
-    rows: new Float32Array(f),
-    cols: new Float32Array(l),
-    vals: new Float32Array(c),
-    nVertices: s
+    rows: new Uint32Array(c),
+    cols: new Uint32Array(d),
+    vals: new Float32Array(i),
+    nVertices: a
   };
 }
-function L(e, n) {
-  const s = e.length, t = new Float32Array(s), p = new Float32Array(s);
-  for (let f = 0; f < s; f++) {
-    const l = e[f];
-    p[f] = l.find((h) => h > 0) ?? 0;
-    let c = 0, a = 1 / 0, o = 1;
-    const i = Math.log2(n);
+function Y(e, t) {
+  const a = e.length, s = new Float32Array(a), u = new Float32Array(a);
+  for (let c = 0; c < a; c++) {
+    const d = e[c];
+    u[c] = d.find((h) => h > 0) ?? 0;
+    let i = 0, n = 1 / 0, r = 1;
+    const o = Math.log2(t);
     for (let h = 0; h < 64; h++) {
-      let d = 0;
-      for (let u = 0; u < l.length; u++)
-        d += Math.exp(-Math.max(0, l[u] - p[f]) / o);
-      if (Math.abs(d - i) < 1e-5) break;
-      d > i ? (a = o, o = (c + a) / 2) : (c = o, o = a === 1 / 0 ? o * 2 : (c + a) / 2);
+      let l = 0;
+      for (let p = 0; p < d.length; p++)
+        l += Math.exp(-Math.max(0, d[p] - u[c]) / r);
+      if (Math.abs(l - o) < 1e-5) break;
+      l > o ? (n = r, r = (i + n) / 2) : (i = r, r = n === 1 / 0 ? r * 2 : (i + n) / 2);
     }
-    t[f] = o;
+    s[c] = r;
   }
-  return { sigmas: t, rhos: p };
+  return { sigmas: s, rhos: u };
 }
-function X(e, n, r, s, t) {
-  const p = /* @__PURE__ */ new Map();
-  for (let a = 0; a < e.length; a++)
-    p.set(e[a] * s + n[a], r[a]);
-  const f = [], l = [], c = [];
-  for (const [a, o] of p) {
-    const i = Math.floor(a / s), h = a % s, d = p.get(h * s + i) ?? 0, u = o + d - o * d, g = o * d;
-    f.push(i), l.push(h), c.push(t * u + (1 - t) * g);
+function oe(e, t, f, a, s) {
+  const u = /* @__PURE__ */ new Map();
+  for (let n = 0; n < e.length; n++)
+    u.set(e[n] * a + t[n], f[n]);
+  const c = [], d = [], i = [];
+  for (const [n, r] of u) {
+    const o = Math.floor(n / a), h = n % a, l = u.get(h * a + o) ?? 0, p = r + l - r * l, g = r * l;
+    c.push(o), d.push(h), i.push(s * p + (1 - s) * g);
   }
   return {
-    rows: new Float32Array(f),
-    cols: new Float32Array(l),
-    vals: new Float32Array(c)
+    rows: new Uint32Array(c),
+    cols: new Uint32Array(d),
+    vals: new Float32Array(i)
   };
 }
-const Z = `// UMAP SGD compute shader — processes one graph edge per GPU thread.
-// Applies attraction forces between connected nodes and repulsion forces
-// against negative samples.
+const ie = `// UMAP SGD compute shader — processes one graph edge per GPU thread.
+// Computes attraction and repulsion forces and accumulates them atomically
+// into a forces buffer. A separate apply-forces pass then updates embeddings,
+// eliminating write-write races on shared vertex positions.
 
 @group(0) @binding(0) var<storage, read>       epochs_per_sample : array<f32>;
 @group(0) @binding(1) var<storage, read>       head              : array<u32>;  // edge source
 @group(0) @binding(2) var<storage, read>       tail              : array<u32>;  // edge target
-@group(0) @binding(3) var<storage, read_write> embedding         : array<f32>;  // [n * nComponents]
+@group(0) @binding(3) var<storage, read>       embedding         : array<f32>;  // [n * nComponents], read-only
 @group(0) @binding(4) var<storage, read_write> epoch_of_next_sample : array<f32>;
 @group(0) @binding(5) var<storage, read_write> epoch_of_next_negative_sample : array<f32>;
 @group(0) @binding(6) var<uniform>             params            : Params;
 @group(0) @binding(7) var<storage, read>       rng_seeds         : array<u32>;  // per-edge seed
+@group(0) @binding(8) var<storage, read_write> forces            : array<atomic<i32>>;  // [n * nComponents]
+
+// Scale factor for quantizing f32 gradients into i32 for atomic accumulation.
+// Gradients are clipped to [-4, 4]. With up to ~1000 edges sharing a vertex
+// the max accumulated magnitude is ~4000, well within i32 range at this scale.
+const FORCE_SCALE : f32 = 65536.0;
 
 struct Params {
   n_edges        : u32,
@@ -106,7 +113,7 @@ struct Params {
   n_components   : u32,
   current_epoch  : u32,
   n_epochs       : u32,
-  alpha          : f32,   // learning rate
+  alpha          : f32,   // learning rate (applied by apply-forces pass)
   a              : f32,
   b              : f32,
   gamma          : f32,   // repulsion strength
@@ -147,7 +154,6 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
 
   let pow_b = pow(dist_sq, params.b);
   // Guard dist_sq == 0: b-1 is negative so pow(0, b-1) = +Inf.
-  // Mirror CPU: use pow_b / dist_sq only when dist_sq > 0, else 0.
   let grad_coeff_attr = select(
     -2.0 * params.a * params.b * (pow_b / dist_sq) / (params.a * pow_b + 1.0),
     0.0,
@@ -157,19 +163,24 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
   for (var d = 0u; d < nc; d++) {
     let diff = embedding[i * nc + d] - embedding[j * nc + d];
     let grad = clip(grad_coeff_attr * diff, -4.0, 4.0);
-    embedding[i * nc + d] += params.alpha * grad;
-    embedding[j * nc + d] -= params.alpha * grad;
+    // Accumulate atomically to avoid write-write races across threads.
+    atomicAdd(&forces[i * nc + d],  i32(grad * FORCE_SCALE));
+    atomicAdd(&forces[j * nc + d], -i32(grad * FORCE_SCALE));
   }
 
   epoch_of_next_sample[edge_idx] += epochs_per_sample[edge_idx];
 
   // --- Repulsion (negative samples) ---
-  let eps = epochs_per_sample[edge_idx];
-  let neg_eps = epoch_of_next_negative_sample[edge_idx];
+  // Compute how many negative samples are overdue relative to current epoch,
+  // matching the Python reference: n_neg = floor((n - next_neg) / eps_per_neg).
+  let epoch_f      = f32(params.current_epoch);
+  let epochs_per_neg = epochs_per_sample[edge_idx] / f32(params.negative_sample_rate);
   var n_neg = 0u;
-  if (neg_eps > 0.0) {
-    n_neg = u32(eps / neg_eps);
+  if (epochs_per_neg > 0.0 && epoch_f >= epoch_of_next_negative_sample[edge_idx]) {
+    n_neg = u32((epoch_f - epoch_of_next_negative_sample[edge_idx]) / epochs_per_neg);
+    epoch_of_next_negative_sample[edge_idx] += f32(n_neg) * epochs_per_neg;
   }
+
   var rng = xorshift(rng_seeds[edge_idx] + params.current_epoch * 6364136223u);
 
   for (var s = 0u; s < n_neg; s++) {
@@ -189,26 +200,73 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     for (var d = 0u; d < nc; d++) {
       let diff = embedding[i * nc + d] - embedding[k * nc + d];
       let grad = clip(grad_coeff_rep * diff, -4.0, 4.0);
-      embedding[i * nc + d] += params.alpha * grad;
+      atomicAdd(&forces[i * nc + d], i32(grad * FORCE_SCALE));
     }
   }
+}
+`, ce = `// Apply-forces shader — second pass of the two-pass GPU SGD.
+//
+// After the SGD pass has atomically accumulated all gradients into the forces
+// buffer, this shader applies each element's accumulated force to the
+// embedding and resets the accumulator to zero for the next epoch.
 
-  epoch_of_next_negative_sample[edge_idx] +=
-    epochs_per_sample[edge_idx] / f32(params.negative_sample_rate);
+@group(0) @binding(0) var<storage, read_write> embedding : array<f32>;
+@group(0) @binding(1) var<storage, read_write> forces    : array<atomic<i32>>;
+@group(0) @binding(2) var<uniform>             params    : ApplyParams;
+
+struct ApplyParams {
+  n_elements : u32,   // nVertices * nComponents
+  alpha      : f32,   // current learning rate
+}
+
+// Must match FORCE_SCALE in sgd.wgsl
+const FORCE_SCALE : f32 = 65536.0;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.n_elements) { return; }
+
+  // atomicExchange atomically reads the accumulated force and resets it to 0.
+  let raw = atomicExchange(&forces[idx], 0);
+  embedding[idx] += params.alpha * f32(raw) / FORCE_SCALE;
 }
 `;
-class W {
+let z = null;
+async function Q() {
+  if (z) return z;
+  if (typeof navigator > "u" || !navigator.gpu)
+    return null;
+  const e = await navigator.gpu.requestAdapter();
+  return e ? (z = await e.requestDevice(), z.lost.then(() => {
+    z = null;
+  }), z) : null;
+}
+function J() {
+  return typeof navigator < "u" && !!navigator.gpu;
+}
+async function he() {
+  return await Q() !== null;
+}
+class X {
   constructor() {
-    G(this, "device");
-    G(this, "pipeline");
+    C(this, "device");
+    C(this, "sgdPipeline");
+    C(this, "applyForcesPipeline");
   }
   async init() {
-    const n = await navigator.gpu.requestAdapter();
-    if (!n) throw new Error("WebGPU not supported");
-    this.device = await n.requestDevice(), this.pipeline = this.device.createComputePipeline({
+    const t = await Q();
+    if (!t) throw new Error("WebGPU not supported");
+    this.device = t, this.sgdPipeline = this.device.createComputePipeline({
+      layout: "auto",
+      compute: {
+        module: this.device.createShaderModule({ code: ie }),
+        entryPoint: "main"
+      }
+    }), this.applyForcesPipeline = this.device.createComputePipeline({
       layout: "auto",
       compute: {
-        module: this.device.createShaderModule({ code: Z }),
+        module: this.device.createShaderModule({ code: ce }),
         entryPoint: "main"
       }
     });
@@ -226,218 +284,254 @@ class W {
    * @param params      - UMAP curve parameters and repulsion settings
    * @returns Optimized embedding as Float32Array
    */
-  async optimize(n, r, s, t, p, f, l, c, a) {
-    const { device: o } = this, i = r.length, h = this.makeBuffer(
-      n,
+  async optimize(t, f, a, s, u, c, d, i, n) {
+    const { device: r } = this, o = f.length, h = u * c, l = this.makeBuffer(
+      t,
       GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
-    ), d = this.makeBuffer(r, GPUBufferUsage.STORAGE), u = this.makeBuffer(s, GPUBufferUsage.STORAGE), g = this.makeBuffer(t, GPUBufferUsage.STORAGE), m = new Float32Array(i).fill(0), w = this.makeBuffer(m, GPUBufferUsage.STORAGE), b = new Float32Array(i);
-    for (let _ = 0; _ < i; _++)
-      b[_] = t[_] / c.negativeSampleRate;
-    const y = this.makeBuffer(b, GPUBufferUsage.STORAGE), v = new Uint32Array(i);
-    for (let _ = 0; _ < i; _++)
-      v[_] = Math.random() * 4294967295 | 0;
-    const x = this.makeBuffer(v, GPUBufferUsage.STORAGE), B = o.createBuffer({
+    ), p = this.makeBuffer(f, GPUBufferUsage.STORAGE), g = this.makeBuffer(a, GPUBufferUsage.STORAGE), _ = this.makeBuffer(s, GPUBufferUsage.STORAGE), m = new Float32Array(s), y = this.makeBuffer(m, GPUBufferUsage.STORAGE), b = new Float32Array(o);
+    for (let A = 0; A < o; A++)
+      b[A] = s[A] / i.negativeSampleRate;
+    const x = this.makeBuffer(b, GPUBufferUsage.STORAGE), v = new Uint32Array(o);
+    for (let A = 0; A < o; A++)
+      v[A] = Math.random() * 4294967295 | 0;
+    const P = this.makeBuffer(v, GPUBufferUsage.STORAGE), G = r.createBuffer({
+      size: h * 4,
+      usage: GPUBufferUsage.STORAGE,
+      mappedAtCreation: !0
+    });
+    new Int32Array(G.getMappedRange()).fill(0), G.unmap();
+    const U = r.createBuffer({
       size: 40,
       usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    }), F = r.createBuffer({
+      size: 16,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    }), N = r.createBindGroup({
+      layout: this.sgdPipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: _ } },
+        { binding: 1, resource: { buffer: p } },
+        { binding: 2, resource: { buffer: g } },
+        { binding: 3, resource: { buffer: l } },
+        { binding: 4, resource: { buffer: y } },
+        { binding: 5, resource: { buffer: x } },
+        { binding: 6, resource: { buffer: U } },
+        { binding: 7, resource: { buffer: P } },
+        { binding: 8, resource: { buffer: G } }
+      ]
+    }), M = r.createBindGroup({
+      layout: this.applyForcesPipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: l } },
+        { binding: 1, resource: { buffer: G } },
+        { binding: 2, resource: { buffer: F } }
+      ]
     });
-    for (let _ = 0; _ < l; _++) {
-      const F = 1 - _ / l, A = new ArrayBuffer(40), M = new Uint32Array(A), N = new Float32Array(A);
-      M[0] = i, M[1] = p, M[2] = f, M[3] = _, M[4] = l, N[5] = F, N[6] = c.a, N[7] = c.b, N[8] = c.gamma, M[9] = c.negativeSampleRate, o.queue.writeBuffer(B, 0, A);
-      const S = o.createBindGroup({
-        layout: this.pipeline.getBindGroupLayout(0),
-        entries: [
-          { binding: 0, resource: { buffer: g } },
-          { binding: 1, resource: { buffer: d } },
-          { binding: 2, resource: { buffer: u } },
-          { binding: 3, resource: { buffer: h } },
-          { binding: 4, resource: { buffer: w } },
-          { binding: 5, resource: { buffer: y } },
-          { binding: 6, resource: { buffer: B } },
-          { binding: 7, resource: { buffer: x } }
-        ]
-      }), O = o.createCommandEncoder(), U = O.beginComputePass();
-      U.setPipeline(this.pipeline), U.setBindGroup(0, S), U.dispatchWorkgroups(Math.ceil(i / 256)), U.end(), o.queue.submit([O.finish()]), _ % 10 === 0 && (await o.queue.onSubmittedWorkDone(), a == null || a(_, l));
+    for (let A = 0; A < d; A++) {
+      const B = 1 - A / d, O = new ArrayBuffer(40), S = new Uint32Array(O), k = new Float32Array(O);
+      S[0] = o, S[1] = u, S[2] = c, S[3] = A, S[4] = d, k[5] = B, k[6] = i.a, k[7] = i.b, k[8] = i.gamma, S[9] = i.negativeSampleRate, r.queue.writeBuffer(U, 0, O);
+      const D = new ArrayBuffer(16), $ = new Uint32Array(D), ee = new Float32Array(D);
+      $[0] = h, ee[1] = B, r.queue.writeBuffer(F, 0, D);
+      const T = r.createCommandEncoder(), q = T.beginComputePass();
+      q.setPipeline(this.sgdPipeline), q.setBindGroup(0, N), q.dispatchWorkgroups(Math.ceil(o / 256)), q.end();
+      const I = T.beginComputePass();
+      I.setPipeline(this.applyForcesPipeline), I.setBindGroup(0, M), I.dispatchWorkgroups(Math.ceil(h / 256)), I.end(), r.queue.submit([T.finish()]), A % 10 === 0 && (await r.queue.onSubmittedWorkDone(), n == null || n(A, d));
     }
-    const E = o.createBuffer({
-      size: n.byteLength,
+    const E = r.createBuffer({
+      size: t.byteLength,
       usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
-    }), R = o.createCommandEncoder();
-    R.copyBufferToBuffer(h, 0, E, 0, n.byteLength), o.queue.submit([R.finish()]), await E.mapAsync(GPUMapMode.READ);
-    const k = new Float32Array(E.getMappedRange().slice(0));
-    return E.unmap(), h.destroy(), d.destroy(), u.destroy(), g.destroy(), w.destroy(), y.destroy(), x.destroy(), B.destroy(), E.destroy(), k;
+    }), w = r.createCommandEncoder();
+    w.copyBufferToBuffer(l, 0, E, 0, t.byteLength), r.queue.submit([w.finish()]), await E.mapAsync(GPUMapMode.READ);
+    const R = new Float32Array(E.getMappedRange().slice(0));
+    return E.unmap(), l.destroy(), p.destroy(), g.destroy(), _.destroy(), y.destroy(), x.destroy(), P.destroy(), G.destroy(), U.destroy(), F.destroy(), E.destroy(), R;
   }
-  makeBuffer(n, r) {
-    const s = this.device.createBuffer({
-      size: n.byteLength,
-      usage: r,
+  makeBuffer(t, f) {
+    const a = this.device.createBuffer({
+      size: t.byteLength,
+      usage: f,
       mappedAtCreation: !0
     });
-    return n instanceof Float32Array ? new Float32Array(s.getMappedRange()).set(n) : new Uint32Array(s.getMappedRange()).set(n), s.unmap(), s;
+    return t instanceof Float32Array ? new Float32Array(a.getMappedRange()).set(t) : new Uint32Array(a.getMappedRange()).set(t), a.unmap(), a;
   }
 }
-function q(e) {
+function j(e) {
   return Math.max(-4, Math.min(4, e));
 }
-function z(e, n, r, s, t, p, f, l) {
-  const { a: c, b: a, gamma: o = 1, negativeSampleRate: i = 5 } = f, h = n.rows.length, d = new Uint32Array(n.rows), u = new Uint32Array(n.cols), g = new Float32Array(h).fill(0), m = new Float32Array(h);
-  for (let w = 0; w < h; w++)
-    m[w] = r[w] / i;
-  for (let w = 0; w < p; w++) {
-    l == null || l(w, p);
-    const b = 1 - w / p;
-    for (let y = 0; y < h; y++) {
-      if (g[y] > w) continue;
-      const v = d[y], x = u[y];
-      let B = 0;
-      for (let _ = 0; _ < t; _++) {
-        const F = e[v * t + _] - e[x * t + _];
-        B += F * F;
+function L(e, t, f, a, s, u, c, d) {
+  const { a: i, b: n, gamma: r = 1, negativeSampleRate: o = 5 } = c, h = t.rows.length, l = new Uint32Array(t.rows), p = new Uint32Array(t.cols), g = new Float32Array(f), _ = new Float32Array(h);
+  for (let m = 0; m < h; m++)
+    _[m] = f[m] / o;
+  for (let m = 0; m < u; m++) {
+    d == null || d(m, u);
+    const y = 1 - m / u;
+    for (let b = 0; b < h; b++) {
+      if (g[b] > m) continue;
+      const x = l[b], v = p[b];
+      let P = 0;
+      for (let M = 0; M < s; M++) {
+        const E = e[x * s + M] - e[v * s + M];
+        P += E * E;
       }
-      const E = Math.pow(B, a), R = -2 * c * a * (B > 0 ? E / B : 0) / (c * E + 1);
-      for (let _ = 0; _ < t; _++) {
-        const F = e[v * t + _] - e[x * t + _], A = q(R * F);
-        e[v * t + _] += b * A, e[x * t + _] -= b * A;
+      const G = Math.pow(P, n), U = -2 * i * n * (P > 0 ? G / P : 0) / (i * G + 1);
+      for (let M = 0; M < s; M++) {
+        const E = e[x * s + M] - e[v * s + M], w = j(U * E);
+        e[x * s + M] += y * w, e[v * s + M] -= y * w;
       }
-      g[y] += r[y];
-      const k = m[y] > 0 ? Math.floor(r[y] / m[y]) : 0;
-      for (let _ = 0; _ < k; _++) {
-        const F = Math.floor(Math.random() * s);
-        if (F === v) continue;
-        let A = 0;
-        for (let S = 0; S < t; S++) {
-          const O = e[v * t + S] - e[F * t + S];
-          A += O * O;
+      g[b] += f[b];
+      const F = f[b] / o, N = Math.max(0, Math.floor(
+        (m - _[b]) / F
+      ));
+      _[b] += N * F;
+      for (let M = 0; M < N; M++) {
+        const E = Math.floor(Math.random() * a);
+        if (E === x) continue;
+        let w = 0;
+        for (let B = 0; B < s; B++) {
+          const O = e[x * s + B] - e[E * s + B];
+          w += O * O;
         }
-        const M = Math.pow(A, a), N = 2 * o * a / ((1e-3 + A) * (c * M + 1));
-        for (let S = 0; S < t; S++) {
-          const O = e[v * t + S] - e[F * t + S], U = q(N * O);
-          e[v * t + S] += b * U;
+        const R = Math.pow(w, n), A = 2 * r * n / ((1e-3 + w) * (i * R + 1));
+        for (let B = 0; B < s; B++) {
+          const O = e[x * s + B] - e[E * s + B], S = j(A * O);
+          e[x * s + B] += y * S;
         }
       }
-      m[y] += r[y] / i;
     }
   }
   return e;
 }
-function $(e, n, r, s, t, p, f, l, c, a) {
-  const { a: o, b: i, gamma: h = 1, negativeSampleRate: d = 5 } = c, u = r.rows.length, g = new Uint32Array(r.rows), m = new Uint32Array(r.cols), w = new Float32Array(u).fill(0), b = new Float32Array(u);
-  for (let y = 0; y < u; y++)
-    b[y] = s[y] / d;
-  for (let y = 0; y < l; y++) {
-    const v = 1 - y / l;
-    for (let x = 0; x < u; x++) {
-      if (w[x] > y) continue;
-      const B = g[x], E = m[x];
-      let R = 0;
-      for (let A = 0; A < f; A++) {
-        const M = e[B * f + A] - n[E * f + A];
-        R += M * M;
+function fe(e, t, f, a, s, u, c, d, i, n) {
+  const { a: r, b: o, gamma: h = 1, negativeSampleRate: l = 5 } = i, p = f.rows.length, g = new Uint32Array(f.rows), _ = new Uint32Array(f.cols), m = new Float32Array(a), y = new Float32Array(p);
+  for (let b = 0; b < p; b++)
+    y[b] = a[b] / l;
+  for (let b = 0; b < d; b++) {
+    const x = 1 - b / d;
+    for (let v = 0; v < p; v++) {
+      if (m[v] > b) continue;
+      const P = g[v], G = _[v];
+      let U = 0;
+      for (let w = 0; w < c; w++) {
+        const R = e[P * c + w] - t[G * c + w];
+        U += R * R;
       }
-      const k = Math.pow(R, i), _ = -2 * o * i * (R > 0 ? k / R : 0) / (o * k + 1);
-      for (let A = 0; A < f; A++) {
-        const M = e[B * f + A] - n[E * f + A];
-        e[B * f + A] += v * q(_ * M);
+      const F = Math.pow(U, o), N = -2 * r * o * (U > 0 ? F / U : 0) / (r * F + 1);
+      for (let w = 0; w < c; w++) {
+        const R = e[P * c + w] - t[G * c + w];
+        e[P * c + w] += x * j(N * R);
       }
-      w[x] += s[x];
-      const F = b[x] > 0 ? Math.floor(s[x] / b[x]) : 0;
-      for (let A = 0; A < F; A++) {
-        const M = Math.floor(Math.random() * p);
-        if (M === E) continue;
-        let N = 0;
-        for (let U = 0; U < f; U++) {
-          const P = e[B * f + U] - n[M * f + U];
-          N += P * P;
+      m[v] += a[v];
+      const M = a[v] / l, E = Math.max(0, Math.floor(
+        (b - y[v]) / M
+      ));
+      y[v] += E * M;
+      for (let w = 0; w < E; w++) {
+        const R = Math.floor(Math.random() * u);
+        if (R === G) continue;
+        let A = 0;
+        for (let S = 0; S < c; S++) {
+          const k = e[P * c + S] - t[R * c + S];
+          A += k * k;
         }
-        const S = Math.pow(N, i), O = 2 * h * i / ((1e-3 + N) * (o * S + 1));
-        for (let U = 0; U < f; U++) {
-          const P = e[B * f + U] - n[M * f + U];
-          e[B * f + U] += v * q(O * P);
+        const B = Math.pow(A, o), O = 2 * h * o / ((1e-3 + A) * (r * B + 1));
+        for (let S = 0; S < c; S++) {
+          const k = e[P * c + S] - t[R * c + S];
+          e[P * c + S] += x * j(O * k);
         }
       }
-      b[x] += s[x] / d;
     }
   }
   return e;
 }
-function j() {
-  return typeof navigator < "u" && !!navigator.gpu;
-}
-async function ae(e, n = {}, r) {
+async function pe(e, t = {}, f) {
   const {
-    nComponents: s = 2,
-    nNeighbors: t = 15,
-    minDist: p = 0.1,
-    spread: f = 1,
-    hnsw: l = {}
-  } = n, c = n.nEpochs ?? (e.length > 1e4 ? 200 : 500);
+    nComponents: a = 2,
+    nNeighbors: s = 15,
+    minDist: u = 0.1,
+    spread: c = 1,
+    hnsw: d = {}
+  } = t, i = t.nEpochs ?? (e.length > 1e4 ? 200 : 500);
   console.time("knn");
-  const { indices: a, distances: o } = await Y(e, t, {
-    M: l.M ?? 16,
-    efConstruction: l.efConstruction ?? 200,
-    efSearch: l.efSearch ?? 50
+  const { indices: n, distances: r } = await se(e, s, {
+    M: d.M ?? 16,
+    efConstruction: d.efConstruction ?? 200,
+    efSearch: d.efSearch ?? 50
   });
   console.timeEnd("knn"), console.time("fuzzy-set");
-  const i = D(a, o, t);
+  const o = V(n, r, s);
   console.timeEnd("fuzzy-set");
-  const { a: h, b: d } = K(p, f), u = I(i.vals, c), g = e.length, m = new Float32Array(g * s);
-  for (let b = 0; b < m.length; b++)
-    m[b] = Math.random() * 20 - 10;
+  const { a: h, b: l } = Z(u, c), p = W(o.vals), g = e.length, _ = new Float32Array(g * a);
+  for (let y = 0; y < _.length; y++)
+    _[y] = Math.random() * 20 - 10;
   console.time("sgd");
-  let w;
-  if (j())
+  let m;
+  if (J())
     try {
-      const b = new W();
-      await b.init(), w = await b.optimize(
-        m,
-        new Uint32Array(i.rows),
-        new Uint32Array(i.cols),
-        u,
+      const y = new X();
+      await y.init(), m = await y.optimize(
+        _,
+        new Uint32Array(o.rows),
+        new Uint32Array(o.cols),
+        p,
         g,
-        s,
-        c,
-        { a: h, b: d, gamma: 1, negativeSampleRate: 5 },
-        r
+        a,
+        i,
+        { a: h, b: l, gamma: 1, negativeSampleRate: 5 },
+        f
       );
-    } catch (b) {
-      console.warn("WebGPU SGD failed, falling back to CPU:", b), w = z(m, i, u, g, s, c, { a: h, b: d }, r);
+    } catch (y) {
+      console.warn("WebGPU SGD failed, falling back to CPU:", y), m = L(_, o, p, g, a, i, { a: h, b: l }, f);
     }
   else
-    w = z(m, i, u, g, s, c, { a: h, b: d }, r);
-  return console.timeEnd("sgd"), w;
-}
-function K(e, n) {
-  if (Math.abs(n - 1) < 1e-6 && Math.abs(e - 0.1) < 1e-6)
-    return { a: 1.9292, b: 0.7915 };
-  if (Math.abs(n - 1) < 1e-6 && Math.abs(e - 0) < 1e-6)
-    return { a: 1.8956, b: 0.8006 };
-  if (Math.abs(n - 1) < 1e-6 && Math.abs(e - 0.5) < 1e-6)
-    return { a: 1.5769, b: 0.8951 };
-  const r = ee(e, n);
-  return { a: ne(e, n, r), b: r };
+    m = L(_, o, p, g, a, i, { a: h, b: l }, f);
+  return console.timeEnd("sgd"), m;
 }
-function ee(e, n) {
-  return 1 / (n * 1.2);
+function Z(e, t) {
+  return Math.abs(t - 1) < 1e-6 && Math.abs(e - 0.1) < 1e-6 ? { a: 1.9292, b: 0.7915 } : Math.abs(t - 1) < 1e-6 && Math.abs(e - 0) < 1e-6 ? { a: 1.8956, b: 0.8006 } : Math.abs(t - 1) < 1e-6 && Math.abs(e - 0.5) < 1e-6 ? { a: 1.5769, b: 0.8951 } : de(e, t);
 }
-function ne(e, n, r) {
-  return e < 1e-6 ? 1.8956 : (1 / (1 + 1e-3) - 1) / -Math.pow(e, 2 * r);
+function de(e, t) {
+  const a = [], s = [];
+  for (let i = 0; i < 299; i++) {
+    const n = (i + 1) / 299 * t * 3;
+    a.push(n), s.push(n < e ? 1 : Math.exp(-(n - e) / t));
+  }
+  let u = 1, c = 1, d = 1e-3;
+  for (let i = 0; i < 500; i++) {
+    let n = 0, r = 0, o = 0, h = 0, l = 0, p = 0;
+    for (let U = 0; U < 299; U++) {
+      const F = a[U], N = Math.pow(F, 2 * c), M = 1 + u * N, w = 1 / M - s[U];
+      p += w * w;
+      const R = M * M, A = -N / R, B = F > 0 ? -2 * Math.log(F) * u * N / R : 0;
+      n += A * w, r += B * w, o += A * A, h += B * B, l += A * B;
+    }
+    const g = o + d, _ = h + d, m = l, y = g * _ - m * m;
+    if (Math.abs(y) < 1e-20) break;
+    const b = -(_ * n - m * r) / y, x = -(g * r - m * n) / y, v = Math.max(1e-4, u + b), P = Math.max(1e-4, c + x);
+    let G = 0;
+    for (let U = 0; U < 299; U++) {
+      const F = Math.pow(a[U], 2 * P), N = 1 / (1 + v * F) - s[U];
+      G += N * N;
+    }
+    if (G < p ? (u = v, c = P, d = Math.max(1e-10, d / 10)) : d = Math.min(1e10, d * 10), Math.abs(b) < 1e-8 && Math.abs(x) < 1e-8) break;
+  }
+  return { a: u, b: c };
 }
-class re {
-  constructor(n = {}) {
-    G(this, "_nComponents");
-    G(this, "_nNeighbors");
-    G(this, "_minDist");
-    G(this, "_spread");
-    G(this, "_nEpochs");
-    G(this, "_hnswOpts");
-    G(this, "_a");
-    G(this, "_b");
+class ge {
+  constructor(t = {}) {
+    C(this, "_nComponents");
+    C(this, "_nNeighbors");
+    C(this, "_minDist");
+    C(this, "_spread");
+    C(this, "_nEpochs");
+    C(this, "_hnswOpts");
+    C(this, "_a");
+    C(this, "_b");
     /** The low-dimensional embedding produced by the last fit() call. */
-    G(this, "embedding", null);
-    G(this, "_hnswIndex", null);
-    G(this, "_nTrain", 0);
-    this._nComponents = n.nComponents ?? 2, this._nNeighbors = n.nNeighbors ?? 15, this._minDist = n.minDist ?? 0.1, this._spread = n.spread ?? 1, this._nEpochs = n.nEpochs, this._hnswOpts = n.hnsw ?? {};
-    const { a: r, b: s } = K(this._minDist, this._spread);
-    this._a = r, this._b = s;
+    C(this, "embedding", null);
+    C(this, "_hnswIndex", null);
+    C(this, "_nTrain", 0);
+    this._nComponents = t.nComponents ?? 2, this._nNeighbors = t.nNeighbors ?? 15, this._minDist = t.minDist ?? 0.1, this._spread = t.spread ?? 1, this._nEpochs = t.nEpochs, this._hnswOpts = t.hnsw ?? {};
+    const { a: f, b: a } = Z(this._minDist, this._spread);
+    this._a = f, this._b = a;
   }
   /**
    * Train UMAP on `vectors`.
@@ -445,45 +539,45 @@ class re {
    * index so that transform() can project new points later.
    * Returns `this` for chaining.
    */
-  async fit(n, r) {
-    const s = n.length, t = this._nEpochs ?? (s > 1e4 ? 200 : 500), { M: p = 16, efConstruction: f = 200, efSearch: l = 50 } = this._hnswOpts;
+  async fit(t, f) {
+    const a = t.length, s = this._nEpochs ?? (a > 1e4 ? 200 : 500), { M: u = 16, efConstruction: c = 200, efSearch: d = 50 } = this._hnswOpts;
     console.time("knn");
-    const { knn: c, index: a } = await Q(n, this._nNeighbors, {
-      M: p,
-      efConstruction: f,
-      efSearch: l
+    const { knn: i, index: n } = await ae(t, this._nNeighbors, {
+      M: u,
+      efConstruction: c,
+      efSearch: d
     });
-    this._hnswIndex = a, this._nTrain = s, console.timeEnd("knn"), console.time("fuzzy-set");
-    const o = D(c.indices, c.distances, this._nNeighbors);
+    this._hnswIndex = n, this._nTrain = a, console.timeEnd("knn"), console.time("fuzzy-set");
+    const r = V(i.indices, i.distances, this._nNeighbors);
     console.timeEnd("fuzzy-set");
-    const i = I(o.vals, t), h = new Float32Array(s * this._nComponents);
-    for (let d = 0; d < h.length; d++)
-      h[d] = Math.random() * 20 - 10;
-    if (console.time("sgd"), j())
+    const o = W(r.vals), h = new Float32Array(a * this._nComponents);
+    for (let l = 0; l < h.length; l++)
+      h[l] = Math.random() * 20 - 10;
+    if (console.time("sgd"), J())
       try {
-        const d = new W();
-        await d.init(), this.embedding = await d.optimize(
+        const l = new X();
+        await l.init(), this.embedding = await l.optimize(
           h,
-          new Uint32Array(o.rows),
-          new Uint32Array(o.cols),
-          i,
-          s,
+          new Uint32Array(r.rows),
+          new Uint32Array(r.cols),
+          o,
+          a,
           this._nComponents,
-          t,
+          s,
           { a: this._a, b: this._b, gamma: 1, negativeSampleRate: 5 },
-          r
+          f
         );
-      } catch (d) {
-        console.warn("WebGPU SGD failed, falling back to CPU:", d), this.embedding = z(h, o, i, s, this._nComponents, t, {
+      } catch (l) {
+        console.warn("WebGPU SGD failed, falling back to CPU:", l), this.embedding = L(h, r, o, a, this._nComponents, s, {
           a: this._a,
           b: this._b
-        }, r);
+        }, f);
       }
     else
-      this.embedding = z(h, o, i, s, this._nComponents, t, {
+      this.embedding = L(h, r, o, a, this._nComponents, s, {
         a: this._a,
         b: this._b
-      }, r);
+      }, f);
     return console.timeEnd("sgd"), this;
   }
   /**
@@ -497,35 +591,35 @@ class re {
    *   returned embedding to [0, 1].  The stored training embedding is never
    *   mutated.  Defaults to `false`.
    */
-  async transform(n, r = !1) {
+  async transform(t, f = !1) {
     if (!this._hnswIndex || !this.embedding)
       throw new Error("UMAP.transform() must be called after fit()");
-    const s = n.length, t = this._nEpochs ?? (this._nTrain > 1e4 ? 200 : 500), p = Math.max(100, Math.floor(t / 4)), f = this._hnswIndex.searchKnn(n, this._nNeighbors), l = J(f.indices, f.distances, this._nNeighbors), c = new Uint32Array(l.rows), a = new Uint32Array(l.cols), o = new Float32Array(s), i = new Float32Array(s * this._nComponents);
-    for (let u = 0; u < c.length; u++) {
-      const g = c[u], m = a[u], w = l.vals[u];
-      o[g] += w;
-      for (let b = 0; b < this._nComponents; b++)
-        i[g * this._nComponents + b] += w * this.embedding[m * this._nComponents + b];
+    const a = t.length, s = this._nEpochs ?? (this._nTrain > 1e4 ? 200 : 500), u = Math.max(100, Math.floor(s / 4)), c = this._hnswIndex.searchKnn(t, this._nNeighbors), d = re(c.indices, c.distances, this._nNeighbors), i = new Uint32Array(d.rows), n = new Uint32Array(d.cols), r = new Float32Array(a), o = new Float32Array(a * this._nComponents);
+    for (let p = 0; p < i.length; p++) {
+      const g = i[p], _ = n[p], m = d.vals[p];
+      r[g] += m;
+      for (let y = 0; y < this._nComponents; y++)
+        o[g * this._nComponents + y] += m * this.embedding[_ * this._nComponents + y];
     }
-    for (let u = 0; u < s; u++)
-      if (o[u] > 0)
+    for (let p = 0; p < a; p++)
+      if (r[p] > 0)
         for (let g = 0; g < this._nComponents; g++)
-          i[u * this._nComponents + g] /= o[u];
+          o[p * this._nComponents + g] /= r[p];
       else
         for (let g = 0; g < this._nComponents; g++)
-          i[u * this._nComponents + g] = Math.random() * 20 - 10;
-    const h = I(l.vals, p), d = $(
-      i,
+          o[p * this._nComponents + g] = Math.random() * 20 - 10;
+    const h = W(d.vals), l = fe(
+      o,
       this.embedding,
-      l,
+      d,
       h,
-      s,
+      a,
       this._nTrain,
       this._nComponents,
-      p,
+      u,
       { a: this._a, b: this._b }
     );
-    return r ? T(d, s, this._nComponents) : d;
+    return f ? K(l, a, this._nComponents) : l;
   }
   /**
    * Convenience method equivalent to `fit(vectors)` followed by
@@ -536,37 +630,38 @@ class re {
    *   returned embedding to [0, 1].  `this.embedding` is never mutated.
    *   Defaults to `false`.
    */
-  async fit_transform(n, r, s = !1) {
-    return await this.fit(n, r), s ? T(this.embedding, n.length, this._nComponents) : this.embedding;
+  async fit_transform(t, f, a = !1) {
+    return await this.fit(t, f), a ? K(this.embedding, t.length, this._nComponents) : this.embedding;
   }
 }
-function T(e, n, r) {
-  const s = new Float32Array(e.length);
-  for (let t = 0; t < r; t++) {
-    let p = 1 / 0, f = -1 / 0;
-    for (let c = 0; c < n; c++) {
-      const a = e[c * r + t];
-      a < p && (p = a), a > f && (f = a);
+function K(e, t, f) {
+  const a = new Float32Array(e.length);
+  for (let s = 0; s < f; s++) {
+    let u = 1 / 0, c = -1 / 0;
+    for (let i = 0; i < t; i++) {
+      const n = e[i * f + s];
+      n < u && (u = n), n > c && (c = n);
     }
-    const l = f - p;
-    for (let c = 0; c < n; c++)
-      s[c * r + t] = l > 0 ? (e[c * r + t] - p) / l : 0;
+    const d = c - u;
+    for (let i = 0; i < t; i++)
+      a[i * f + s] = d > 0 ? (e[i * f + s] - u) / d : 0;
   }
-  return s;
+  return a;
 }
-function I(e, n) {
-  let r = -1 / 0;
-  for (let t = 0; t < e.length; t++)
-    e[t] > r && (r = e[t]);
-  const s = new Float32Array(e.length);
-  for (let t = 0; t < e.length; t++) {
-    const p = e[t] / r;
-    s[t] = p > 0 ? n / p : -1;
+function W(e, t) {
+  let f = -1 / 0;
+  for (let s = 0; s < e.length; s++)
+    e[s] > f && (f = e[s]);
+  const a = new Float32Array(e.length);
+  for (let s = 0; s < e.length; s++) {
+    const u = e[s] / f;
+    a[s] = u > 0 ? 1 / u : -1;
   }
-  return s;
+  return a;
 }
 export {
-  re as UMAP,
-  ae as fit,
-  j as isWebGPUAvailable
+  ge as UMAP,
+  he as checkWebGPUAvailable,
+  pe as fit,
+  J as isWebGPUAvailable
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umap-gpu",
-  "version": "0.2.11",
+  "version": "0.2.14",
   "description": "UMAP with HNSW kNN and WebGPU-accelerated SGD",
   "type": "module",
   "main": "dist/index.js",