Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

vendor/ruvector/crates/ruvector-math-wasm/Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+name = "ruvector-math-wasm"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+description = "WebAssembly bindings for ruvector-math: Optimal Transport, Information Geometry, Product Manifolds"
+keywords = ["wasm", "wasserstein", "vector-search", "optimal-transport"]
+categories = ["wasm", "mathematics"]
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+default = ["console_error_panic_hook"]
+parallel = ["rayon", "wasm-bindgen-rayon"]
+
+[dependencies]
+ruvector-math = { path = "../ruvector-math" }
+wasm-bindgen = { workspace = true }
+js-sys = { workspace = true }
+web-sys = { workspace = true }
+getrandom = { version = "0.2", features = ["js"] }
+serde = { workspace = true }
+serde_json = { workspace = true }
+serde-wasm-bindgen = "0.6"
+console_error_panic_hook = { version = "0.1", optional = true }
+rayon = { workspace = true, optional = true }
+wasm-bindgen-rayon = { version = "1.2", optional = true }
+
+[package.metadata.wasm-pack.profile.release]
+wasm-opt = false
+
+[dev-dependencies]
+wasm-bindgen-test = "0.3"

vendor/ruvector/crates/ruvector-math-wasm/README.md

@@ -0,0 +1,201 @@
+# @ruvector/math-wasm
+
+[![npm version](https://img.shields.io/npm/v/@ruvector/math-wasm.svg)](https://www.npmjs.com/package/@ruvector/math-wasm)
+[![crates.io](https://img.shields.io/crates/v/ruvector-math-wasm.svg)](https://crates.io/crates/ruvector-math-wasm)
+[![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue.svg)](LICENSE)
+[![WASM](https://img.shields.io/badge/target-wasm32-orange.svg)](https://webassembly.org/)
+
+**High-performance WebAssembly bindings for advanced mathematical algorithms in vector search and AI.**
+
+Brings Optimal Transport, Information Geometry, and Product Manifolds to the browser with near-native performance.
+
+## Features
+
+- 🚀 **Optimal Transport** - Sliced Wasserstein, Sinkhorn, Gromov-Wasserstein distances
+- 📐 **Information Geometry** - Fisher Information Matrix, Natural Gradient, K-FAC
+- 🌐 **Product Manifolds** - E^n × H^n × S^n (Euclidean, Hyperbolic, Spherical)
+- ⚡ **SIMD Optimized** - Vectorized operations where available
+- 🔒 **Type-Safe** - Full TypeScript definitions included
+- 📦 **Zero Dependencies** - Pure Rust compiled to WASM
+
+## Installation
+
+```bash
+npm install @ruvector/math-wasm
+# or
+yarn add ruvector-math-wasm
+# or
+pnpm add ruvector-math-wasm
+```
+
+## Quick Start
+
+### Browser (ES Modules)
+
+```javascript
+import init, {
+  WasmSlicedWasserstein,
+  WasmSinkhorn,
+  WasmProductManifold
+} from '@ruvector/math-wasm';
+
+// Initialize WASM module
+await init();
+
+// Compute Sliced Wasserstein distance
+const sw = new WasmSlicedWasserstein(100); // 100 projections
+const source = new Float64Array([0, 0, 1, 1, 2, 2]); // 3 points in 2D
+const target = new Float64Array([0.5, 0.5, 1.5, 1.5, 2.5, 2.5]);
+const distance = sw.distance(source, target, 2);
+console.log(`Wasserstein distance: ${distance}`);
+```
+
+### Node.js
+
+```javascript
+const { WasmSlicedWasserstein } = require('@ruvector/math-wasm');
+
+const sw = new WasmSlicedWasserstein(100);
+const dist = sw.distance(source, target, 2);
+```
+
+## Use Cases
+
+### 1. Distribution Comparison in ML
+
+Compare probability distributions for generative models, anomaly detection, or data drift monitoring.
+
+```javascript
+// Compare embedding distributions
+const sw = new WasmSlicedWasserstein(200).withPower(2); // W2 distance
+
+const trainEmbeddings = new Float64Array(/* ... */);
+const testEmbeddings = new Float64Array(/* ... */);
+
+const drift = sw.distance(trainEmbeddings, testEmbeddings, 768);
+if (drift > threshold) {
+  console.warn('Data drift detected!');
+}
+```
+
+### 2. Semantic Vector Search
+
+Use product manifolds for hierarchical and semantic search.
+
+```javascript
+const manifold = new WasmProductManifold({
+  euclidean_dim: 256,
+  hyperbolic_dim: 128,
+  spherical_dim: 128,
+  curvature_h: -1.0,
+  curvature_s: 1.0
+});
+
+// Compute distance in mixed-curvature space
+const dist = manifold.distance(queryVector, documentVector);
+```
+
+### 3. Optimal Transport for Image Comparison
+
+```javascript
+const sinkhorn = new WasmSinkhorn(0.01, 100); // regularization, max_iters
+
+// Compare image histograms
+const result = sinkhorn.solveTransport(
+  costMatrix,
+  sourceWeights,
+  targetWeights,
+  n, m
+);
+
+console.log(`Transport cost: ${result.cost}`);
+console.log(`Converged: ${result.converged}`);
+```
+
+### 4. Natural Gradient Optimization
+
+```javascript
+const fisher = new WasmFisherInformation(512);
+
+// Compute Fisher Information Matrix
+const fim = fisher.compute(activations);
+
+// Apply natural gradient
+const naturalGrad = fisher.naturalGradientStep(gradient, 0.01);
+```
+
+## API Reference
+
+### Optimal Transport
+
+| Class | Description |
+|-------|-------------|
+| `WasmSlicedWasserstein` | Fast approximation via random projections |
+| `WasmSinkhorn` | Entropy-regularized optimal transport |
+| `WasmGromovWasserstein` | Cross-space structural comparison |
+
+### Information Geometry
+
+| Class | Description |
+|-------|-------------|
+| `WasmFisherInformation` | Fisher Information Matrix computation |
+| `WasmNaturalGradient` | Natural gradient descent optimizer |
+
+### Product Manifolds
+
+| Class | Description |
+|-------|-------------|
+| `WasmProductManifold` | E^n × H^n × S^n mixed-curvature space |
+| `WasmSphericalSpace` | Spherical geometry operations |
+
+## Performance
+
+Benchmarked on M1 MacBook Pro (WASM in Chrome):
+
+| Operation | Dimension | Time |
+|-----------|-----------|------|
+| Sliced Wasserstein (100 proj) | 1000 points × 128D | 2.3ms |
+| Sinkhorn (100 iter) | 500 × 500 | 8.7ms |
+| Product Manifold distance | 512D | 0.04ms |
+
+## TypeScript Support
+
+Full TypeScript definitions are included:
+
+```typescript
+import { WasmSlicedWasserstein, WasmSinkhornConfig } from '@ruvector/math-wasm';
+
+const sw: WasmSlicedWasserstein = new WasmSlicedWasserstein(100);
+const distance: number = sw.distance(source, target, dim);
+```
+
+## Building from Source
+
+```bash
+# Install wasm-pack
+curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+
+# Build
+cd crates/ruvector-math-wasm
+wasm-pack build --target web --release
+
+# Test
+wasm-pack test --headless --chrome
+```
+
+## Related Packages
+
+- [`ruvector-math`](https://crates.io/crates/ruvector-math) - Rust crate (native)
+- [`@ruvector/attention`](https://www.npmjs.com/package/@ruvector/attention) - Attention mechanisms (native Node.js)
+- [`@ruvector/attention-wasm`](https://www.npmjs.com/package/@ruvector/attention-wasm) - Attention mechanisms (WASM)
+
+## License
+
+MIT OR Apache-2.0
+
+## Links
+
+- [GitHub](https://github.com/ruvnet/ruvector)
+- [Documentation](https://docs.rs/ruvector-math-wasm)
+- [crates.io](https://crates.io/crates/ruvector-math-wasm)
+- [npm](https://www.npmjs.com/package/ruvector-math-wasm)

vendor/ruvector/crates/ruvector-math-wasm/src/lib.rs

@@ -0,0 +1,550 @@
+//! WebAssembly bindings for ruvector-math
+//!
+//! This crate provides JavaScript/TypeScript bindings for the advanced
+//! mathematics in ruvector-math, enabling browser-based vector search
+//! with optimal transport, information geometry, and product manifolds.
+
+use ruvector_math::{
+    information_geometry::{FisherInformation, NaturalGradient},
+    optimal_transport::{GromovWasserstein, SinkhornSolver, SlicedWasserstein},
+    product_manifold::ProductManifold,
+    spherical::SphericalSpace,
+};
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(start)]
+pub fn start() {
+    #[cfg(feature = "console_error_panic_hook")]
+    console_error_panic_hook::set_once();
+}
+
+// ============================================================================
+// Optimal Transport
+// ============================================================================
+
+/// Sliced Wasserstein distance calculator for WASM
+#[wasm_bindgen]
+pub struct WasmSlicedWasserstein {
+    inner: SlicedWasserstein,
+}
+
+#[wasm_bindgen]
+impl WasmSlicedWasserstein {
+    /// Create a new Sliced Wasserstein calculator
+    ///
+    /// @param num_projections - Number of random 1D projections (100-1000 typical)
+    #[wasm_bindgen(constructor)]
+    pub fn new(num_projections: usize) -> Self {
+        Self {
+            inner: SlicedWasserstein::new(num_projections),
+        }
+    }
+
+    /// Set Wasserstein power (1 for W1, 2 for W2)
+    #[wasm_bindgen(js_name = withPower)]
+    pub fn with_power(self, p: f64) -> Self {
+        Self {
+            inner: self.inner.with_power(p),
+        }
+    }
+
+    /// Set random seed for reproducibility
+    #[wasm_bindgen(js_name = withSeed)]
+    pub fn with_seed(self, seed: u64) -> Self {
+        Self {
+            inner: self.inner.with_seed(seed),
+        }
+    }
+
+    /// Compute distance between two point clouds
+    ///
+    /// @param source - Source points as flat array [x1, y1, z1, x2, y2, z2, ...]
+    /// @param target - Target points as flat array
+    /// @param dim - Dimension of each point
+    #[wasm_bindgen]
+    pub fn distance(&self, source: &[f64], target: &[f64], dim: usize) -> f64 {
+        use ruvector_math::optimal_transport::OptimalTransport;
+
+        let source_points = to_points(source, dim);
+        let target_points = to_points(target, dim);
+
+        self.inner.distance(&source_points, &target_points)
+    }
+
+    /// Compute weighted distance
+    #[wasm_bindgen(js_name = weightedDistance)]
+    pub fn weighted_distance(
+        &self,
+        source: &[f64],
+        source_weights: &[f64],
+        target: &[f64],
+        target_weights: &[f64],
+        dim: usize,
+    ) -> f64 {
+        use ruvector_math::optimal_transport::OptimalTransport;
+
+        let source_points = to_points(source, dim);
+        let target_points = to_points(target, dim);
+
+        self.inner.weighted_distance(
+            &source_points,
+            source_weights,
+            &target_points,
+            target_weights,
+        )
+    }
+}
+
+/// Sinkhorn optimal transport solver for WASM
+#[wasm_bindgen]
+pub struct WasmSinkhorn {
+    inner: SinkhornSolver,
+}
+
+#[wasm_bindgen]
+impl WasmSinkhorn {
+    /// Create a new Sinkhorn solver
+    ///
+    /// @param regularization - Entropy regularization (0.01-0.1 typical)
+    /// @param max_iterations - Maximum iterations (100-1000 typical)
+    #[wasm_bindgen(constructor)]
+    pub fn new(regularization: f64, max_iterations: usize) -> Self {
+        Self {
+            inner: SinkhornSolver::new(regularization, max_iterations),
+        }
+    }
+
+    /// Compute transport cost between point clouds
+    #[wasm_bindgen]
+    pub fn distance(&self, source: &[f64], target: &[f64], dim: usize) -> Result<f64, JsError> {
+        let source_points = to_points(source, dim);
+        let target_points = to_points(target, dim);
+
+        self.inner
+            .distance(&source_points, &target_points)
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+
+    /// Solve optimal transport and return transport plan
+    #[wasm_bindgen(js_name = solveTransport)]
+    pub fn solve_transport(
+        &self,
+        cost_matrix: &[f64],
+        source_weights: &[f64],
+        target_weights: &[f64],
+        n: usize,
+        m: usize,
+    ) -> Result<TransportResult, JsError> {
+        let cost = to_matrix(cost_matrix, n, m);
+
+        let result = self
+            .inner
+            .solve(&cost, source_weights, target_weights)
+            .map_err(|e| JsError::new(&e.to_string()))?;
+
+        Ok(TransportResult {
+            plan: result.plan.into_iter().flatten().collect(),
+            cost: result.cost,
+            iterations: result.iterations,
+            converged: result.converged,
+        })
+    }
+}
+
+/// Result of Sinkhorn transport computation
+#[wasm_bindgen]
+pub struct TransportResult {
+    plan: Vec<f64>,
+    cost: f64,
+    iterations: usize,
+    converged: bool,
+}
+
+#[wasm_bindgen]
+impl TransportResult {
+    /// Get transport plan as flat array
+    #[wasm_bindgen(getter)]
+    pub fn plan(&self) -> Vec<f64> {
+        self.plan.clone()
+    }
+
+    /// Get total transport cost
+    #[wasm_bindgen(getter)]
+    pub fn cost(&self) -> f64 {
+        self.cost
+    }
+
+    /// Get number of iterations
+    #[wasm_bindgen(getter)]
+    pub fn iterations(&self) -> usize {
+        self.iterations
+    }
+
+    /// Whether algorithm converged
+    #[wasm_bindgen(getter)]
+    pub fn converged(&self) -> bool {
+        self.converged
+    }
+}
+
+/// Gromov-Wasserstein distance for WASM
+#[wasm_bindgen]
+pub struct WasmGromovWasserstein {
+    inner: GromovWasserstein,
+}
+
+#[wasm_bindgen]
+impl WasmGromovWasserstein {
+    /// Create a new Gromov-Wasserstein calculator
+    #[wasm_bindgen(constructor)]
+    pub fn new(regularization: f64) -> Self {
+        Self {
+            inner: GromovWasserstein::new(regularization),
+        }
+    }
+
+    /// Compute GW distance between point clouds
+    #[wasm_bindgen]
+    pub fn distance(&self, source: &[f64], target: &[f64], dim: usize) -> Result<f64, JsError> {
+        let source_points = to_points(source, dim);
+        let target_points = to_points(target, dim);
+
+        self.inner
+            .distance(&source_points, &target_points)
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+}
+
+// ============================================================================
+// Information Geometry
+// ============================================================================
+
+/// Fisher Information for WASM
+#[wasm_bindgen]
+pub struct WasmFisherInformation {
+    inner: FisherInformation,
+}
+
+#[wasm_bindgen]
+impl WasmFisherInformation {
+    /// Create a new Fisher Information calculator
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        Self {
+            inner: FisherInformation::new(),
+        }
+    }
+
+    /// Set damping factor
+    #[wasm_bindgen(js_name = withDamping)]
+    pub fn with_damping(self, damping: f64) -> Self {
+        Self {
+            inner: self.inner.with_damping(damping),
+        }
+    }
+
+    /// Compute diagonal FIM from gradient samples
+    #[wasm_bindgen(js_name = diagonalFim)]
+    pub fn diagonal_fim(
+        &self,
+        gradients: &[f64],
+        _num_samples: usize,
+        dim: usize,
+    ) -> Result<Vec<f64>, JsError> {
+        let grads = to_points(gradients, dim);
+        self.inner
+            .diagonal_fim(&grads)
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+
+    /// Compute natural gradient
+    #[wasm_bindgen(js_name = naturalGradient)]
+    pub fn natural_gradient(&self, fim_diag: &[f64], gradient: &[f64], damping: f64) -> Vec<f64> {
+        gradient
+            .iter()
+            .zip(fim_diag.iter())
+            .map(|(&g, &f)| g / (f + damping))
+            .collect()
+    }
+}
+
+/// Natural Gradient optimizer for WASM
+#[wasm_bindgen]
+pub struct WasmNaturalGradient {
+    inner: NaturalGradient,
+}
+
+#[wasm_bindgen]
+impl WasmNaturalGradient {
+    /// Create a new Natural Gradient optimizer
+    #[wasm_bindgen(constructor)]
+    pub fn new(learning_rate: f64) -> Self {
+        Self {
+            inner: NaturalGradient::new(learning_rate),
+        }
+    }
+
+    /// Set damping factor
+    #[wasm_bindgen(js_name = withDamping)]
+    pub fn with_damping(self, damping: f64) -> Self {
+        Self {
+            inner: self.inner.with_damping(damping),
+        }
+    }
+
+    /// Use diagonal approximation
+    #[wasm_bindgen(js_name = withDiagonal)]
+    pub fn with_diagonal(self, use_diagonal: bool) -> Self {
+        Self {
+            inner: self.inner.with_diagonal(use_diagonal),
+        }
+    }
+
+    /// Compute update step
+    #[wasm_bindgen]
+    pub fn step(
+        &mut self,
+        gradient: &[f64],
+        gradient_samples: Option<Vec<f64>>,
+        dim: usize,
+    ) -> Result<Vec<f64>, JsError> {
+        let samples = gradient_samples.map(|s| to_points(&s, dim));
+
+        self.inner
+            .step(gradient, samples.as_deref())
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+
+    /// Reset optimizer state
+    #[wasm_bindgen]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
+// ============================================================================
+// Spherical Geometry
+// ============================================================================
+
+/// Spherical space operations for WASM
+#[wasm_bindgen]
+pub struct WasmSphericalSpace {
+    inner: SphericalSpace,
+}
+
+#[wasm_bindgen]
+impl WasmSphericalSpace {
+    /// Create a new spherical space S^{n-1} embedded in R^n
+    #[wasm_bindgen(constructor)]
+    pub fn new(ambient_dim: usize) -> Self {
+        Self {
+            inner: SphericalSpace::new(ambient_dim),
+        }
+    }
+
+    /// Get ambient dimension
+    #[wasm_bindgen(getter, js_name = ambientDim)]
+    pub fn ambient_dim(&self) -> usize {
+        self.inner.ambient_dim()
+    }
+
+    /// Project point onto sphere
+    #[wasm_bindgen]
+    pub fn project(&self, point: &[f64]) -> Result<Vec<f64>, JsError> {
+        self.inner
+            .project(point)
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+
+    /// Geodesic distance on sphere
+    #[wasm_bindgen]
+    pub fn distance(&self, x: &[f64], y: &[f64]) -> Result<f64, JsError> {
+        self.inner
+            .distance(x, y)
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+
+    /// Exponential map: move from x in direction v
+    #[wasm_bindgen(js_name = expMap)]
+    pub fn exp_map(&self, x: &[f64], v: &[f64]) -> Result<Vec<f64>, JsError> {
+        self.inner
+            .exp_map(x, v)
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+
+    /// Logarithmic map: tangent vector at x pointing toward y
+    #[wasm_bindgen(js_name = logMap)]
+    pub fn log_map(&self, x: &[f64], y: &[f64]) -> Result<Vec<f64>, JsError> {
+        self.inner
+            .log_map(x, y)
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+
+    /// Geodesic interpolation at fraction t
+    #[wasm_bindgen]
+    pub fn geodesic(&self, x: &[f64], y: &[f64], t: f64) -> Result<Vec<f64>, JsError> {
+        self.inner
+            .geodesic(x, y, t)
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+
+    /// Fréchet mean of points
+    #[wasm_bindgen(js_name = frechetMean)]
+    pub fn frechet_mean(&self, points: &[f64], dim: usize) -> Result<Vec<f64>, JsError> {
+        let pts = to_points(points, dim);
+        self.inner
+            .frechet_mean(&pts, None)
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+}
+
+// ============================================================================
+// Product Manifolds
+// ============================================================================
+
+/// Product manifold for WASM: E^e × H^h × S^s
+#[wasm_bindgen]
+pub struct WasmProductManifold {
+    inner: ProductManifold,
+}
+
+#[wasm_bindgen]
+impl WasmProductManifold {
+    /// Create a new product manifold
+    ///
+    /// @param euclidean_dim - Dimension of Euclidean component
+    /// @param hyperbolic_dim - Dimension of hyperbolic component
+    /// @param spherical_dim - Dimension of spherical component
+    #[wasm_bindgen(constructor)]
+    pub fn new(euclidean_dim: usize, hyperbolic_dim: usize, spherical_dim: usize) -> Self {
+        Self {
+            inner: ProductManifold::new(euclidean_dim, hyperbolic_dim, spherical_dim),
+        }
+    }
+
+    /// Get total dimension
+    #[wasm_bindgen(getter)]
+    pub fn dim(&self) -> usize {
+        self.inner.dim()
+    }
+
+    /// Project point onto manifold
+    #[wasm_bindgen]
+    pub fn project(&self, point: &[f64]) -> Result<Vec<f64>, JsError> {
+        self.inner
+            .project(point)
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+
+    /// Compute distance in product manifold
+    #[wasm_bindgen]
+    pub fn distance(&self, x: &[f64], y: &[f64]) -> Result<f64, JsError> {
+        self.inner
+            .distance(x, y)
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+
+    /// Exponential map
+    #[wasm_bindgen(js_name = expMap)]
+    pub fn exp_map(&self, x: &[f64], v: &[f64]) -> Result<Vec<f64>, JsError> {
+        self.inner
+            .exp_map(x, v)
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+
+    /// Logarithmic map
+    #[wasm_bindgen(js_name = logMap)]
+    pub fn log_map(&self, x: &[f64], y: &[f64]) -> Result<Vec<f64>, JsError> {
+        self.inner
+            .log_map(x, y)
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+
+    /// Geodesic interpolation
+    #[wasm_bindgen]
+    pub fn geodesic(&self, x: &[f64], y: &[f64], t: f64) -> Result<Vec<f64>, JsError> {
+        self.inner
+            .geodesic(x, y, t)
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+
+    /// Fréchet mean
+    #[wasm_bindgen(js_name = frechetMean)]
+    pub fn frechet_mean(&self, points: &[f64], _num_points: usize) -> Result<Vec<f64>, JsError> {
+        let dim = self.inner.dim();
+        let pts = to_points(points, dim);
+        self.inner
+            .frechet_mean(&pts, None)
+            .map_err(|e| JsError::new(&e.to_string()))
+    }
+
+    /// K-nearest neighbors
+    #[wasm_bindgen]
+    pub fn knn(&self, query: &[f64], points: &[f64], k: usize) -> Result<Vec<u32>, JsError> {
+        let dim = self.inner.dim();
+        let pts = to_points(points, dim);
+        let neighbors = self
+            .inner
+            .knn(query, &pts, k)
+            .map_err(|e| JsError::new(&e.to_string()))?;
+
+        Ok(neighbors.into_iter().map(|(idx, _)| idx as u32).collect())
+    }
+
+    /// Pairwise distances
+    #[wasm_bindgen(js_name = pairwiseDistances)]
+    pub fn pairwise_distances(&self, points: &[f64]) -> Result<Vec<f64>, JsError> {
+        let dim = self.inner.dim();
+        let pts = to_points(points, dim);
+        let dists = self
+            .inner
+            .pairwise_distances(&pts)
+            .map_err(|e| JsError::new(&e.to_string()))?;
+
+        Ok(dists.into_iter().flatten().collect())
+    }
+}
+
+// ============================================================================
+// Utility functions
+// ============================================================================
+
+/// Convert flat array to vector of points
+fn to_points(flat: &[f64], dim: usize) -> Vec<Vec<f64>> {
+    flat.chunks(dim).map(|c| c.to_vec()).collect()
+}
+
+/// Convert flat array to matrix
+fn to_matrix(flat: &[f64], rows: usize, cols: usize) -> Vec<Vec<f64>> {
+    flat.chunks(cols).take(rows).map(|c| c.to_vec()).collect()
+}
+
+// ============================================================================
+// TypeScript type definitions
+// ============================================================================
+
+#[wasm_bindgen(typescript_custom_section)]
+const TS_TYPES: &'static str = r#"
+/** Sliced Wasserstein distance for comparing point cloud distributions */
+export interface SlicedWassersteinOptions {
+    numProjections?: number;
+    power?: number;
+    seed?: number;
+}
+
+/** Sinkhorn optimal transport options */
+export interface SinkhornOptions {
+    regularization?: number;
+    maxIterations?: number;
+    threshold?: number;
+}
+
+/** Product manifold configuration */
+export interface ProductManifoldConfig {
+    euclideanDim: number;
+    hyperbolicDim: number;
+    sphericalDim: number;
+    hyperbolicCurvature?: number;
+    sphericalCurvature?: number;
+}
+"#;