@danielsimonjr/mathts-matrix 0.1.8 → 0.1.10

package/dist/{eig-A5GJGSJJ.js → eig-G72TLEBA.js}

@@ -2,7 +2,7 @@ import {
   eig,
   eigvals,
   powerIteration
-} from "./chunk-VCPLE6ED.js";
+} from "./chunk-HT4ZF3LN.js";
 import "./chunk-4VMDO6W2.js";
 export {
   eig,

package/dist/index.d.ts

@@ -629,7 +629,7 @@ declare function isSparseMatrix(value: unknown): value is SparseMatrix;
 /**
  * Backend type identifier
  */
-type BackendType = 'js' | 'wasm' | 'rust-wasm' | 'gpu' | 'parallel';
+type BackendType = 'js' | 'wasm' | 'gpu' | 'parallel';
 /**
  * Backend selection hints
  */
@@ -892,7 +892,7 @@ declare module 'workerpool' {
     debugPortStart?: number;
   }
 
-  export interface WorkerpoolPromise<T, E = unknown> extends Promise<T> {
+  export interface WorkerpoolPromise<T> extends Promise<T> {
     readonly resolved: boolean;
     readonly rejected: boolean;
     readonly pending: boolean;
@@ -1142,13 +1142,14 @@ declare function getCachedFeatures(): WasmFeatures | null;
  *     5. Copy caller data into the buffer
  *     6. `__unpin(buffer)`       — the header now owns the buffer reference
  *
- *   The Rust artifact has no managed runtime and uses a completely different
- *   ABI (camelCase exports, flat-memory raw pointers); for that backend, use
- *   `RustWASMBackend` (from `./RustWASMBackend.ts`).
+ *   The legacy artifact had no managed runtime and used a completely
+ *   different ABI (camelCase exports, flat-memory raw pointers). It was
+ *   retired in Phase 7b; the AssemblyScript binary is now the only WASM
+ *   backend.
  *
- * Naming map (Rust ↔ AssemblyScript) — for cross-backend reference:
+ * Naming map (legacy backend ↔ AssemblyScript) — kept for historical reference:
  *
- *   Op                  Rust (camelCase, flat ptrs)        AS (snake_case, header refs)
+ *   Op                  Legacy (camelCase, flat ptrs)      AS (snake_case, header refs)
  *   ------------------  ---------------------------------  -------------------------------
  *   add                 add(aPtr,bPtr,n,resPtr)            matrix_add(a,b,result)
  *   subtract            subtract(aPtr,bPtr,n,resPtr)       matrix_sub(a,b,result)
@@ -1163,9 +1164,10 @@ declare function getCachedFeatures(): WasmFeatures | null;
  *   norm                simdNormF64(aPtr,n)                array_norm(a)
  *   dot                 dotProduct(aPtr,bPtr,n)            array_dot(a,b)
  *
- *   AssemblyScript has no LU / QR / Cholesky / inverse / determinant exports,
- *   so those operations fall back to the JS implementation. The Rust backend
- *   has them — route those calls through `RustWASMBackend` if you need WASM.
+ *   AssemblyScript also exports LU / QR / Cholesky / inverse / determinant
+ *   (see assembly/src/algebra/decomposition.ts); the methods below dispatch
+ *   to them when present and fall back to the in-process JS implementation
+ *   otherwise.
  *
  * @packageDocumentation
  */
@@ -1185,9 +1187,8 @@ interface WASMBackendConfig {
 /**
  * WASM Backend for matrix operations (AssemblyScript path).
  *
- * For the Rust path use `RustWASMBackend`. Both implement `MatrixBackend`
- * and report different `type` discriminants ('wasm' vs 'rust-wasm') so that
- * `BackendManager` can route operations to the correct one.
+ * This is the sole WASM backend after Phase 7b retired the legacy path; it
+ * reports `type: 'wasm'` and is registered by `register-backends.ts`.
  */
 declare class WASMBackend implements MatrixBackend {
     readonly type: BackendType;
@@ -1212,7 +1213,7 @@ declare class WASMBackend implements MatrixBackend {
     /**
      * Compile + instantiate the AssemblyScript WASM artifact. Each
      * WASMBackend instance owns its own instance — this is intentional so
-     * tests and the Rust backend can coexist in the same process.
+     * tests and multiple backend instances can coexist in the same process.
      */
     private loadAsModule;
     private shouldUseWasm;
@@ -2178,307 +2179,6 @@ declare const gpuMatrixBackend: GPUMatrixBackend;
  */
 declare function createGPUMatrixBackend(config?: GPUMatrixBackendConfig): GPUMatrixBackend;
 
-/**
- * Rust WASM Matrix Backend
- *
- * Implements MatrixBackend using the Rust-compiled WebAssembly module (648 KB).
- * Designed for heavy operations: large matrix multiply (faer), FFT (rustfft),
- * eigendecomposition, sparse algebra, and SIMD-accelerated array operations.
- *
- * This backend sits alongside the existing WASMBackend (AssemblyScript) and
- * is selected by BackendManager for large matrices and heavy operations.
- *
- * Memory model:
- *   Uses a bump allocator on the JS side to write data into WASM linear
- *   memory. The allocator is reset between operations (batch-free pattern).
- *   This avoids the overhead of per-allocation malloc/free calls.
- *
- * @packageDocumentation
- */
-
-/**
- * Rust WASM Backend configuration
- */
-interface RustWASMBackendConfig {
-    /** Minimum elements to use Rust WASM (default: 1000) */
-    minElements?: number;
-    /** Path to the Rust WASM binary */
-    wasmPath?: string;
-}
-/**
- * Rust WASM Backend for matrix operations.
- *
- * Uses the Rust WASM module for heavy computation, with automatic
- * fallback to JSBackend when the module is unavailable or for small matrices.
- *
- * The backend registers as type 'wasm' so it can serve as a drop-in
- * replacement or complement to the AssemblyScript WASMBackend. When both
- * are needed, use BackendManager's operation-specific routing.
- */
-declare class RustWASMBackend implements MatrixBackend {
-    /**
-     * Backend type identifier.
-     * Uses 'rust-wasm' to distinguish from the AssemblyScript WASMBackend.
-     */
-    readonly type: BackendType;
-    private config;
-    private exports;
-    private initPromise;
-    constructor(config?: RustWASMBackendConfig);
-    /**
-     * Check if WebAssembly is available in the current environment.
-     */
-    isAvailable(): boolean;
-    /**
-     * Initialize the Rust WASM backend.
-     * Loads the WASM binary and caches the exports.
-     */
-    initialize(): Promise<void>;
-    private doInitialize;
-    /**
-     * Whether to use Rust WASM for this operation size.
-     */
-    private shouldUseRustWasm;
-    /**
-     * Whether the Rust WASM module is loaded and ready.
-     */
-    get isRustLoaded(): boolean;
-    add(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    subtract(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    multiplyElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    divideElementwise(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    scale(a: DenseMatrix, scalar: number): DenseMatrix;
-    abs(a: DenseMatrix): DenseMatrix;
-    negate(a: DenseMatrix): DenseMatrix;
-    multiply(a: DenseMatrix, b: DenseMatrix): DenseMatrix;
-    transpose(a: DenseMatrix): DenseMatrix;
-    sum(a: DenseMatrix): number;
-    sumAxis(a: DenseMatrix, axis: 0 | 1): DenseMatrix;
-    norm(a: DenseMatrix): number;
-    dot(a: DenseMatrix, b: DenseMatrix): number;
-    /**
-     * LU Decomposition using Rust WASM.
-     */
-    luDecomposition(a: DenseMatrix): Promise<{
-        lu: DenseMatrix;
-        perm: Int32Array;
-        singular: boolean;
-    }>;
-    /**
-     * Eigenvalue decomposition for symmetric matrices using Rust WASM.
-     */
-    eigsSymmetric(a: DenseMatrix, precision?: number): Promise<{
-        eigenvalues: Float64Array;
-        eigenvectors: DenseMatrix;
-        iterations: number;
-    }>;
-    /**
-     * Matrix inversion using Rust WASM.
-     */
-    inverse(a: DenseMatrix): Promise<{
-        inverse: DenseMatrix;
-        singular: boolean;
-    }>;
-    /**
-     * FFT using Rust WASM (rustfft).
-     * Data is interleaved complex: [re0, im0, re1, im1, ...].
-     */
-    fft(data: Float64Array, n: number, inverse?: boolean): Float64Array;
-    /**
-     * Update configuration.
-     */
-    updateConfig(config: Partial<RustWASMBackendConfig>): void;
-    /**
-     * Get current configuration.
-     */
-    getConfig(): Required<RustWASMBackendConfig>;
-}
-/**
- * Global Rust WASM backend instance
- */
-declare const rustWasmBackend: RustWASMBackend;
-/**
- * Create a Rust WASM backend with custom configuration
- */
-declare function createRustWASMBackend(config?: RustWASMBackendConfig): RustWASMBackend;
-
-/**
- * Rust WASM Loader
- *
- * Loads and manages the Rust-compiled WebAssembly module (648 KB).
- * The Rust WASM provides heavy computation: matrix multiply (faer),
- * FFT (rustfft), eigendecomposition, sparse algebra, statistics (statrs),
- * and SIMD-accelerated array operations.
- *
- * Memory model:
- *   The Rust WASM uses `#[no_mangle] extern "C"` raw exports with
- *   a linear memory model. Unlike the AssemblyScript WASM, there is
- *   no managed GC heap (`__new`/`__pin`/`__unpin`/`__collect`).
- *   Instead, JavaScript writes data directly into WASM linear memory
- *   at computed offsets and passes those offsets as pointers.
- *
- * @packageDocumentation
- */
-/**
- * Typed interface for Rust WASM exports.
- *
- * This is a subset of the full export surface, covering the operations
- * most useful for the matrix backend. The full module has 150+ exports
- * across algebra, arithmetic, signal, statistics, etc.
- */
-interface RustWasmExports {
-    memory: WebAssembly.Memory;
-    multiplyDense: (aPtr: number, aRows: number, aCols: number, bPtr: number, bRows: number, bCols: number, resultPtr: number) => void;
-    multiplyDenseSIMD: (aPtr: number, aRows: number, aCols: number, bPtr: number, bRows: number, bCols: number, resultPtr: number) => void;
-    multiplyVector: (aPtr: number, aRows: number, aCols: number, xPtr: number, resultPtr: number) => void;
-    transpose: (dataPtr: number, rows: number, cols: number, resultPtr: number) => void;
-    /** Thin SVD: writes U (m*k), S (k), V (n*k); k = min(m,n). */
-    svd: (aPtr: number, m: number, n: number, uPtr: number, sPtr: number, vPtr: number, workPtr: number) => number;
-    /** Singular values only: writes S (k); k = min(m,n). */
-    singularValues: (aPtr: number, m: number, n: number, sPtr: number, workPtr: number) => number;
-    /** Scratch length (in f64s) required by `svd`. */
-    svdWorkSize: (m: number, n: number) => number;
-    /** Scratch length (in f64s) required by `singularValues`. */
-    singularValuesWorkSize: (m: number, n: number) => number;
-    simdAddF64: (aPtr: number, bPtr: number, resultPtr: number, length: number) => void;
-    simdSubF64: (aPtr: number, bPtr: number, resultPtr: number, length: number) => void;
-    simdMulF64: (aPtr: number, bPtr: number, resultPtr: number, length: number) => void;
-    simdScaleF64: (aPtr: number, scalar: number, resultPtr: number, length: number) => void;
-    simdAbsF64: (aPtr: number, resultPtr: number, length: number) => void;
-    simdDotF64: (aPtr: number, bPtr: number, length: number) => number;
-    simdSumF64: (aPtr: number, length: number) => number;
-    simdNormF64: (aPtr: number, length: number) => number;
-    simdMatMulF64: (aPtr: number, bPtr: number, cPtr: number, m: number, k: number, n: number) => void;
-    simdMinF64: (aPtr: number, length: number) => number;
-    simdMaxF64: (aPtr: number, length: number) => number;
-    simdMeanF64: (aPtr: number, length: number) => number;
-    simdVarianceF64: (aPtr: number, length: number, ddof: number) => number;
-    simdStdF64: (aPtr: number, length: number, ddof: number) => number;
-    luDecomposition: (aPtr: number, n: number, permPtr: number) => number;
-    qrDecomposition: (aPtr: number, m: number, n: number, qPtr: number) => void;
-    choleskyDecomposition: (aPtr: number, n: number, lPtr: number) => number;
-    eigsSymmetric: (matrixPtr: number, n: number, precision: number, eigenvaluesPtr: number, eigenvectorsPtr: number, workPtr: number) => number;
-    laInv: (aPtr: number, n: number, resultPtr: number, workPtr: number) => number;
-    laDet: (aPtr: number, n: number, workPtr: number) => number;
-    laSolve: (aPtr: number, bPtr: number, n: number, resultPtr: number, workPtr: number) => number;
-    fft: (dataPtr: number, n: number, inverse: number) => void;
-    fft2d: (dataPtr: number, rows: number, cols: number, inverse: number) => void;
-    convolve: (signalPtr: number, n: number, kernelPtr: number, m: number, resultPtr: number) => void;
-    rfft: (dataPtr: number, n: number, resultPtr: number) => void;
-    statsMean: (aPtr: number, n: number) => number;
-    statsMedian: (aPtr: number, n: number) => number;
-    statsVariance: (aPtr: number, n: number, ddof: number) => number;
-    statsStd: (aPtr: number, n: number, ddof: number) => number;
-    statsSum: (aPtr: number, n: number) => number;
-    statsMin: (aPtr: number, n: number) => number;
-    statsMax: (aPtr: number, n: number) => number;
-    rust_mat_mul_2x2: (aPtr: number, bPtr: number, outPtr: number) => void;
-    rust_fft_4: (inPtr: number, outPtr: number) => void;
-    rust_gamma: (x: number, outPtr: number) => void;
-    [key: string]: unknown;
-}
-/**
- * Loading metrics for performance monitoring
- */
-interface RustLoadingMetrics {
-    loadMs: number;
-    compileMs: number;
-    instantiateMs: number;
-    totalMs: number;
-    binarySize: number;
-}
-/**
- * Loader for the Rust-compiled WASM module.
- *
- * Singleton pattern with lazy loading. The WASM binary is loaded
- * on first use and cached for subsequent calls.
- */
-declare class RustWasmLoader {
-    private static instance;
-    private wasmInstance;
-    private wasmMemory;
-    private allocator;
-    private _isLoaded;
-    private loading;
-    private lastMetrics;
-    private constructor();
-    static getInstance(): RustWasmLoader;
-    get isLoaded(): boolean;
-    /**
-     * Load the Rust WASM module.
-     * Returns true on success, false if the binary is not available.
-     * Safe to call multiple times (idempotent).
-     */
-    load(wasmPath?: string): Promise<boolean>;
-    private doLoad;
-    /**
-     * Resolve the WASM binary path.
-     * Checks several locations relative to the project root.
-     */
-    private findWasmPath;
-    private getImports;
-    /**
-     * Get the typed exports from the WASM instance.
-     */
-    getExports(): RustWasmExports | null;
-    /**
-     * Get WASM linear memory.
-     */
-    getMemory(): WebAssembly.Memory | null;
-    /**
-     * Get loading metrics.
-     */
-    getLoadingMetrics(): RustLoadingMetrics | null;
-    /**
-     * Write a Float64Array into WASM memory and return the pointer.
-     */
-    writeF64(data: Float64Array | number[]): number;
-    /**
-     * Allocate an empty Float64Array in WASM memory (for output buffers).
-     * Returns the pointer.
-     */
-    allocF64(length: number): number;
-    /**
-     * Write an Int32Array into WASM memory and return the pointer.
-     */
-    writeI32(data: Int32Array | number[]): number;
-    /**
-     * Allocate an empty Int32Array in WASM memory.
-     */
-    allocI32(length: number): number;
-    /**
-     * Read a Float64Array from WASM memory.
-     * Note: the returned array is a *copy* (safe after memory reset).
-     */
-    readF64(ptr: number, length: number): Float64Array;
-    /**
-     * Read an Int32Array from WASM memory.
-     */
-    readI32(ptr: number, length: number): Int32Array;
-    /**
-     * Reset the bump allocator. Call between independent operations
-     * to reclaim temporary memory.
-     */
-    resetAllocator(): void;
-    /**
-     * Reset the loader (for testing).
-     */
-    reset(): void;
-    /**
-     * Reset the singleton (for testing).
-     */
-    static resetInstance(): void;
-}
-/**
- * Global Rust WASM loader instance
- */
-declare const rustWasmLoader: RustWasmLoader;
-/**
- * Initialize the Rust WASM module (call once at startup).
- * Returns true if loaded successfully, false if not available.
- */
-declare function initRustWasm(wasmPath?: string): Promise<boolean>;
-
 /**
  * MathTS Matrix Configuration
  *
@@ -2515,16 +2215,11 @@ interface ExtendedBackendHints extends BackendHints {
     operationThresholds?: Partial<Record<OperationType, {
         wasm?: number;
         gpu?: number;
-        rustWasm?: number;
     }>>;
     /** Enable automatic SIMD detection for WASM */
     autoSIMD?: boolean;
     /** Fallback to JS on backend failure */
     fallbackOnError?: boolean;
-    /** Minimum elements to use Rust WASM backend (default: 1000) */
-    rustWasmThreshold?: number;
-    /** Operations that always prefer Rust WASM regardless of size */
-    rustWasmPreferredOps?: OperationType[];
 }
 /**
  * Default extended hints
@@ -2566,11 +2261,9 @@ declare class BackendManager {
      *
      * Selection priority:
      *   1. Preferred backend (if explicitly set)
-     *   2. Heavy operations (fft, eig, svd, decomposition) -> Rust WASM (if loaded)
-     *   3. Elements > gpuThreshold -> GPU (if available)
-     *   4. Elements > rustWasmThreshold -> Rust WASM (if loaded)
-     *   5. Elements > wasmThreshold -> AS WASM (if loaded)
-     *   6. JS fallback
+     *   2. Elements > gpuThreshold -> GPU (if available)
+     *   3. Elements > wasmThreshold -> AS WASM (if loaded)
+     *   4. JS fallback
      */
     selectBackend(elementCount: number, operation?: OperationType): MatrixBackend;
     /**
@@ -2823,23 +2516,33 @@ declare function normFro(matrix: number[][]): number;
  * WASM-accelerated Eigendecomposition
  *
  * Provides eigenvalue/eigenvector computation with optional WASM acceleration
- * via the Rust-compiled Jacobi eigenvalue algorithm. Falls back to the pure
+ * via the AssemblyScript-compiled Jacobi eigenvalue algorithm. Falls back to the pure
  * JavaScript QR-based implementation when WASM is unavailable.
  *
  * WASM acceleration path:
- *   - Symmetric matrices: Jacobi eigenvalue algorithm (Rust WASM)
- *   - Non-symmetric matrices: falls back to JS QR algorithm
+ *   - Symmetric matrices: Jacobi eigenvalue algorithm (AssemblyScript
+ *     `matrix_eig_symmetric`, `assembly/src/ops/eig.ts`)
+ *   - Non-symmetric matrices: Hessenberg reduction + Francis double-shift
+ *     implicit QR to the real Schur form, with eigenvector back-substitution
+ *     (AssemblyScript `matrix_eig_general`, `assembly/src/ops/eig.ts`)
  *
- * JS fallback path:
+ * JS fallback path (wasm unavailable, n < threshold, or missing export):
  *   - Full QR algorithm with implicit shifts (eig.ts)
  *
+ * Packing of the AS return values (both decoded via `readReturnedFloat64Array`):
+ *   - matrix_eig_symmetric: `[ eigenvalues(n) | eigenvectors(n*n) ]`
+ *   - matrix_eig_general:   `[ re(n) | im(n) | eigenvectors(n*n) ]`
+ * Eigenvectors are stored as COLUMNS (`V[i*n+j]` = component `i` of
+ * eigenvector `j`). Complex-eigenvalue columns are zero (the real `number[][]`
+ * vector contract cannot represent complex eigenvectors).
+ *
  * @packageDocumentation
  */
 
 /**
  * WASM-accelerated eigendecomposition for symmetric matrices.
  *
- * Uses the Rust Jacobi eigenvalue algorithm when WASM is loaded,
+ * Uses the AssemblyScript Jacobi eigenvalue algorithm when WASM is loaded,
  * otherwise falls back to the JavaScript QR algorithm.
  *
  * @param matrix - Square matrix as 2D array
@@ -2861,7 +2564,7 @@ declare function eigvalsWasm(matrix: number[][], options?: Omit<EigOptions, 'com
 }>>;
 /**
  * WASM-accelerated spectral radius.
- * Uses Rust power iteration when WASM is available.
+ * Uses AssemblyScript power iteration when WASM is available.
  *
  * @param matrix - Square matrix as 2D array
  * @param options - Iteration options
@@ -2875,10 +2578,12 @@ declare function spectralRadiusWasm(matrix: number[][], options?: {
 /**
  * WASM-accelerated Singular Value Decomposition.
  *
- * Routes through the Rust WASM crate's direct one-sided Jacobi SVD
- * (`svd` export) for any real `m x n` matrix, and falls back to the
- * synchronous JavaScript Golub-Reinsch {@link svd} when the WASM module is
- * unavailable.
+ * Routes through the AssemblyScript binary's one-sided Jacobi SVD
+ * (`matrix_svd` export, `assembly/src/ops/svd.ts`) for any real `m x n`
+ * matrix, and falls back to the synchronous JavaScript Golub-Reinsch
+ * {@link svd} when the WASM module is unavailable. (Phase 7b: repointed onto
+ * the AssemblyScript binary; singular values are bit-identical to the JS
+ * reference per the 7a parity validation.)
  *
  * Unlike the synchronous {@link svd} (which returns the *full* `m x m` /
  * `n x n` factors), `svdWasm` always returns the **thin / economy** form —
@@ -2890,7 +2595,7 @@ declare function spectralRadiusWasm(matrix: number[][], options?: {
 
 /**
  * WASM-accelerated thin SVD. Always safe to call — falls back to the
- * synchronous JS SVD when the Rust WASM module is not available.
+ * synchronous JS SVD when the AssemblyScript WASM module is not available.
  *
  * @param matrix - Input matrix (m x n) as a row-major 2D array
  * @param options - SVD options; `rankTolerance` controls the rank estimate
@@ -3630,4 +3335,4 @@ declare function initializeParallelMatrix(): Promise<void>;
  */
 declare function terminateParallelMatrix(): Promise<void>;
 
-export { BUILTIN_SHADERS, type BackendHints, BackendManager, BackendRegistry, type BackendType, BatchExecutor, BufferPool, type CholeskyResult, DEFAULT_BACKEND_HINTS, DEFAULT_EXTENDED_HINTS, DenseMatrix, type EigOptions, type EigResult, type ExpmOptions, type ExtendedBackendHints, GPUBackend, type GPUBackendOptions, type GPUBackendStatus, type GPUCapabilities, GPUContext, type GPUContextOptions, GPUMatrixBackend, type GPUMatrixBackendConfig, JSBackend, type LUResult, type LogmOptions, Matrix, type MatrixBackend, type MatrixDimensions, type MatrixEntry, type MatrixIndex, type MatrixType, type OperationType, ParallelBackend, type ParallelBackendConfig, type PinvOptions, type QROptions, type QRResult, type RustLoadingMetrics, RustWASMBackend, type RustWASMBackendConfig, type RustWasmExports, RustWasmLoader, type SVDOptions, type SVDResult, type SchurOptions, type SchurResult, ShaderManager, type SliceSpec, SparseMatrix, type SqrtmOptions, type SyncConfig, SyncManager, type SyncStrategy, WASMBackend, type WASMBackendConfig, type WasmFeatures, abs, add, backendManager, backendRegistry, cholesky, clearFeatureCache, column, cond, createBackendManager, createGPUMatrixBackend, createParallelBackend, createRustWASMBackend, createSyncManager, createWASMBackend, destroyGlobalGPU, destroyGlobalGPUBackend, detectGPUCapabilities, detectWasmFeatures, diag, diagonal, divide, dotMultiply, eig, eigWasm, eigvals, eigvalsWasm, exp, getCachedFeatures, getGlobalGPUBackend, getGlobalGPUContext, getRecommendedWorkgroupSize, gpuMatrixBackend, hasWebGPU, identity, initRustWasm, initializeGlobalGPUBackend, initializeParallelMatrix, isAtomicsAvailable, isDenseMatrix, isMatrix, isSharedMemoryAvailable, isSparseMatrix, isWasmAvailable, jsBackend, log, lowRankApprox, lu, matrix, matrixExpm, matrixLogm, pinv as matrixPinv, matrixSchur, matrixSqrtm, max, mean, min, multiply, norm, norm2, normFro, ones, parallelBackend, parallelDiag, parallelDotMultiply, parallelIdentity, parallelMatrix, parallelMatrixAbs, parallelMatrixAdd, parallelMatrixColumn, parallelMatrixCos, parallelMatrixDiagonal, parallelMatrixDistance, parallelMatrixDivide, parallelMatrixDot, parallelMatrixExp, parallelMatrixHistogram, parallelMatrixLog, parallelMatrixMatvec, parallelMatrixMax, parallelMatrixMean, parallelMatrixMin, parallelMatrixMultiply, parallelMatrixNorm, parallelMatrixOperations, parallelMatrixOuter, parallelMatrixRow, parallelMatrixSin, parallelMatrixSize, parallelMatrixSqrt, parallelMatrixSquare, parallelMatrixStd, parallelMatrixSubset, parallelMatrixSubtract, parallelMatrixSum, parallelMatrixTan, parallelMatrixTrace, parallelMatrixTranspose, parallelMatrixVariance, parallelOnes, parallelRandom, parallelUnaryMinus, parallelZeros, pinv$1 as pinv, pow, powerIteration, qr, random, row, rustWasmBackend, rustWasmLoader, singularValues, size, spectralRadiusWasm, sqrt, square, subset, subtract, sum, svd, svdWasm, terminateParallelMatrix, trace, transpose, typedMatrixOperations, unaryMinus, wasmBackend, zeros };
+export { BUILTIN_SHADERS, type BackendHints, BackendManager, BackendRegistry, type BackendType, BatchExecutor, BufferPool, type CholeskyResult, DEFAULT_BACKEND_HINTS, DEFAULT_EXTENDED_HINTS, DenseMatrix, type EigOptions, type EigResult, type ExpmOptions, type ExtendedBackendHints, GPUBackend, type GPUBackendOptions, type GPUBackendStatus, type GPUCapabilities, GPUContext, type GPUContextOptions, GPUMatrixBackend, type GPUMatrixBackendConfig, JSBackend, type LUResult, type LogmOptions, Matrix, type MatrixBackend, type MatrixDimensions, type MatrixEntry, type MatrixIndex, type MatrixType, type OperationType, ParallelBackend, type ParallelBackendConfig, type PinvOptions, type QROptions, type QRResult, type SVDOptions, type SVDResult, type SchurOptions, type SchurResult, ShaderManager, type SliceSpec, SparseMatrix, type SqrtmOptions, type SyncConfig, SyncManager, type SyncStrategy, WASMBackend, type WASMBackendConfig, type WasmFeatures, abs, add, backendManager, backendRegistry, cholesky, clearFeatureCache, column, cond, createBackendManager, createGPUMatrixBackend, createParallelBackend, createSyncManager, createWASMBackend, destroyGlobalGPU, destroyGlobalGPUBackend, detectGPUCapabilities, detectWasmFeatures, diag, diagonal, divide, dotMultiply, eig, eigWasm, eigvals, eigvalsWasm, exp, getCachedFeatures, getGlobalGPUBackend, getGlobalGPUContext, getRecommendedWorkgroupSize, gpuMatrixBackend, hasWebGPU, identity, initializeGlobalGPUBackend, initializeParallelMatrix, isAtomicsAvailable, isDenseMatrix, isMatrix, isSharedMemoryAvailable, isSparseMatrix, isWasmAvailable, jsBackend, log, lowRankApprox, lu, matrix, matrixExpm, matrixLogm, pinv as matrixPinv, matrixSchur, matrixSqrtm, max, mean, min, multiply, norm, norm2, normFro, ones, parallelBackend, parallelDiag, parallelDotMultiply, parallelIdentity, parallelMatrix, parallelMatrixAbs, parallelMatrixAdd, parallelMatrixColumn, parallelMatrixCos, parallelMatrixDiagonal, parallelMatrixDistance, parallelMatrixDivide, parallelMatrixDot, parallelMatrixExp, parallelMatrixHistogram, parallelMatrixLog, parallelMatrixMatvec, parallelMatrixMax, parallelMatrixMean, parallelMatrixMin, parallelMatrixMultiply, parallelMatrixNorm, parallelMatrixOperations, parallelMatrixOuter, parallelMatrixRow, parallelMatrixSin, parallelMatrixSize, parallelMatrixSqrt, parallelMatrixSquare, parallelMatrixStd, parallelMatrixSubset, parallelMatrixSubtract, parallelMatrixSum, parallelMatrixTan, parallelMatrixTrace, parallelMatrixTranspose, parallelMatrixVariance, parallelOnes, parallelRandom, parallelUnaryMinus, parallelZeros, pinv$1 as pinv, pow, powerIteration, qr, random, row, singularValues, size, spectralRadiusWasm, sqrt, square, subset, subtract, sum, svd, svdWasm, terminateParallelMatrix, trace, transpose, typedMatrixOperations, unaryMinus, wasmBackend, zeros };