@danielsimonjr/mathts-wasm 0.1.2 → 0.1.3

package/build/wasm-manifest.json

@@ -0,0 +1,4 @@
+{
+  "mathts-debug.wasm": "sha384-DWpIT/Aj2P6lTUCvEX4wZi/wIBBILesWJ2DnuRw6fp0PMj6b8aOwNkLHtL657y4z",
+  "mathts.wasm": "sha384-q/fiU1qnpj7vLiYnprGBDdO7on0S/Gnd5Pyql20PZxGfl9Jx0jdWPUGQe0FM91wo"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-wasm",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "MathTS WebAssembly module - high-performance numerical computing",
   "type": "module",
   "main": "build/release.js",
@@ -28,10 +28,11 @@
     "build:bindings": "tsc -p tsconfig.bindings.json",
     "build": "npm run asbuild && npm run build:bindings",
     "clean": "rm -rf build/",
-    "test": "node --experimental-wasm-simd tests/run.js",
+    "test": "node tests/run.js && node tests/svd.test.mjs && node tests/special-numtheory.test.mjs && node tests/polynomial.test.mjs && node tests/signal.test.mjs && node tests/linalg.test.mjs && node tests/curvefit.test.mjs && node tests/optimization.test.mjs && node tests/approx.test.mjs && node tests/tensor.test.mjs",
     "benchmark": "node --experimental-wasm-simd benchmarks/run.js"
   },
   "devDependencies": {
+    "@assemblyscript/loader": "^0.28.17",
     "assemblyscript": "^0.27.27",
     "typescript": "^5.3.0"
   },
@@ -45,11 +46,11 @@
     "linear-algebra",
     "simd"
   ],
-  "author": "MathTS Contributors",
+  "author": "Daniel Simon Jr.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/danielsimonjr/MathTS.git",
+    "url": "https://github.com/danielsimonjr/mathts",
     "directory": "assembly"
   },
   "bugs": {

package/src/bindings/wasm-loader.ts

@@ -3,8 +3,82 @@
  *
  * TypeScript bindings for loading and using the MathTS WASM module.
  * This provides a clean interface for JavaScript/TypeScript consumers.
+ *
+ * Security: optional SHA-384 integrity check via a sibling
+ * `wasm-manifest.json`. See verifyWasm() / loadManifest() below — kept
+ * inline rather than imported because the assembly package ships
+ * standalone (no functions/ dependency).
  */
 
+interface WasmManifest {
+  [fileName: string]: string;
+}
+
+async function sha384Base64(buffer: ArrayBuffer | Uint8Array): Promise<string> {
+  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+  const isNode = typeof process !== 'undefined' && (process as any).versions?.node !== undefined;
+  let digest: Uint8Array;
+  if (isNode) {
+    const { createHash } = await import('crypto');
+    const h = createHash('sha384');
+    h.update(bytes);
+    digest = new Uint8Array(h.digest());
+  } else {
+    // Copy into a fresh ArrayBuffer so SubtleCrypto.digest accepts the
+    // bytes regardless of the source backing (ArrayBuffer or SharedArrayBuffer).
+    const copy = new ArrayBuffer(bytes.byteLength);
+    new Uint8Array(copy).set(bytes);
+    const out = await crypto.subtle.digest('SHA-384', copy);
+    digest = new Uint8Array(out);
+  }
+  let bin = '';
+  for (let i = 0; i < digest.length; i++) bin += String.fromCharCode(digest[i]);
+  const b64 =
+    typeof btoa === 'function'
+      ? btoa(bin)
+      : (globalThis as any).Buffer.from(digest).toString('base64');
+  return `sha384-${b64}`;
+}
+
+async function loadManifest(wasmPath: string): Promise<WasmManifest | null> {
+  const manifestPath = wasmPath.replace(/[^/\\]+$/, 'wasm-manifest.json');
+  const isNode = typeof process !== 'undefined' && (process as any).versions?.node !== undefined;
+  try {
+    if (isNode) {
+      const fs = await import('fs');
+      const text = fs.readFileSync(manifestPath, 'utf8');
+      return JSON.parse(text) as WasmManifest;
+    } else {
+      const res = await fetch(manifestPath);
+      if (!res.ok) return null;
+      return (await res.json()) as WasmManifest;
+    }
+  } catch {
+    return null;
+  }
+}
+
+async function verifyWasm(buffer: ArrayBuffer | Uint8Array, wasmPath: string): Promise<void> {
+  const manifest = await loadManifest(wasmPath);
+  if (!manifest) {
+    if (typeof console !== 'undefined') {
+      console.warn(
+        `[wasm-integrity] no manifest found beside "${wasmPath}"; skipping SHA-384 verification`
+      );
+    }
+    return;
+  }
+  const fileName = wasmPath.split(/[/\\]/).pop() || wasmPath;
+  const expected = manifest[fileName];
+  if (!expected) return;
+  const actual = await sha384Base64(buffer);
+  if (actual !== expected) {
+    throw new Error(
+      `WASM integrity check failed for "${fileName}": expected ${expected}, got ${actual}`
+    );
+  }
+}
+
 // Type definitions for the WASM module exports
 export interface MathTSWasmExports {
   // Memory
@@ -30,11 +104,54 @@ export interface MathTSWasmExports {
   array_norm(dataPtr: number): number;
 
   // Matrix operations (pointers)
-  matrix_multiply(aPtr: number, aRows: number, aCols: number, bPtr: number, bCols: number, resultPtr: number): void;
+  matrix_multiply(
+    aPtr: number,
+    aRows: number,
+    aCols: number,
+    bPtr: number,
+    bCols: number,
+    resultPtr: number
+  ): void;
   matrix_transpose(aPtr: number, rows: number, cols: number, resultPtr: number): void;
   matrix_trace(dataPtr: number, rows: number, cols: number): number;
   matrix_norm_frobenius(dataPtr: number): number;
 
+  // Dense matrix decompositions — AS exports added in tandem with the
+  // Rust crate's `decomposition.rs` so the AS backend can stop falling
+  // back to JS for these ops. AS calling convention: pass typed-array
+  // *header* references (the AS runtime carries length, no ptr+len args).
+  // See `assembly/src/algebra/decomposition.ts` for the kernels.
+  matrix_lu_decompose?(
+    a: Float64Array,
+    n: number,
+    l_out: Float64Array,
+    u_out: Float64Array,
+    perm_out: Int32Array
+  ): number;
+  matrix_qr_decompose?(
+    a: Float64Array,
+    m: number,
+    n: number,
+    q_out: Float64Array,
+    r_out: Float64Array
+  ): number;
+  matrix_cholesky?(a: Float64Array, n: number, l_out: Float64Array): number;
+  matrix_inverse?(a: Float64Array, n: number, result: Float64Array, work: Float64Array): number;
+  matrix_determinant?(a: Float64Array, n: number, work: Float64Array): number;
+
+  // Bitwise operations (Int32Array, elementwise) — AS-backend kernels.
+  // The Rust backend ships an equivalent set under the `*Array` /
+  // `*ArrayPerElement` naming (declared in
+  // functions/src/wasm/WasmLoader.ts's interface); the AS kernels keep
+  // the `_i32_array` suffix to match AS export-name discoverability.
+  bitAnd_i32_array?(a: Int32Array, b: Int32Array, result: Int32Array): void;
+  bitOr_i32_array?(a: Int32Array, b: Int32Array, result: Int32Array): void;
+  bitXor_i32_array?(a: Int32Array, b: Int32Array, result: Int32Array): void;
+  bitNot_i32_array?(a: Int32Array, result: Int32Array): void;
+  leftShift_i32_array?(a: Int32Array, b: Int32Array, result: Int32Array): void;
+  rightArithShift_i32_array?(a: Int32Array, b: Int32Array, result: Int32Array): void;
+  rightLogShift_i32_array?(a: Int32Array, b: Int32Array, result: Int32Array): void;
+
   // Memory management
   __new(size: number, id: number): number;
   __pin(ptr: number): number;
@@ -58,16 +175,20 @@ export async function loadWasm(source: string | BufferSource): Promise<MathTSWas
     if (typeof fetch !== 'undefined') {
       const response = await fetch(source);
       const buffer = await response.arrayBuffer();
+      await verifyWasm(buffer, source);
       wasmModule = await WebAssembly.compile(buffer);
     } else {
       // Node.js environment
       const fs = await import('fs');
       const path = await import('path');
-      const buffer = fs.readFileSync(path.resolve(source));
+      const resolved = path.resolve(source);
+      const buffer = fs.readFileSync(resolved);
+      await verifyWasm(buffer, resolved);
       wasmModule = await WebAssembly.compile(buffer);
     }
   } else {
-    // Load from buffer
+    // Load from buffer — caller is responsible for verifying integrity
+    // since we have no path to locate a sibling manifest.
     wasmModule = await WebAssembly.compile(source);
   }
 
@@ -214,8 +335,8 @@ export class MathTSWasm {
     this.exports.__pin(ptr);
 
     const view = new DataView(this.memory.buffer);
-    view.setInt32(ptr, ptr + 16, true);     // data pointer
-    view.setInt32(ptr + 4, length, true);   // length
+    view.setInt32(ptr, ptr + 16, true); // data pointer
+    view.setInt32(ptr + 4, length, true); // length
 
     const array = new Float64Array(this.memory.buffer, ptr + 16, length);
     return { ptr, array };