@danielsimonjr/mathts-matrix 0.1.7 → 0.1.10

package/dist/index.js

@@ -1,8 +1,21 @@
 import {
+  applyHouseholderLeft,
+  applyHouseholderRight,
+  cloneMatrix,
   eig,
   eigvals,
-  powerIteration
-} from "./chunk-VCPLE6ED.js";
+  eye,
+  householder,
+  isSymmetric,
+  matAdd,
+  matMul,
+  matScale,
+  matSub,
+  norm1,
+  normInf,
+  powerIteration,
+  transpose
+} from "./chunk-HT4ZF3LN.js";
 import {
   __esm,
   __export,
@@ -183,7 +196,7 @@ function scale(a, scalar) {
   for (let i = 0; i < ad.length; i++) result[i] = ad[i] * scalar;
   return result;
 }
-function transpose(a) {
+function transpose2(a) {
   const ad = flat(a);
   const rows = a.rows;
   const cols = a.cols;
@@ -1288,7 +1301,7 @@ var init_DenseMatrix = __esm({
        * Matrix transpose
        */
       transpose() {
-        return new _DenseMatrix(this.cols, this.rows, transpose(this));
+        return new _DenseMatrix(this.cols, this.rows, transpose2(this));
       }
       /**
        * Negate all elements
@@ -2474,7 +2487,7 @@ var WASMBackend = class {
       const loaded = await this.loadAsModule(path);
       if (typeof loaded.__new !== "function" || typeof loaded.matrix_multiply !== "function") {
         console.warn(
-          "WASMBackend: loaded module is not the AssemblyScript artifact; falling back to JS. Pass an explicit wasmPath or use RustWASMBackend for the Rust artifact."
+          "WASMBackend: loaded module is not the AssemblyScript artifact; falling back to JS. Pass an explicit wasmPath (the AS binary, mathts-as.wasm)."
         );
         this.wasmModule = null;
         return;
@@ -2506,7 +2519,7 @@ var WASMBackend = class {
   /**
    * 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.
    */
   async loadAsModule(path) {
     const imports = {
@@ -2754,7 +2767,7 @@ var WASMBackend = class {
   // =========================================================================
   // LU / QR / Cholesky / Inverse / Determinant
   // -------------------------------------------------------------------------
-  // AssemblyScript now exports these alongside the Rust binary (see
+  // AssemblyScript exports these (see
   // assembly/src/algebra/decomposition.ts). Each method dispatches to
   // the AS export when the loaded module exposes it; otherwise it falls
   // back to the in-process JS implementation that previously handled
@@ -4990,620 +5003,8 @@ function createGPUMatrixBackend(config) {
   return new GPUMatrixBackend(config);
 }
 
-// src/backends/RustWASMBackend.ts
-init_DenseMatrix();
-
-// src/backends/RustWasmLoader.ts
-var BumpAllocator = class {
-  /** Next free byte offset in WASM memory */
-  offset;
-  /** Minimum offset (base of allocatable region) */
-  base;
-  constructor(baseOffset) {
-    this.base = baseOffset;
-    this.offset = baseOffset;
-  }
-  /**
-   * Allocate `byteLength` bytes, aligned to 8-byte boundary.
-   * Returns the byte offset (pointer) into WASM memory.
-   */
-  alloc(byteLength, memory) {
-    const aligned = this.offset + 7 & ~7;
-    const end = aligned + byteLength;
-    const currentBytes = memory.buffer.byteLength;
-    if (end > currentBytes) {
-      const pagesNeeded = Math.ceil((end - currentBytes) / 65536);
-      memory.grow(pagesNeeded);
-    }
-    this.offset = end;
-    return aligned;
-  }
-  /**
-   * Reset the allocator, reclaiming all temporary memory.
-   * Call between independent operations.
-   */
-  reset() {
-    this.offset = this.base;
-  }
-  /** Current high-water mark */
-  get highWaterMark() {
-    return this.offset;
-  }
-};
-var RustWasmLoader = class _RustWasmLoader {
-  static instance = null;
-  wasmInstance = null;
-  wasmMemory = null;
-  allocator = null;
-  _isLoaded = false;
-  loading = null;
-  lastMetrics = null;
-  constructor() {
-  }
-  static getInstance() {
-    if (!_RustWasmLoader.instance) {
-      _RustWasmLoader.instance = new _RustWasmLoader();
-    }
-    return _RustWasmLoader.instance;
-  }
-  get isLoaded() {
-    return this._isLoaded;
-  }
-  /**
-   * Load the Rust WASM module.
-   * Returns true on success, false if the binary is not available.
-   * Safe to call multiple times (idempotent).
-   */
-  async load(wasmPath) {
-    if (this._isLoaded) return true;
-    if (this.loading) return this.loading;
-    this.loading = this.doLoad(wasmPath);
-    const result = await this.loading;
-    this.loading = null;
-    return result;
-  }
-  async doLoad(wasmPath) {
-    const totalStart = performance.now();
-    try {
-      const path = wasmPath || await this.findWasmPath();
-      const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
-      const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-X3CLNVGW.js");
-      let binarySize = 0;
-      if (isNode) {
-        const loadStart = performance.now();
-        const fs = await import("fs");
-        const buffer = fs.readFileSync(path);
-        binarySize = buffer.byteLength;
-        const loadEnd = performance.now();
-        await verifyWasmIntegrity(buffer, path);
-        const compileStart = performance.now();
-        const module = await WebAssembly.compile(buffer);
-        const compileEnd = performance.now();
-        const instStart = performance.now();
-        this.wasmInstance = await WebAssembly.instantiate(module, this.getImports());
-        const instEnd = performance.now();
-        this.lastMetrics = {
-          loadMs: loadEnd - loadStart,
-          compileMs: compileEnd - compileStart,
-          instantiateMs: instEnd - instStart,
-          totalMs: performance.now() - totalStart,
-          binarySize
-        };
-      } else {
-        const manifest = await loadWasmManifest(path);
-        const instStart = performance.now();
-        if (!manifest && typeof WebAssembly.instantiateStreaming === "function") {
-          const result = await WebAssembly.instantiateStreaming(fetch(path), this.getImports());
-          this.wasmInstance = result.instance;
-        } else {
-          const response = await fetch(path);
-          const buffer = await response.arrayBuffer();
-          binarySize = buffer.byteLength;
-          await verifyWasmIntegrity(buffer, path, { manifest });
-          const module = await WebAssembly.compile(buffer);
-          this.wasmInstance = await WebAssembly.instantiate(module, this.getImports());
-        }
-        this.lastMetrics = {
-          loadMs: 0,
-          compileMs: 0,
-          instantiateMs: performance.now() - instStart,
-          totalMs: performance.now() - totalStart,
-          binarySize
-        };
-      }
-      this.wasmMemory = this.wasmInstance.exports.memory;
-      const heapBaseGlobal = this.wasmInstance.exports.__heap_base;
-      const heapBase = heapBaseGlobal && typeof heapBaseGlobal.value === "number" ? heapBaseGlobal.value : 65536;
-      this.allocator = new BumpAllocator(heapBase);
-      this._isLoaded = true;
-      return true;
-    } catch (e) {
-      console.warn("Rust WASM not available, using JS fallback:", e.message);
-      return false;
-    }
-  }
-  /**
-   * Resolve the WASM binary path.
-   * Checks several locations relative to the project root.
-   */
-  async findWasmPath() {
-    const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
-    const resolvedUrl = new URL(`../../../lib/wasm/mathts.wasm`, import.meta.url);
-    if (isNode) {
-      const { fileURLToPath } = await import("url");
-      return fileURLToPath(resolvedUrl);
-    }
-    return resolvedUrl.href;
-  }
-  getImports() {
-    return {
-      env: {
-        abort: () => {
-          throw new Error("Rust WASM abort");
-        }
-      }
-    };
-  }
-  /**
-   * Get the typed exports from the WASM instance.
-   */
-  getExports() {
-    if (!this.wasmInstance) return null;
-    return this.wasmInstance.exports;
-  }
-  /**
-   * Get WASM linear memory.
-   */
-  getMemory() {
-    return this.wasmMemory;
-  }
-  /**
-   * Get loading metrics.
-   */
-  getLoadingMetrics() {
-    return this.lastMetrics;
-  }
-  // =========================================================================
-  // Memory Management (Bump Allocator)
-  // =========================================================================
-  /**
-   * Write a Float64Array into WASM memory and return the pointer.
-   */
-  writeF64(data) {
-    if (!this.wasmMemory || !this.allocator) {
-      throw new Error("Rust WASM not loaded");
-    }
-    const byteLength = (Array.isArray(data) ? data.length : data.length) * 8;
-    const ptr = this.allocator.alloc(byteLength, this.wasmMemory);
-    const view = new Float64Array(
-      this.wasmMemory.buffer,
-      ptr,
-      Array.isArray(data) ? data.length : data.length
-    );
-    view.set(data);
-    return ptr;
-  }
-  /**
-   * Allocate an empty Float64Array in WASM memory (for output buffers).
-   * Returns the pointer.
-   */
-  allocF64(length) {
-    if (!this.wasmMemory || !this.allocator) {
-      throw new Error("Rust WASM not loaded");
-    }
-    return this.allocator.alloc(length * 8, this.wasmMemory);
-  }
-  /**
-   * Write an Int32Array into WASM memory and return the pointer.
-   */
-  writeI32(data) {
-    if (!this.wasmMemory || !this.allocator) {
-      throw new Error("Rust WASM not loaded");
-    }
-    const length = Array.isArray(data) ? data.length : data.length;
-    const byteLength = length * 4;
-    const ptr = this.allocator.alloc(byteLength, this.wasmMemory);
-    const view = new Int32Array(this.wasmMemory.buffer, ptr, length);
-    view.set(data);
-    return ptr;
-  }
-  /**
-   * Allocate an empty Int32Array in WASM memory.
-   */
-  allocI32(length) {
-    if (!this.wasmMemory || !this.allocator) {
-      throw new Error("Rust WASM not loaded");
-    }
-    return this.allocator.alloc(length * 4, this.wasmMemory);
-  }
-  /**
-   * Read a Float64Array from WASM memory.
-   * Note: the returned array is a *copy* (safe after memory reset).
-   */
-  readF64(ptr, length) {
-    if (!this.wasmMemory) {
-      throw new Error("Rust WASM not loaded");
-    }
-    const view = new Float64Array(this.wasmMemory.buffer, ptr, length);
-    return new Float64Array(view);
-  }
-  /**
-   * Read an Int32Array from WASM memory.
-   */
-  readI32(ptr, length) {
-    if (!this.wasmMemory) {
-      throw new Error("Rust WASM not loaded");
-    }
-    const view = new Int32Array(this.wasmMemory.buffer, ptr, length);
-    return new Int32Array(view);
-  }
-  /**
-   * Reset the bump allocator. Call between independent operations
-   * to reclaim temporary memory.
-   */
-  resetAllocator() {
-    this.allocator?.reset();
-  }
-  /**
-   * Reset the loader (for testing).
-   */
-  reset() {
-    this.wasmInstance = null;
-    this.wasmMemory = null;
-    this.allocator = null;
-    this._isLoaded = false;
-    this.loading = null;
-    this.lastMetrics = null;
-  }
-  /**
-   * Reset the singleton (for testing).
-   */
-  static resetInstance() {
-    if (_RustWasmLoader.instance) {
-      _RustWasmLoader.instance.reset();
-    }
-    _RustWasmLoader.instance = null;
-  }
-};
-var rustWasmLoader = RustWasmLoader.getInstance();
-async function initRustWasm(wasmPath) {
-  return rustWasmLoader.load(wasmPath);
-}
-
-// src/backends/RustWASMBackend.ts
-var DEFAULT_CONFIG3 = {
-  minElements: 1e3,
-  wasmPath: ""
-};
-var RustWASMBackend = class {
-  /**
-   * Backend type identifier.
-   * Uses 'rust-wasm' to distinguish from the AssemblyScript WASMBackend.
-   */
-  type = "rust-wasm";
-  config;
-  exports = null;
-  initPromise = null;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG3, ...config };
-  }
-  /**
-   * Check if WebAssembly is available in the current environment.
-   */
-  isAvailable() {
-    return typeof WebAssembly !== "undefined";
-  }
-  /**
-   * Initialize the Rust WASM backend.
-   * Loads the WASM binary and caches the exports.
-   */
-  async initialize() {
-    if (this.exports) return;
-    if (this.initPromise) return this.initPromise;
-    this.initPromise = this.doInitialize();
-    return this.initPromise;
-  }
-  async doInitialize() {
-    if (!this.isAvailable()) {
-      throw new Error("WebAssembly is not available in this environment");
-    }
-    const loaded = await rustWasmLoader.load(this.config.wasmPath || void 0);
-    if (loaded) {
-      this.exports = rustWasmLoader.getExports();
-    } else {
-      console.warn("Rust WASM binary not available, RustWASMBackend will use JS fallback");
-    }
-  }
-  /**
-   * Whether to use Rust WASM for this operation size.
-   */
-  shouldUseRustWasm(elementCount) {
-    return this.exports !== null && elementCount >= this.config.minElements;
-  }
-  /**
-   * Whether the Rust WASM module is loaded and ready.
-   */
-  get isRustLoaded() {
-    return this.exports !== null;
-  }
-  // =========================================================================
-  // Element-wise Operations
-  // =========================================================================
-  add(a, b) {
-    const n = a.rows * a.cols;
-    if (!this.shouldUseRustWasm(n)) return jsBackend.add(a, b);
-    try {
-      rustWasmLoader.resetAllocator();
-      const aPtr = rustWasmLoader.writeF64(a.toFloat64Array());
-      const bPtr = rustWasmLoader.writeF64(b.toFloat64Array());
-      const outPtr = rustWasmLoader.allocF64(n);
-      this.exports.simdAddF64(aPtr, bPtr, outPtr, n);
-      const result = rustWasmLoader.readF64(outPtr, n);
-      return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
-    } catch {
-      return jsBackend.add(a, b);
-    }
-  }
-  subtract(a, b) {
-    const n = a.rows * a.cols;
-    if (!this.shouldUseRustWasm(n)) return jsBackend.subtract(a, b);
-    try {
-      rustWasmLoader.resetAllocator();
-      const aPtr = rustWasmLoader.writeF64(a.toFloat64Array());
-      const bPtr = rustWasmLoader.writeF64(b.toFloat64Array());
-      const outPtr = rustWasmLoader.allocF64(n);
-      this.exports.simdSubF64(aPtr, bPtr, outPtr, n);
-      const result = rustWasmLoader.readF64(outPtr, n);
-      return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
-    } catch {
-      return jsBackend.subtract(a, b);
-    }
-  }
-  multiplyElementwise(a, b) {
-    const n = a.rows * a.cols;
-    if (!this.shouldUseRustWasm(n)) return jsBackend.multiplyElementwise(a, b);
-    try {
-      rustWasmLoader.resetAllocator();
-      const aPtr = rustWasmLoader.writeF64(a.toFloat64Array());
-      const bPtr = rustWasmLoader.writeF64(b.toFloat64Array());
-      const outPtr = rustWasmLoader.allocF64(n);
-      this.exports.simdMulF64(aPtr, bPtr, outPtr, n);
-      const result = rustWasmLoader.readF64(outPtr, n);
-      return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
-    } catch {
-      return jsBackend.multiplyElementwise(a, b);
-    }
-  }
-  divideElementwise(a, b) {
-    return jsBackend.divideElementwise(a, b);
-  }
-  scale(a, scalar) {
-    const n = a.rows * a.cols;
-    if (!this.shouldUseRustWasm(n)) return jsBackend.scale(a, scalar);
-    try {
-      rustWasmLoader.resetAllocator();
-      const aPtr = rustWasmLoader.writeF64(a.toFloat64Array());
-      const outPtr = rustWasmLoader.allocF64(n);
-      this.exports.simdScaleF64(aPtr, scalar, outPtr, n);
-      const result = rustWasmLoader.readF64(outPtr, n);
-      return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
-    } catch {
-      return jsBackend.scale(a, scalar);
-    }
-  }
-  abs(a) {
-    const n = a.rows * a.cols;
-    if (!this.shouldUseRustWasm(n)) return jsBackend.abs(a);
-    try {
-      rustWasmLoader.resetAllocator();
-      const aPtr = rustWasmLoader.writeF64(a.toFloat64Array());
-      const outPtr = rustWasmLoader.allocF64(n);
-      this.exports.simdAbsF64(aPtr, outPtr, n);
-      const result = rustWasmLoader.readF64(outPtr, n);
-      return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
-    } catch {
-      return jsBackend.abs(a);
-    }
-  }
-  negate(a) {
-    const n = a.rows * a.cols;
-    if (!this.shouldUseRustWasm(n)) return jsBackend.negate(a);
-    try {
-      rustWasmLoader.resetAllocator();
-      const aPtr = rustWasmLoader.writeF64(a.toFloat64Array());
-      const outPtr = rustWasmLoader.allocF64(n);
-      this.exports.simdScaleF64(aPtr, -1, outPtr, n);
-      const result = rustWasmLoader.readF64(outPtr, n);
-      return DenseMatrix.fromFlat(a.rows, a.cols, Array.from(result));
-    } catch {
-      return jsBackend.negate(a);
-    }
-  }
-  // =========================================================================
-  // Matrix Operations
-  // =========================================================================
-  multiply(a, b) {
-    const elementCount = a.rows * a.cols + b.rows * b.cols;
-    if (!this.shouldUseRustWasm(elementCount)) return jsBackend.multiply(a, b);
-    try {
-      rustWasmLoader.resetAllocator();
-      const aPtr = rustWasmLoader.writeF64(a.toFloat64Array());
-      const bPtr = rustWasmLoader.writeF64(b.toFloat64Array());
-      const resultSize = a.rows * b.cols;
-      const outPtr = rustWasmLoader.allocF64(resultSize);
-      this.exports.multiplyDenseSIMD(aPtr, a.rows, a.cols, bPtr, b.rows, b.cols, outPtr);
-      const result = rustWasmLoader.readF64(outPtr, resultSize);
-      return DenseMatrix.fromFlat(a.rows, b.cols, Array.from(result));
-    } catch {
-      return jsBackend.multiply(a, b);
-    }
-  }
-  transpose(a) {
-    const n = a.rows * a.cols;
-    if (!this.shouldUseRustWasm(n)) return jsBackend.transpose(a);
-    try {
-      rustWasmLoader.resetAllocator();
-      const aPtr = rustWasmLoader.writeF64(a.toFloat64Array());
-      const outPtr = rustWasmLoader.allocF64(n);
-      this.exports.transpose(aPtr, a.rows, a.cols, outPtr);
-      const result = rustWasmLoader.readF64(outPtr, n);
-      return DenseMatrix.fromFlat(a.cols, a.rows, Array.from(result));
-    } catch {
-      return jsBackend.transpose(a);
-    }
-  }
-  // =========================================================================
-  // Reduction Operations
-  // =========================================================================
-  sum(a) {
-    const n = a.rows * a.cols;
-    if (!this.shouldUseRustWasm(n)) return jsBackend.sum(a);
-    try {
-      rustWasmLoader.resetAllocator();
-      const aPtr = rustWasmLoader.writeF64(a.toFloat64Array());
-      return this.exports.simdSumF64(aPtr, n);
-    } catch {
-      return jsBackend.sum(a);
-    }
-  }
-  sumAxis(a, axis) {
-    return jsBackend.sumAxis(a, axis);
-  }
-  norm(a) {
-    const n = a.rows * a.cols;
-    if (!this.shouldUseRustWasm(n)) return jsBackend.norm(a);
-    try {
-      rustWasmLoader.resetAllocator();
-      const aPtr = rustWasmLoader.writeF64(a.toFloat64Array());
-      return this.exports.simdNormF64(aPtr, n);
-    } catch {
-      return jsBackend.norm(a);
-    }
-  }
-  dot(a, b) {
-    const n = a.rows * a.cols;
-    if (!this.shouldUseRustWasm(n)) return jsBackend.dot(a, b);
-    try {
-      rustWasmLoader.resetAllocator();
-      const aPtr = rustWasmLoader.writeF64(a.toFloat64Array());
-      const bPtr = rustWasmLoader.writeF64(b.toFloat64Array());
-      return this.exports.simdDotF64(aPtr, bPtr, n);
-    } catch {
-      return jsBackend.dot(a, b);
-    }
-  }
-  // =========================================================================
-  // Heavy Operations (unique to Rust backend)
-  // =========================================================================
-  /**
-   * LU Decomposition using Rust WASM.
-   */
-  async luDecomposition(a) {
-    const n = a.rows;
-    if (n !== a.cols) {
-      throw new Error("LU decomposition requires a square matrix");
-    }
-    if (!this.exports) {
-      throw new Error("Rust WASM not loaded");
-    }
-    rustWasmLoader.resetAllocator();
-    const aPtr = rustWasmLoader.writeF64(a.toFloat64Array());
-    const permPtr = rustWasmLoader.allocI32(n);
-    const success = this.exports.luDecomposition(aPtr, n, permPtr);
-    return {
-      lu: DenseMatrix.fromFlat(n, n, Array.from(rustWasmLoader.readF64(aPtr, n * n))),
-      perm: rustWasmLoader.readI32(permPtr, n),
-      singular: success === 0
-    };
-  }
-  /**
-   * Eigenvalue decomposition for symmetric matrices using Rust WASM.
-   */
-  async eigsSymmetric(a, precision = 1e-12) {
-    const n = a.rows;
-    if (n !== a.cols) {
-      throw new Error("Eigendecomposition requires a square matrix");
-    }
-    if (!this.exports) {
-      throw new Error("Rust WASM not loaded");
-    }
-    rustWasmLoader.resetAllocator();
-    const aPtr = rustWasmLoader.writeF64(a.toFloat64Array());
-    const eigvalsPtr = rustWasmLoader.allocF64(n);
-    const eigvecsPtr = rustWasmLoader.allocF64(n * n);
-    const workPtr = rustWasmLoader.allocF64(n * n);
-    const iterations = this.exports.eigsSymmetric(
-      aPtr,
-      n,
-      precision,
-      eigvalsPtr,
-      eigvecsPtr,
-      workPtr
-    );
-    return {
-      eigenvalues: rustWasmLoader.readF64(eigvalsPtr, n),
-      eigenvectors: DenseMatrix.fromFlat(
-        n,
-        n,
-        Array.from(rustWasmLoader.readF64(eigvecsPtr, n * n))
-      ),
-      iterations
-    };
-  }
-  /**
-   * Matrix inversion using Rust WASM.
-   */
-  async inverse(a) {
-    const n = a.rows;
-    if (n !== a.cols) {
-      throw new Error("Matrix inversion requires a square matrix");
-    }
-    if (!this.exports) {
-      throw new Error("Rust WASM not loaded");
-    }
-    rustWasmLoader.resetAllocator();
-    const aPtr = rustWasmLoader.writeF64(a.toFloat64Array());
-    const resultPtr = rustWasmLoader.allocF64(n * n);
-    const workPtr = rustWasmLoader.allocF64(n * n);
-    const success = this.exports.laInv(aPtr, n, resultPtr, workPtr);
-    return {
-      inverse: DenseMatrix.fromFlat(n, n, Array.from(rustWasmLoader.readF64(resultPtr, n * n))),
-      singular: success === 0
-    };
-  }
-  /**
-   * FFT using Rust WASM (rustfft).
-   * Data is interleaved complex: [re0, im0, re1, im1, ...].
-   */
-  fft(data, n, inverse = false) {
-    if (!this.exports) {
-      throw new Error("Rust WASM not loaded");
-    }
-    rustWasmLoader.resetAllocator();
-    const dataPtr = rustWasmLoader.writeF64(data);
-    this.exports.fft(dataPtr, n, inverse ? 1 : 0);
-    return rustWasmLoader.readF64(dataPtr, n * 2);
-  }
-  /**
-   * Update configuration.
-   */
-  updateConfig(config) {
-    this.config = { ...this.config, ...config };
-  }
-  /**
-   * Get current configuration.
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-};
-var rustWasmBackend = new RustWASMBackend();
-function createRustWASMBackend(config) {
-  return new RustWASMBackend(config);
-}
-
 // src/config.ts
-var DEFAULT_CONFIG4 = {
+var DEFAULT_CONFIG3 = {
   backends: {
     js: {
       enabled: true,
@@ -5651,7 +5052,7 @@ var DEFAULT_CONFIG4 = {
   precision: "double",
   debug: false
 };
-var currentConfig = { ...DEFAULT_CONFIG4 };
+var currentConfig = { ...DEFAULT_CONFIG3 };
 var listeners = /* @__PURE__ */ new Set();
 function getConfig() {
   return currentConfig;
@@ -5663,22 +5064,18 @@ function onConfigChange(listener) {
 
 // src/backends/register-backends.ts
 backendRegistry.register(jsBackend);
-backendRegistry.register(rustWasmBackend);
 backendRegistry.register(wasmBackend);
 
 // src/backends/BackendManager.ts
 var DEFAULT_EXTENDED_HINTS = {
   ...DEFAULT_BACKEND_HINTS,
   operationThresholds: {
-    multiply: { wasm: 500, gpu: 5e4, rustWasm: 1e3 },
-    decomposition: { wasm: 100, gpu: 1e4, rustWasm: 100 },
-    transpose: { wasm: 2e3, gpu: 2e5, rustWasm: 2e3 }
+    multiply: { wasm: 500, gpu: 5e4 },
+    decomposition: { wasm: 100, gpu: 1e4 },
+    transpose: { wasm: 2e3, gpu: 2e5 }
   },
   autoSIMD: true,
-  fallbackOnError: true,
-  rustWasmThreshold: 1e3,
-  /** Heavy operations that always prefer Rust WASM (faer/rustfft) when available */
-  rustWasmPreferredOps: ["fft", "eig", "svd", "decomposition"]
+  fallbackOnError: true
 };
 var BackendManager = class {
   hints;
@@ -5756,48 +5153,29 @@ var BackendManager = class {
    *
    * 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, operation) {
-    const {
-      preferredBackend,
-      operationThresholds,
-      wasmThreshold,
-      gpuThreshold,
-      rustWasmThreshold,
-      rustWasmPreferredOps
-    } = this.hints;
+    const { preferredBackend, operationThresholds, wasmThreshold, gpuThreshold } = this.hints;
     if (preferredBackend !== "js" && backendRegistry.has(preferredBackend)) {
       const backend = backendRegistry.get(preferredBackend);
       if (backend) {
         return backend;
       }
     }
-    if (operation && rustWasmPreferredOps?.includes(operation) && backendRegistry.has("rust-wasm")) {
-      const rustBackend = backendRegistry.get("rust-wasm");
-      if (rustBackend) return rustBackend;
-    }
     let wasmThresh = wasmThreshold;
     let gpuThresh = gpuThreshold;
-    let rustWasmThresh = rustWasmThreshold;
     if (operation && operationThresholds?.[operation]) {
       const opThresh = operationThresholds[operation];
       if (opThresh?.wasm !== void 0) wasmThresh = opThresh.wasm;
       if (opThresh?.gpu !== void 0) gpuThresh = opThresh.gpu;
-      if (opThresh?.rustWasm !== void 0) rustWasmThresh = opThresh.rustWasm;
     }
     if (elementCount >= gpuThresh && backendRegistry.has("gpu")) {
       const gpuBackend = backendRegistry.get("gpu");
       if (gpuBackend) return gpuBackend;
     }
-    if (elementCount >= rustWasmThresh && backendRegistry.has("rust-wasm")) {
-      const rustBackend = backendRegistry.get("rust-wasm");
-      if (rustBackend) return rustBackend;
-    }
     if (elementCount >= wasmThresh && backendRegistry.has("wasm")) {
       const wasmBackend2 = backendRegistry.get("wasm");
       if (wasmBackend2) return wasmBackend2;
@@ -6102,7 +5480,6 @@ var BackendManager = class {
       const backendUsage = {
         js: 0,
         wasm: 0,
-        "rust-wasm": 0,
         gpu: 0,
         parallel: 0
       };
@@ -6140,31 +5517,6 @@ var AS_ID_ARRAY_BUFFER2 = 1;
 var AS_ID_INT32_ARRAY2 = 4;
 var AS_ID_FLOAT64_ARRAY2 = 5;
 var AS_HEADER_BYTES2 = 12;
-var RustBumpAllocator = class {
-  offset;
-  base;
-  constructor(baseOffset) {
-    this.base = baseOffset;
-    this.offset = baseOffset;
-  }
-  alloc(byteLength, memory) {
-    const aligned = this.offset + 7 & ~7;
-    const end = aligned + byteLength;
-    const currentBytes = memory.buffer.byteLength;
-    if (end > currentBytes) {
-      const pagesNeeded = Math.ceil((end - currentBytes) / 65536);
-      memory.grow(pagesNeeded);
-    }
-    this.offset = end;
-    return aligned;
-  }
-  reset() {
-    this.offset = this.base;
-  }
-  get highWaterMark() {
-    return this.offset;
-  }
-};
 var WasmLoader = class _WasmLoader {
   static instance = null;
   wasmModule = null;
@@ -6172,11 +5524,7 @@ var WasmLoader = class _WasmLoader {
   loading = null;
   isNode;
   lastMetrics = null;
-  // Discriminant chosen at load() time. Null before load().
-  allocatorKind = null;
-  // Rust path: a bump allocator anchored at __heap_base.
-  rustAllocator = null;
-  // Memory pool for AS allocations (Rust does not use these pools).
+  // Memory pool for AS allocations.
   float64Pool = [];
   int32Pool = [];
   poolSizeThreshold = 1024 * 1024;
@@ -6202,7 +5550,6 @@ var WasmLoader = class _WasmLoader {
     }
     this.loading = this.loadModule(wasmPath);
     this.wasmModule = await this.loading;
-    this.detectAllocatorKind(this.wasmModule);
     return this.wasmModule;
   }
   /**
@@ -6262,15 +5609,15 @@ var WasmLoader = class _WasmLoader {
     }
   }
   /**
-   * Get the WASM binary path based on the selected backend.
-   * Set MATHTS_WASM_BACKEND=assemblyscript to use the AS binary.
-   * Default is Rust (after migration cutover).
+   * Get the WASM binary path. AssemblyScript is the sole WASM backend
+   * (`mathts-as.wasm`); the legacy second toolchain was removed in the
+   * WASM-backend migration (complete 2026-06-26).
    *
    * The path is resolved relative to this source file's location so it is
    * CWD-independent.  This file lives at:
    *   <repo-root>/matrix/src/backends/WasmLoader.ts
    * so the repo root is three directories up, and the artifact is at
-   *   <repo-root>/lib/wasm/mathts[‑as].wasm
+   *   <repo-root>/lib/wasm/mathts-as.wasm
    *
    * Both branches use `new URL(relative, import.meta.url)` to resolve a
    * file: URL. In Node we convert via `fileURLToPath` (which correctly
@@ -6278,8 +5625,7 @@ var WasmLoader = class _WasmLoader {
    * doubled); in the browser we keep the full `.href` for fetch().
    */
   async getDefaultWasmPath() {
-    const useAS = typeof process !== "undefined" && process.env?.MATHTS_WASM_BACKEND === "assemblyscript";
-    const wasmFile = useAS ? "mathts-as.wasm" : "mathts.wasm";
+    const wasmFile = "mathts-as.wasm";
     if (this.isNode) {
       const { resolvePackagedWasm } = await import("./resolve-JRHDDNVQ.js");
       const found = await resolvePackagedWasm(import.meta.url, wasmFile);
@@ -6364,30 +5710,6 @@ var WasmLoader = class _WasmLoader {
       Date
     };
   }
-  /**
-   * Inspect a freshly loaded module and set up the allocator path.
-   *
-   * Discriminant: the AssemblyScript managed runtime exports `__new`. The
-   * Rust artifact does not. We branch on that exactly once at load time and
-   * cache the result so the hot path doesn't have to re-detect.
-   */
-  detectAllocatorKind(module) {
-    const hasManagedRuntime = typeof module.__new === "function";
-    if (hasManagedRuntime) {
-      this.allocatorKind = "as";
-      this.rustAllocator = null;
-      return;
-    }
-    this.allocatorKind = "rust";
-    const heapBaseGlobal = module.__heap_base;
-    let heapBase = 65536;
-    if (typeof heapBaseGlobal === "number") {
-      heapBase = heapBaseGlobal;
-    } else if (heapBaseGlobal && typeof heapBaseGlobal.value === "number") {
-      heapBase = heapBaseGlobal.value;
-    }
-    this.rustAllocator = new RustBumpAllocator(heapBase);
-  }
   /**
    * Get the loaded WASM module
    */
@@ -6412,28 +5734,6 @@ var WasmLoader = class _WasmLoader {
   isPrecompiled() {
     return this.compiledModule !== null;
   }
-  /**
-   * Allocator kind (rust/as) chosen at load-time.
-   * Returns null before load() has resolved.
-   */
-  getAllocatorKind() {
-    return this.allocatorKind;
-  }
-  /**
-   * Reset the Rust bump allocator's high-water mark.
-   *
-   * This is a coarse batch-free for the Rust path: every previously
-   * allocated pointer becomes invalid. Use only when no pointers are still
-   * in flight (e.g. between matrix operations that explicitly free their
-   * own scratch).
-   *
-   * No-op on the AS path; AS uses per-allocation pin/unpin via release().
-   */
-  resetRustAllocator() {
-    if (this.allocatorKind === "rust" && this.rustAllocator) {
-      this.rustAllocator.reset();
-    }
-  }
   /**
    * Get loading performance metrics
    */
@@ -6443,35 +5743,48 @@ var WasmLoader = class _WasmLoader {
   // ===========================================================================
   // Allocation API
   // ---------------------------------------------------------------------------
-  // All allocation methods branch on `allocatorKind`. The returned handle's
-  // `ptr` is always the value that should be passed to WASM functions.
+  // The returned handle's `ptr` is the header pointer to pass to WASM
+  // functions (AssemblyScript managed runtime).
   // ===========================================================================
   /**
    * Allocate Float64Array in WASM memory and copy `data` into it.
-   * Uses memory pooling on the AS path.
+   * Uses memory pooling.
    */
   allocateFloat64Array(data) {
     const module = this.wasmModule;
     if (!module) throw new Error("WASM module not loaded");
     const length = data.length;
-    if (this.allocatorKind === "rust") {
-      const alloc2 = this.allocateRustFloat64(module, length);
-      alloc2.array.set(data);
-      return alloc2;
-    }
     const alloc = this.allocateAsFloat64(module, length);
     alloc.array.set(data);
     return alloc;
   }
+  /**
+   * Decode a managed Float64Array RETURNED by an AssemblyScript export
+   * (e.g. `matrix_svd`, `matrix_eig_symmetric`) into a fresh JS copy.
+   *
+   * AS exports that return a `Float64Array` hand back the typed-array
+   * *header* pointer. The header is a 12-byte block laid out as
+   * `[buffer, dataStart, byteLength]` (little-endian u32s) — the same shape
+   * the loader writes in `makeAsFloat64`. We read `dataStart`/`byteLength`
+   * and copy the data region out so it survives any later reuse of WASM
+   * memory.
+   */
+  readReturnedFloat64Array(headerPtr) {
+    const module = this.wasmModule;
+    if (!module) throw new Error("WASM module not loaded");
+    const hdr = headerPtr >>> 0;
+    const dv = new DataView(module.memory.buffer);
+    const dataStart = dv.getUint32(hdr + 4, true);
+    const byteLength = dv.getUint32(hdr + 8, true);
+    const view = new Float64Array(module.memory.buffer, dataStart, byteLength >>> 3);
+    return new Float64Array(view);
+  }
   /**
    * Allocate Float64Array without copying data (for output buffers)
    */
   allocateFloat64ArrayEmpty(length) {
     const module = this.wasmModule;
     if (!module) throw new Error("WASM module not loaded");
-    if (this.allocatorKind === "rust") {
-      return this.allocateRustFloat64(module, length);
-    }
     return this.allocateAsFloat64(module, length);
   }
   /**
@@ -6481,11 +5794,6 @@ var WasmLoader = class _WasmLoader {
     const module = this.wasmModule;
     if (!module) throw new Error("WASM module not loaded");
     const length = data.length;
-    if (this.allocatorKind === "rust") {
-      const alloc2 = this.allocateRustInt32(module, length);
-      alloc2.array.set(data);
-      return alloc2;
-    }
     const alloc = this.allocateAsInt32(module, length);
     alloc.array.set(data);
     return alloc;
@@ -6496,29 +5804,9 @@ var WasmLoader = class _WasmLoader {
   allocateInt32ArrayEmpty(length) {
     const module = this.wasmModule;
     if (!module) throw new Error("WASM module not loaded");
-    if (this.allocatorKind === "rust") {
-      return this.allocateRustInt32(module, length);
-    }
     return this.allocateAsInt32(module, length);
   }
-  // ---- Rust path (flat memory + bump allocator) --------------------------
-  allocateRustFloat64(module, length) {
-    const allocator = this.rustAllocator;
-    if (!allocator) throw new Error("Rust allocator not initialized");
-    const byteLength = length * 8;
-    const ptr = allocator.alloc(byteLength, module.memory);
-    const array = new Float64Array(module.memory.buffer, ptr, length);
-    return { kind: "rust", ptr, dataPtr: ptr, array, length };
-  }
-  allocateRustInt32(module, length) {
-    const allocator = this.rustAllocator;
-    if (!allocator) throw new Error("Rust allocator not initialized");
-    const byteLength = length * 4;
-    const ptr = allocator.alloc(byteLength, module.memory);
-    const array = new Int32Array(module.memory.buffer, ptr, length);
-    return { kind: "rust", ptr, dataPtr: ptr, array, length };
-  }
-  // ---- AS path (managed runtime + header pointers) -----------------------
+  // ---- AS managed runtime (header pointers) ------------------------------
   allocateAsFloat64(module, length) {
     const byteLength = length * 8;
     if (byteLength <= this.poolSizeThreshold) {
@@ -6526,7 +5814,6 @@ var WasmLoader = class _WasmLoader {
       if (recycled) {
         const array = new Float64Array(module.memory.buffer, recycled.dataPtr, length);
         return {
-          kind: "as",
           ptr: recycled.ptr,
           dataPtr: recycled.dataPtr,
           array,
@@ -6543,7 +5830,6 @@ var WasmLoader = class _WasmLoader {
       if (recycled) {
         const array = new Int32Array(module.memory.buffer, recycled.dataPtr, length);
         return {
-          kind: "as",
           ptr: recycled.ptr,
           dataPtr: recycled.dataPtr,
           array,
@@ -6563,7 +5849,7 @@ var WasmLoader = class _WasmLoader {
     dv.setUint32(headerPtr + 4, bufferPtr, true);
     dv.setUint32(headerPtr + 8, byteLength, true);
     const array = new Float64Array(module.memory.buffer, bufferPtr, length);
-    return { kind: "as", ptr: headerPtr, dataPtr: bufferPtr, array, length };
+    return { ptr: headerPtr, dataPtr: bufferPtr, array, length };
   }
   makeAsInt32(module, length) {
     const byteLength = length * 4;
@@ -6575,7 +5861,7 @@ var WasmLoader = class _WasmLoader {
     dv.setUint32(headerPtr + 4, bufferPtr, true);
     dv.setUint32(headerPtr + 8, byteLength, true);
     const array = new Int32Array(module.memory.buffer, bufferPtr, length);
-    return { kind: "as", ptr: headerPtr, dataPtr: bufferPtr, array, length };
+    return { ptr: headerPtr, dataPtr: bufferPtr, array, length };
   }
   /**
    * Find a pool entry whose data region is large enough; returns null when
@@ -6605,9 +5891,6 @@ var WasmLoader = class _WasmLoader {
    * automatically.
    */
   release(ptr, isFloat64 = true) {
-    if (this.allocatorKind === "rust") {
-      return;
-    }
     const pool = isFloat64 ? this.float64Pool : this.int32Pool;
     const entry = pool.find((e) => e.ptr === ptr);
     if (entry) {
@@ -6617,17 +5900,11 @@ var WasmLoader = class _WasmLoader {
     this.free(ptr);
   }
   /**
-   * Free allocated memory (immediate, bypasses pool).
-   *
-   * - Rust path: no-op (use `resetRustAllocator`).
-   * - AS path: unpin the header pointer.
+   * Free allocated memory (immediate, bypasses pool): unpin the header pointer.
    */
   free(ptr) {
     const module = this.wasmModule;
     if (!module) return;
-    if (this.allocatorKind === "rust") {
-      return;
-    }
     this.float64Pool = this.float64Pool.filter((e) => e.ptr !== ptr);
     this.int32Pool = this.int32Pool.filter((e) => e.ptr !== ptr);
     if (typeof module.__unpin === "function") {
@@ -6640,7 +5917,7 @@ var WasmLoader = class _WasmLoader {
   clearPool() {
     const module = this.wasmModule;
     if (!module) return;
-    if (this.allocatorKind === "as" && typeof module.__unpin === "function") {
+    if (typeof module.__unpin === "function") {
       for (const entry of this.float64Pool) {
         module.__unpin(entry.ptr);
       }
@@ -6650,9 +5927,6 @@ var WasmLoader = class _WasmLoader {
     }
     this.float64Pool = [];
     this.int32Pool = [];
-    if (this.allocatorKind === "rust" && this.rustAllocator) {
-      this.rustAllocator.reset();
-    }
   }
   /**
    * Get pool statistics
@@ -6676,12 +5950,12 @@ var WasmLoader = class _WasmLoader {
     };
   }
   /**
-   * Run garbage collection (AS path only).
+   * Run garbage collection.
    */
   collect() {
     const module = this.wasmModule;
     if (!module) return;
-    if (this.allocatorKind === "as" && typeof module.__collect === "function") {
+    if (typeof module.__collect === "function") {
       module.__collect();
     }
   }
@@ -6694,8 +5968,6 @@ var WasmLoader = class _WasmLoader {
     this.compiledModule = null;
     this.loading = null;
     this.lastMetrics = null;
-    this.allocatorKind = null;
-    this.rustAllocator = null;
   }
 };
 var wasmLoader = WasmLoader.getInstance();
@@ -6703,69 +5975,6 @@ var wasmLoader = WasmLoader.getInstance();
 // src/operations/svd.ts
 var DEFAULT_MAX_ITERATIONS = 1e3;
 var DEFAULT_TOLERANCE = 1e-12;
-function eye(n) {
-  const I = Array.from({ length: n }, () => new Array(n).fill(0));
-  for (let i = 0; i < n; i++) {
-    I[i][i] = 1;
-  }
-  return I;
-}
-function cloneMatrix(A) {
-  return A.map((row2) => [...row2]);
-}
-function householder(x) {
-  const n = x.length;
-  let sigma = 0;
-  for (let i = 1; i < n; i++) {
-    sigma += x[i] * x[i];
-  }
-  const v = [...x];
-  v[0] = 1;
-  if (sigma === 0 && x[0] >= 0) {
-    return { v, beta: 0 };
-  } else if (sigma === 0 && x[0] < 0) {
-    return { v, beta: -2 };
-  } else {
-    const mu = Math.sqrt(x[0] * x[0] + sigma);
-    if (x[0] <= 0) {
-      v[0] = x[0] - mu;
-    } else {
-      v[0] = -sigma / (x[0] + mu);
-    }
-    const beta = 2 * v[0] * v[0] / (sigma + v[0] * v[0]);
-    const v0 = v[0];
-    for (let i = 0; i < n; i++) {
-      v[i] /= v0;
-    }
-    return { v, beta };
-  }
-}
-function applyHouseholderLeft(A, v, beta, startRow, startCol, _endRow, endCol) {
-  const len = v.length;
-  for (let j = startCol; j < endCol; j++) {
-    let dot = 0;
-    for (let i = 0; i < len; i++) {
-      dot += v[i] * A[startRow + i][j];
-    }
-    dot *= beta;
-    for (let i = 0; i < len; i++) {
-      A[startRow + i][j] -= dot * v[i];
-    }
-  }
-}
-function applyHouseholderRight(A, v, beta, startRow, startCol, endRow, _endCol) {
-  const len = v.length;
-  for (let i = startRow; i < endRow; i++) {
-    let dot = 0;
-    for (let j = 0; j < len; j++) {
-      dot += A[i][startCol + j] * v[j];
-    }
-    dot *= beta;
-    for (let j = 0; j < len; j++) {
-      A[i][startCol + j] -= dot * v[j];
-    }
-  }
-}
 function bidiagonalize(A) {
   const m = A.length;
   const n = A[0].length;
@@ -6781,8 +5990,8 @@ function bidiagonalize(A) {
       }
       const { v, beta } = householder(col);
       if (beta !== 0) {
-        applyHouseholderLeft(B2, v, beta, k, k, m, n);
-        applyHouseholderRight(U, v, beta, 0, k, m, m);
+        applyHouseholderLeft(B2, v, beta, k, k);
+        applyHouseholderRight(U, v, beta, 0, k);
       }
     }
     if (k < n - 2) {
@@ -6792,8 +6001,8 @@ function bidiagonalize(A) {
       }
       const { v, beta } = householder(row2);
       if (beta !== 0) {
-        applyHouseholderRight(B2, v, beta, k, k + 1, m, n);
-        applyHouseholderRight(V, v, beta, 0, k + 1, n, n);
+        applyHouseholderRight(B2, v, beta, k, k + 1);
+        applyHouseholderRight(V, v, beta, 0, k + 1);
       }
     }
   }
@@ -7055,19 +6264,6 @@ function normFro(matrix2) {
 
 // src/operations/eig-wasm.ts
 var WASM_EIG_THRESHOLD = 8;
-function isSymmetric(matrix2, tolerance = 1e-10) {
-  const n = matrix2.length;
-  if (n === 0) return true;
-  if (matrix2[0].length !== n) return false;
-  for (let i = 0; i < n; i++) {
-    for (let j = i + 1; j < n; j++) {
-      if (Math.abs(matrix2[i][j] - matrix2[j][i]) > tolerance) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
 function flattenMatrix(matrix2) {
   const n = matrix2.length;
   const flat2 = new Float64Array(n * n);
@@ -7088,72 +6284,81 @@ async function eigWasm(matrix2, options) {
       throw new Error("Matrix must be square");
     }
   }
-  const wasmModule = wasmLoader.getModule();
+  let module = wasmLoader.getModule();
+  if (!module) {
+    try {
+      module = await wasmLoader.load();
+    } catch {
+      module = null;
+    }
+  }
   const symmetric = isSymmetric(matrix2);
-  if (!wasmModule || n < WASM_EIG_THRESHOLD || !symmetric) {
+  const useSymWasm = !!module && n >= WASM_EIG_THRESHOLD && symmetric && typeof module.matrix_eig_symmetric === "function";
+  const useGenWasm = !!module && n >= WASM_EIG_THRESHOLD && !symmetric && typeof module.matrix_eig_general === "function";
+  if (!useSymWasm && !useGenWasm) {
     return eig(matrix2, options);
   }
-  const tolerance = options?.tolerance ?? 1e-12;
   const computeVectors = options?.computeVectors ?? true;
+  const identityVectors = () => Array.from({ length: n }, (_, i) => {
+    const row2 = new Array(n).fill(0);
+    row2[i] = 1;
+    return row2;
+  });
   const flatMatrix = flattenMatrix(matrix2);
   const matrixAlloc = wasmLoader.allocateFloat64Array(Array.from(flatMatrix));
-  const eigenvaluesAlloc = wasmLoader.allocateFloat64ArrayEmpty(n);
-  const eigenvectorsAlloc = computeVectors ? wasmLoader.allocateFloat64ArrayEmpty(n * n) : { ptr: 0, array: new Float64Array(0) };
-  const workAlloc = wasmLoader.allocateFloat64ArrayEmpty(2 * n);
   try {
-    const iterations = wasmModule.eigsSymmetric(
-      matrixAlloc.ptr,
-      n,
-      tolerance,
-      eigenvaluesAlloc.ptr,
-      computeVectors ? eigenvectorsAlloc.ptr : 0,
-      workAlloc.ptr
-    );
-    if (iterations < 0) {
+    if (useSymWasm) {
+      const packedPtr2 = module.matrix_eig_symmetric(matrixAlloc.ptr, n);
+      const packed2 = wasmLoader.readReturnedFloat64Array(packedPtr2);
+      if (packed2.length < n + n * n) {
+        return eig(matrix2, options);
+      }
+      const values2 = [];
+      for (let j = 0; j < n; j++) {
+        values2.push({ re: packed2[j], im: 0 });
+      }
+      let vectors2;
+      if (computeVectors) {
+        vectors2 = [];
+        for (let j = 0; j < n; j++) {
+          const vec = [];
+          for (let i = 0; i < n; i++) {
+            vec.push(packed2[n + i * n + j]);
+          }
+          vectors2.push(vec);
+        }
+      } else {
+        vectors2 = identityVectors();
+      }
+      return { values: values2, vectors: vectors2, isSymmetric: true };
+    }
+    const packedPtr = module.matrix_eig_general(matrixAlloc.ptr, n);
+    const packed = wasmLoader.readReturnedFloat64Array(packedPtr);
+    if (packed.length < 2 * n + n * n) {
       return eig(matrix2, options);
     }
-    const module = wasmLoader.getModule();
-    const eigenvaluesResult = new Float64Array(module.memory.buffer, eigenvaluesAlloc.ptr, n);
     const values = [];
-    for (let i = 0; i < n; i++) {
-      values.push({ re: eigenvaluesResult[i], im: 0 });
+    for (let j = 0; j < n; j++) {
+      values.push({ re: packed[j], im: packed[n + j] });
     }
     let vectors;
     if (computeVectors) {
-      const eigenvectorsResult = new Float64Array(
-        module.memory.buffer,
-        eigenvectorsAlloc.ptr,
-        n * n
-      );
       vectors = [];
-      for (let i = 0; i < n; i++) {
+      for (let j = 0; j < n; j++) {
         const vec = [];
-        for (let j = 0; j < n; j++) {
-          vec.push(eigenvectorsResult[i * n + j]);
+        for (let i = 0; i < n; i++) {
+          vec.push(packed[2 * n + i * n + j]);
         }
         vectors.push(vec);
       }
     } else {
-      vectors = Array.from({ length: n }, (_, i) => {
-        const row2 = new Array(n).fill(0);
-        row2[i] = 1;
-        return row2;
-      });
+      vectors = identityVectors();
     }
-    return {
-      values,
-      vectors,
-      isSymmetric: true
-    };
+    return { values, vectors, isSymmetric: false };
   } catch {
     return eig(matrix2, options);
   } finally {
     wasmLoader.free(matrixAlloc.ptr);
-    wasmLoader.free(eigenvaluesAlloc.ptr);
-    if (computeVectors && eigenvectorsAlloc.ptr !== 0) {
-      wasmLoader.free(eigenvectorsAlloc.ptr);
-    }
-    wasmLoader.free(workAlloc.ptr);
   }
 }
 async function eigvalsWasm(matrix2, options) {
@@ -7162,33 +6367,29 @@ async function eigvalsWasm(matrix2, options) {
 }
 async function spectralRadiusWasm(matrix2, options) {
   const n = matrix2.length;
-  const wasmModule = wasmLoader.getModule();
-  if (!wasmModule || n < WASM_EIG_THRESHOLD) {
-    const { powerIteration: powerIteration2 } = await import("./eig-A5GJGSJJ.js");
+  let module = wasmLoader.getModule();
+  if (!module) {
+    try {
+      module = await wasmLoader.load();
+    } catch {
+      module = null;
+    }
+  }
+  if (!module || n < WASM_EIG_THRESHOLD || typeof module.matrix_spectral_radius !== "function") {
+    const { powerIteration: powerIteration2 } = await import("./eig-G72TLEBA.js");
     const result = powerIteration2(matrix2, options);
     return Math.abs(result.value);
   }
-  const maxIterations = options?.maxIterations ?? 1e3;
-  const tolerance = options?.tolerance ?? 1e-12;
   const flatMatrix = flattenMatrix(matrix2);
   const matrixAlloc = wasmLoader.allocateFloat64Array(Array.from(flatMatrix));
-  const workAlloc = wasmLoader.allocateFloat64ArrayEmpty(2 * n);
   try {
-    const radius = wasmModule.spectralRadius(
-      matrixAlloc.ptr,
-      n,
-      workAlloc.ptr,
-      maxIterations,
-      tolerance
-    );
-    return radius;
+    return module.matrix_spectral_radius(matrixAlloc.ptr, n);
   } catch {
-    const { powerIteration: powerIteration2 } = await import("./eig-A5GJGSJJ.js");
+    const { powerIteration: powerIteration2 } = await import("./eig-G72TLEBA.js");
     const result = powerIteration2(matrix2, options);
     return Math.abs(result.value);
   } finally {
     wasmLoader.free(matrixAlloc.ptr);
-    wasmLoader.free(workAlloc.ptr);
   }
 }
 
@@ -7217,30 +6418,31 @@ async function svdWasm(matrix2, options) {
   }
   const k = Math.min(m, n);
   const rankTolerance = options?.rankTolerance ?? 1e-10;
-  const loader = RustWasmLoader.getInstance();
-  const ready = loader.isLoaded || await loader.load();
-  const wasm = ready ? loader.getExports() : null;
-  if (!wasm || typeof wasm.svd !== "function") {
+  let module = wasmLoader.getModule();
+  if (!module) {
+    try {
+      module = await wasmLoader.load();
+    } catch {
+      module = null;
+    }
+  }
+  if (!module || typeof module.matrix_svd !== "function") {
     return toThin(svd(matrix2, options), k, rankTolerance);
   }
+  const flat2 = new Float64Array(m * n);
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) flat2[i * n + j] = matrix2[i][j];
+  }
+  const aAlloc = wasmLoader.allocateFloat64Array(flat2);
   try {
-    loader.resetAllocator();
-    const flat2 = new Float64Array(m * n);
-    for (let i = 0; i < m; i++) {
-      for (let j = 0; j < n; j++) flat2[i * n + j] = matrix2[i][j];
-    }
-    const aPtr = loader.writeF64(flat2);
-    const uPtr = loader.allocF64(m * k);
-    const sPtr = loader.allocF64(k);
-    const vPtr = loader.allocF64(n * k);
-    const workPtr = loader.allocF64(wasm.svdWorkSize(m, n));
-    const status = wasm.svd(aPtr, m, n, uPtr, sPtr, vPtr, workPtr);
-    if (status < 0) {
+    const packedPtr = module.matrix_svd(aAlloc.ptr, m, n);
+    const packed = wasmLoader.readReturnedFloat64Array(packedPtr);
+    if (packed.length < m * k + k + n * k) {
       return toThin(svd(matrix2, options), k, rankTolerance);
     }
-    const uFlat = loader.readF64(uPtr, m * k);
-    const sFlat = loader.readF64(sPtr, k);
-    const vFlat = loader.readF64(vPtr, n * k);
+    const uFlat = packed.subarray(0, m * k);
+    const sFlat = packed.subarray(m * k, m * k + k);
+    const vFlat = packed.subarray(m * k + k, m * k + k + n * k);
     const U = [];
     for (let i = 0; i < m; i++) {
       U.push(Array.from(uFlat.subarray(i * k, i * k + k)));
@@ -7253,6 +6455,8 @@ async function svdWasm(matrix2, options) {
     return { U, S, V, rank: estimateRank(S, rankTolerance) };
   } catch {
     return toThin(svd(matrix2, options), k, rankTolerance);
+  } finally {
+    wasmLoader.free(aAlloc.ptr);
   }
 }
 
@@ -7499,55 +6703,6 @@ var B = [
   182,
   1
 ];
-function eye2(n) {
-  return Array.from(
-    { length: n },
-    (_, i) => Array.from({ length: n }, (_2, j) => i === j ? 1 : 0)
-  );
-}
-function matMul(A, B2) {
-  const m = A.length;
-  const p = A[0].length;
-  const n = B2[0].length;
-  const C = Array.from({ length: m }, () => new Array(n).fill(0));
-  for (let i = 0; i < m; i++) {
-    for (let k = 0; k < p; k++) {
-      const aik = A[i][k];
-      if (aik === 0) continue;
-      for (let j = 0; j < n; j++) C[i][j] += aik * B2[k][j];
-    }
-  }
-  return C;
-}
-function matAdd(A, B2) {
-  const n = A.length;
-  const r = Array.from(
-    { length: n },
-    (_, i) => Array.from({ length: n }, (_2, j) => A[i][j] + B2[i][j])
-  );
-  return r;
-}
-function matSub(A, B2) {
-  const n = A.length;
-  return Array.from(
-    { length: n },
-    (_, i) => Array.from({ length: n }, (_2, j) => A[i][j] - B2[i][j])
-  );
-}
-function matScale(A, c) {
-  return A.map((row2) => row2.map((v) => v * c));
-}
-function norm1(A) {
-  const m = A.length;
-  const n = A[0].length;
-  let maxColSum = 0;
-  for (let j = 0; j < n; j++) {
-    let colSum = 0;
-    for (let i = 0; i < m; i++) colSum += Math.abs(A[i][j]);
-    if (colSum > maxColSum) maxColSum = colSum;
-  }
-  return maxColSum;
-}
 function matSolve(M, N) {
   const n = M.length;
   const cols = N[0].length;
@@ -7576,7 +6731,7 @@ function matSolve(M, N) {
 }
 function pade13(A) {
   const n = A.length;
-  const I = eye2(n);
+  const I = eye(n);
   const A2 = matMul(A, A);
   const A4 = matMul(A2, A2);
   const A6 = matMul(A2, A4);
@@ -7637,63 +6792,18 @@ init_DenseMatrix();
 
 // src/operations/schur.ts
 init_DenseMatrix();
-function eye3(n) {
-  return Array.from({ length: n }, (_, i) => Array.from({ length: n }, (_2, j) => i === j ? 1 : 0));
-}
-function cloneMatrix2(A) {
-  return A.map((row2) => [...row2]);
-}
-function householder2(x) {
-  const n = x.length;
-  let sigma = 0;
-  for (let i = 1; i < n; i++) sigma += x[i] * x[i];
-  const v = [...x];
-  v[0] = 1;
-  if (sigma === 0 && x[0] >= 0) {
-    return { v, beta: 0 };
-  } else if (sigma === 0 && x[0] < 0) {
-    return { v, beta: 2 };
-  } else {
-    const mu = Math.sqrt(x[0] * x[0] + sigma);
-    v[0] = x[0] <= 0 ? x[0] - mu : -sigma / (x[0] + mu);
-    const beta = 2 * v[0] * v[0] / (sigma + v[0] * v[0]);
-    const v0 = v[0];
-    for (let i = 0; i < n; i++) v[i] /= v0;
-    return { v, beta };
-  }
-}
-function applyHouseholderLeft2(A, v, beta, startRow, startCol) {
-  const n = A[0].length;
-  const len = v.length;
-  for (let j = startCol; j < n; j++) {
-    let dot = 0;
-    for (let i = 0; i < len; i++) dot += v[i] * A[startRow + i][j];
-    dot *= beta;
-    for (let i = 0; i < len; i++) A[startRow + i][j] -= dot * v[i];
-  }
-}
-function applyHouseholderRight2(A, v, beta, startRow, startCol) {
-  const m = A.length;
-  const len = v.length;
-  for (let i = startRow; i < m; i++) {
-    let dot = 0;
-    for (let j = 0; j < len; j++) dot += A[i][startCol + j] * v[j];
-    dot *= beta;
-    for (let j = 0; j < len; j++) A[i][startCol + j] -= dot * v[j];
-  }
-}
 function hessenbergReduce(A) {
   const n = A.length;
-  const H = cloneMatrix2(A);
-  const Q = eye3(n);
+  const H = cloneMatrix(A);
+  const Q = eye(n);
   for (let k = 0; k < n - 2; k++) {
     const x = [];
     for (let i = k + 1; i < n; i++) x.push(H[i][k]);
-    const { v, beta } = householder2(x);
+    const { v, beta } = householder(x, 2);
     if (beta !== 0) {
-      applyHouseholderLeft2(H, v, beta, k + 1, k);
-      applyHouseholderRight2(H, v, beta, 0, k + 1);
-      applyHouseholderRight2(Q, v, beta, 0, k + 1);
+      applyHouseholderLeft(H, v, beta, k + 1, k);
+      applyHouseholderRight(H, v, beta, 0, k + 1);
+      applyHouseholderRight(Q, v, beta, 0, k + 1);
     }
   }
   for (let i = 0; i < n; i++)
@@ -7769,7 +6879,7 @@ function qrStepDouble(H, Q, start, end) {
   let y = H[start + 1][start] * (H[start][start] + H[start + 1][start + 1] - s);
   let z = H[start + 1][start] * H[start + 2][start + 1];
   for (let k = start; k <= end - 2; k++) {
-    const { v, beta } = householder2([x, y, z]);
+    const { v, beta } = householder([x, y, z], 2);
     const q = Math.max(start, k - 1);
     for (let j = q; j < n; j++) {
       let dot = v[0] * H[k][j] + v[1] * H[k + 1][j] + v[2] * H[k + 2][j];
@@ -7867,48 +6977,6 @@ function schurInternal(A, maxIterations = 1e3, tolerance = 1e-12) {
 }
 
 // src/operations/logm.ts
-function eye4(n) {
-  return Array.from(
-    { length: n },
-    (_, i) => Array.from({ length: n }, (_2, j) => i === j ? 1 : 0)
-  );
-}
-function matMul2(A, B2) {
-  const m = A.length;
-  const p = A[0].length;
-  const n = B2[0].length;
-  const C = Array.from({ length: m }, () => new Array(n).fill(0));
-  for (let i = 0; i < m; i++)
-    for (let k = 0; k < p; k++) {
-      const aik = A[i][k];
-      if (aik === 0) continue;
-      for (let j = 0; j < n; j++) C[i][j] += aik * B2[k][j];
-    }
-  return C;
-}
-function transpose2(A) {
-  const m = A.length;
-  const n = A[0].length;
-  return Array.from({ length: n }, (_, j) => Array.from({ length: m }, (_2, i) => A[i][j]));
-}
-function matScale2(A, c) {
-  return A.map((row2) => row2.map((v) => v * c));
-}
-function normInf(A) {
-  let mx = 0;
-  for (const row2 of A) for (const v of row2) if (Math.abs(v) > mx) mx = Math.abs(v);
-  return mx;
-}
-function norm12(A) {
-  const n = A[0].length;
-  let mx = 0;
-  for (let j = 0; j < n; j++) {
-    let s = 0;
-    for (const row2 of A) s += Math.abs(row2[j]);
-    if (s > mx) mx = s;
-  }
-  return mx;
-}
 function matInv(A) {
   const n = A.length;
   const M = A.map((row2, i) => {
@@ -7941,11 +7009,11 @@ function matInv(A) {
 }
 function matSqrt(A) {
   const n = A.length;
-  let Y = eye4(n);
+  let Y = eye(n);
   for (let iter = 0; iter < 150; iter++) {
     const Yinv = matInv(Y);
     if (Yinv === null) break;
-    const AYinv = matMul2(A, Yinv);
+    const AYinv = matMul(A, Yinv);
     const Ynew = Array.from(
       { length: n },
       (_, i) => Array.from({ length: n }, (_2, j) => (Y[i][j] + AYinv[i][j]) / 2)
@@ -8022,7 +7090,7 @@ function solveCol(M, b) {
 function logPade(X) {
   const n = X.length;
   const result = Array.from({ length: n }, () => new Array(n).fill(0));
-  const I = eye4(n);
+  const I = eye(n);
   for (let q = 0; q < GL16_NODES.length; q++) {
     const t = GL16_NODES[q];
     const w = GL16_WEIGHTS[q];
@@ -8055,24 +7123,6 @@ function sqrtUpperTriangular(T) {
   }
   return U;
 }
-function matMulArr(A, B2) {
-  const m = A.length;
-  const p = A[0].length;
-  const n = B2[0].length;
-  const C = Array.from({ length: m }, () => new Array(n).fill(0));
-  for (let i = 0; i < m; i++)
-    for (let k = 0; k < p; k++) {
-      const aik = A[i][k];
-      if (aik === 0) continue;
-      for (let j = 0; j < n; j++) C[i][j] += aik * B2[k][j];
-    }
-  return C;
-}
-function transposeArr(A) {
-  const m = A.length;
-  const n = A[0].length;
-  return Array.from({ length: n }, (_, j) => Array.from({ length: m }, (_2, i) => A[i][j]));
-}
 function isStrictlyUpperTriangular(T) {
   const n = T.length;
   for (let i = 1; i < n; i++) {
@@ -8092,21 +7142,21 @@ function logmSchur(A, tol) {
   const maxSqrt = 64;
   while (numSqrt < maxSqrt) {
     const MminI2 = M.map((row2, i) => row2.map((v, j) => v - (i === j ? 1 : 0)));
-    if (norm12(MminI2) < tol) break;
+    if (norm1(MminI2) < tol) break;
     const sqrtM = sqrtUpperTriangular(M);
     if (sqrtM === null || !isFinite(normInf(sqrtM))) break;
     M = sqrtM;
     numSqrt++;
   }
   const MminI = M.map((row2, i) => row2.map((v, j) => v - (i === j ? 1 : 0)));
-  if (norm12(MminI) >= tol) return null;
+  if (norm1(MminI) >= tol) return null;
   let logT = logPade(MminI);
   if (numSqrt > 0) {
     const scale2 = Math.pow(2, numSqrt);
     logT = logT.map((row2) => row2.map((v) => v * scale2));
   }
-  const Qt = transposeArr(Q);
-  return matMulArr(matMulArr(Q, logT), Qt);
+  const Qt = transpose(Q);
+  return matMul(matMul(Q, logT), Qt);
 }
 function validateEigenvalues(A) {
   const { values } = eig(A, { computeVectors: false });
@@ -8139,16 +7189,16 @@ function logmEig(A) {
     }
   }
   const V = vectors;
-  const Q = transpose2(V);
+  const Q = transpose(V);
   const Qinv = matInv(Q);
   if (Qinv === null) {
     throw new Error(
       "matrixLogm: eigenvector matrix is singular \u2014 matrix appears to be non-diagonalisable (Slice 5.9a limitation; full Schur-based implementation deferred to Slice 5.9b)"
     );
   }
-  const D = eye4(n);
+  const D = eye(n);
   for (let i = 0; i < n; i++) D[i][i] = Math.log(values[i].re);
-  return matMul2(matMul2(Q, D), Qinv);
+  return matMul(matMul(Q, D), Qinv);
 }
 function matrixLogm(A, opts) {
   const n = A.rows;
@@ -8168,7 +7218,7 @@ function matrixLogm(A, opts) {
   const maxSqrt = 64;
   while (numSqrt < maxSqrt) {
     const MminI2 = M.map((row2, i) => row2.map((v, j) => v - (i === j ? 1 : 0)));
-    if (norm12(MminI2) < tol) break;
+    if (norm1(MminI2) < tol) break;
     const sqrtM = matSqrt(M);
     if (!isFinite(normInf(sqrtM))) break;
     M = sqrtM;
@@ -8176,14 +7226,14 @@ function matrixLogm(A, opts) {
   }
   let logM;
   const MminI = M.map((row2, i) => row2.map((v, j) => v - (i === j ? 1 : 0)));
-  if (norm12(MminI) < tol) {
+  if (norm1(MminI) < tol) {
     logM = logPade(MminI);
   } else {
     logM = logmEig(Aarr);
     numSqrt = 0;
   }
   if (numSqrt > 0) {
-    logM = matScale2(logM, Math.pow(2, numSqrt));
+    logM = matScale(logM, Math.pow(2, numSqrt));
   }
   const data = new Float64Array(n * n);
   for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) data[i * n + j] = logM[i][j];
@@ -8192,30 +7242,6 @@ function matrixLogm(A, opts) {
 
 // src/operations/sqrtm.ts
 init_DenseMatrix();
-function eye5(n) {
-  return Array.from(
-    { length: n },
-    (_, i) => Array.from({ length: n }, (_2, j) => i === j ? 1 : 0)
-  );
-}
-function matMul3(A, B2) {
-  const m = A.length;
-  const p = A[0].length;
-  const n = B2[0].length;
-  const C = Array.from({ length: m }, () => new Array(n).fill(0));
-  for (let i = 0; i < m; i++)
-    for (let k = 0; k < p; k++) {
-      const aik = A[i][k];
-      if (aik === 0) continue;
-      for (let j = 0; j < n; j++) C[i][j] += aik * B2[k][j];
-    }
-  return C;
-}
-function transpose3(A) {
-  const m = A.length;
-  const n = A[0].length;
-  return Array.from({ length: n }, (_, j) => Array.from({ length: m }, (_2, i) => A[i][j]));
-}
 function symmetrize(A) {
   const n = A.length;
   return Array.from(
@@ -8288,20 +7314,20 @@ function sqrtmSymmetric(A) {
   }
   const Ynewton = sqrtmNewton(Asym);
   if (Ynewton !== null) return Ynewton;
-  const Qraw = transpose3(vectors);
+  const Qraw = transpose(vectors);
   const Q = gramSchmidt(Qraw);
-  const Qt = transpose3(Q);
-  const Dsqrt = eye5(n);
+  const Qt = transpose(Q);
+  const Dsqrt = eye(n);
   for (let i = 0; i < n; i++) Dsqrt[i][i] = Math.sqrt(Math.max(values[i].re, 0));
-  return matMul3(matMul3(Q, Dsqrt), Qt);
+  return matMul(matMul(Q, Dsqrt), Qt);
 }
 function sqrtmNewton(A) {
   const n = A.length;
-  let Y = eye5(n);
+  let Y = eye(n);
   for (let iter = 0; iter < 150; iter++) {
     const Yinv = matInv2(Y);
     if (Yinv === null) return null;
-    const AYinv = matMul3(A, Yinv);
+    const AYinv = matMul(A, Yinv);
     const Ynew = Array.from(
       { length: n },
       (_, i) => Array.from({ length: n }, (_2, j) => (Y[i][j] + AYinv[i][j]) / 2)
@@ -8312,7 +7338,7 @@ function sqrtmNewton(A) {
     Y = Ynew;
     if (diff < 1e-13) return Y;
   }
-  const Y2 = matMul3(Y, Y);
+  const Y2 = matMul(Y, Y);
   let err = 0;
   for (let i = 0; i < n; i++)
     for (let j = 0; j < n; j++) err = Math.max(err, Math.abs(Y2[i][j] - A[i][j]));
@@ -8336,16 +7362,16 @@ function sqrtmGeneral(A) {
   const Ynewton = sqrtmNewton(A);
   if (Ynewton !== null) return Ynewton;
   const V = vectors;
-  const Q = transpose3(V);
+  const Q = transpose(V);
   const Qinv = matInv2(Q);
   if (Qinv === null) {
     throw new Error(
       "matrixSqrtm: eigenvector matrix is singular \u2014 matrix appears to be non-diagonalisable"
     );
   }
-  const Dsqrt = eye5(n);
+  const Dsqrt = eye(n);
   for (let i = 0; i < n; i++) Dsqrt[i][i] = Math.sqrt(Math.max(values[i].re, 0));
-  return matMul3(matMul3(Q, Dsqrt), Qinv);
+  return matMul(matMul(Q, Dsqrt), Qinv);
 }
 function sqrtmQuasiTriangular(T) {
   const n = T.length;
@@ -8460,30 +7486,12 @@ function solveLinearSystem(A, b) {
   }
   return Aug.map((row2) => row2[n]);
 }
-function matMulArr2(A, B2) {
-  const m = A.length;
-  const p = A[0].length;
-  const n2 = B2[0].length;
-  const C = Array.from({ length: m }, () => new Array(n2).fill(0));
-  for (let i = 0; i < m; i++)
-    for (let k = 0; k < p; k++) {
-      const aik = A[i][k];
-      if (aik === 0) continue;
-      for (let j = 0; j < n2; j++) C[i][j] += aik * B2[k][j];
-    }
-  return C;
-}
-function transposeArr2(A) {
-  const m = A.length;
-  const n2 = A[0].length;
-  return Array.from({ length: n2 }, (_, j) => Array.from({ length: m }, (_2, i) => A[i][j]));
-}
 function sqrtmSchur(A) {
   const { H: T, Q } = schurInternal(A);
   const U = sqrtmQuasiTriangular(T);
   if (U === null) return null;
-  const Qt = transposeArr2(Q);
-  return matMulArr2(matMulArr2(Q, U), Qt);
+  const Qt = transpose(Q);
+  return matMul(matMul(Q, U), Qt);
 }
 function matrixSqrtm(A, opts) {
   const n = A.rows;
@@ -8589,7 +7597,7 @@ var unaryMinus = mathTyped("unaryMinus", {
   DenseMatrix: (a) => a.negate(),
   number: (a) => -a
 });
-var transpose4 = mathTyped("transpose", {
+var transpose3 = mathTyped("transpose", {
   DenseMatrix: (a) => a.transpose()
 });
 var sum2 = mathTyped("sum", {
@@ -8678,7 +7686,7 @@ var typedMatrixOperations = {
   dotMultiply,
   divide,
   unaryMinus,
-  transpose: transpose4,
+  transpose: transpose3,
   // Reductions
   sum: sum2,
   mean: mean2,
@@ -9359,8 +8367,6 @@ export {
   JSBackend,
   Matrix,
   ParallelBackend,
-  RustWASMBackend,
-  RustWasmLoader,
   ShaderManager,
   SparseMatrix,
   SyncManager,
@@ -9376,7 +8382,6 @@ export {
   createBackendManager,
   createGPUMatrixBackend,
   createParallelBackend,
-  createRustWASMBackend,
   createSyncManager,
   createWASMBackend,
   destroyGlobalGPU,
@@ -9399,7 +8404,6 @@ export {
   gpuMatrixBackend,
   hasWebGPU,
   identity,
-  initRustWasm,
   initializeGlobalGPUBackend,
   initializeParallelMatrix,
   isAtomicsAvailable,
@@ -9473,8 +8477,6 @@ export {
   qr,
   random,
   row,
-  rustWasmBackend,
-  rustWasmLoader,
   singularValues,
   size,
   spectralRadiusWasm,
@@ -9487,7 +8489,7 @@ export {
   svdWasm,
   terminateParallelMatrix,
   trace2 as trace,
-  transpose4 as transpose,
+  transpose3 as transpose,
   typedMatrixOperations,
   unaryMinus,
   wasmBackend,