@danielsimonjr/mathts-functions 0.64.3 → 0.65.0

package/dist/index.js

@@ -6,14 +6,16 @@ import {
   asReadReturnedI32,
   getWasm,
   isAsWasm,
+  isWasmLoaded,
+  loadWasm,
   makeUnaryArrayDispatch,
   runChainPtr,
   runUnaryPtr,
   sortF64Dispatch,
-  wasmLoader,
+  wasmPolicyAllows,
   withAsF64,
   withAsI32
-} from "./chunk-UMUT2YEC.js";
+} from "./chunk-5A2EZLXV.js";
 
 // src/typed/index.ts
 var typed_exports = {};
@@ -1342,7 +1344,7 @@ var WASM_ELEMENTWISE_THRESHOLD = 1024;
 var kernelName = (op) => `array_${op}_ptr`;
 function elementwiseUnaryDispatch(op, xs) {
   const n = xs.length;
-  if (n < WASM_ELEMENTWISE_THRESHOLD) return null;
+  if (n < WASM_ELEMENTWISE_THRESHOLD || !wasmPolicyAllows(kernelName(op), n)) return null;
   const wasm = getWasm();
   if (!wasm) return null;
   const fn = wasm[kernelName(op)];
@@ -1353,6 +1355,7 @@ function elementwiseUnaryDispatch(op, xs) {
 function elementwiseChainDispatch(ops, xs) {
   const n = xs.length;
   if (ops.length === 0 || n < WASM_ELEMENTWISE_THRESHOLD) return null;
+  if (!wasmPolicyAllows("fused_chain", n)) return null;
   const wasm = getWasm();
   if (!wasm) return null;
   const mem = wasm.memory;
@@ -3681,7 +3684,7 @@ function chirpZTransformJS(samples, m, phiStartRe, phiStartIm, phiStepRe, phiSte
 }
 function applyWindowDispatch(samples, windowName) {
   const wt = windowTypeCode(windowName);
-  const wasm = getWasm();
+  const wasm = wasmPolicyAllows("apply_window_f64", samples.length) ? getWasm() : null;
   if (wasm && isAsWasm(wasm)) {
     try {
       const out = withAsF64(wasm, [samples], (mod3, [h]) => {
@@ -3700,7 +3703,7 @@ function applyWindowDispatch(samples, windowName) {
 function welchPSDDispatch(samples, frameLength, overlap, windowName) {
   const n = samples.length;
   const wt = windowTypeCode(windowName);
-  if (n >= WASM_SIGNAL_THRESHOLD && n >= frameLength) {
+  if (n >= WASM_SIGNAL_THRESHOLD && n >= frameLength && wasmPolicyAllows("welch_psd_f64", n)) {
     const wasm = getWasm();
     if (wasm && isAsWasm(wasm)) {
       try {
@@ -3726,7 +3729,7 @@ function welchPSDDispatch(samples, frameLength, overlap, windowName) {
 }
 function bartlettPSDDispatch(samples, frameLength) {
   const n = samples.length;
-  if (n >= WASM_SIGNAL_THRESHOLD && n >= frameLength) {
+  if (n >= WASM_SIGNAL_THRESHOLD && n >= frameLength && wasmPolicyAllows("bartlett_psd_f64", n)) {
     const wasm = getWasm();
     if (wasm && isAsWasm(wasm)) {
       try {
@@ -3747,7 +3750,7 @@ function bartlettPSDDispatch(samples, frameLength) {
 }
 function goertzelDispatch(samples, targetFreq, sampleRate) {
   const n = samples.length;
-  if (n >= WASM_SIGNAL_THRESHOLD) {
+  if (n >= WASM_SIGNAL_THRESHOLD && wasmPolicyAllows("goertzel_f64", n)) {
     const wasm = getWasm();
     if (wasm && isAsWasm(wasm)) {
       try {
@@ -3769,7 +3772,7 @@ function goertzelDispatch(samples, targetFreq, sampleRate) {
 }
 function chirpZTransformDispatch(samples, m, phiStartRe, phiStartIm, phiStepRe, phiStepIm) {
   const n = samples.length;
-  if (Math.max(n, m) >= WASM_SIGNAL_THRESHOLD) {
+  if (Math.max(n, m) >= WASM_SIGNAL_THRESHOLD && wasmPolicyAllows("chirp_z_transform_f64", Math.max(n, m))) {
     const wasm = getWasm();
     if (wasm && isAsWasm(wasm)) {
       try {
@@ -3931,7 +3934,6 @@ function idwtPeriodization(approx, detail, wavelet) {
 }
 
 // src/typed/signal.ts
-var WASM_THRESHOLD = 64;
 function isPowerOf22(n) {
   return n > 0 && (n & n - 1) === 0;
 }
@@ -4212,23 +4214,6 @@ function unwrapPhase(phase) {
 }
 function dct(x) {
   const N2 = x.length;
-  if (N2 >= WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const inAlloc = wasmLoader.allocateFloat64Array(x);
-        const outAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
-        try {
-          wasm.dct_wasm(inAlloc.ptr, outAlloc.ptr, N2);
-          return Array.from(outAlloc.array);
-        } finally {
-          wasmLoader.free(inAlloc.ptr);
-          wasmLoader.free(outAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   const result = new Array(N2);
   for (let k = 0; k < N2; k++) {
     let sum3 = 0;
@@ -4241,23 +4226,6 @@ function dct(x) {
 }
 function idct(X) {
   const N2 = X.length;
-  if (N2 >= WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const inAlloc = wasmLoader.allocateFloat64Array(X);
-        const outAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
-        try {
-          wasm.idct_wasm(inAlloc.ptr, outAlloc.ptr, N2);
-          return Array.from(outAlloc.array);
-        } finally {
-          wasmLoader.free(inAlloc.ptr);
-          wasmLoader.free(outAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   const result = new Array(N2);
   for (let n = 0; n < N2; n++) {
     let sum3 = X[0] * Math.sqrt(1 / N2);
@@ -4270,23 +4238,6 @@ function idct(X) {
 }
 function dst(x) {
   const N2 = x.length;
-  if (N2 >= WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const inAlloc = wasmLoader.allocateFloat64Array(x);
-        const outAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
-        try {
-          wasm.dst_wasm(inAlloc.ptr, outAlloc.ptr, N2);
-          return Array.from(outAlloc.array);
-        } finally {
-          wasmLoader.free(inAlloc.ptr);
-          wasmLoader.free(outAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   const result = new Array(N2);
   for (let k = 0; k < N2; k++) {
     let sum3 = 0;
@@ -4299,23 +4250,6 @@ function dst(x) {
 }
 function idst(X) {
   const N2 = X.length;
-  if (N2 >= WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const inAlloc = wasmLoader.allocateFloat64Array(X);
-        const outAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
-        try {
-          wasm.idst_wasm(inAlloc.ptr, outAlloc.ptr, N2);
-          return Array.from(outAlloc.array);
-        } finally {
-          wasmLoader.free(inAlloc.ptr);
-          wasmLoader.free(outAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   const result = new Array(N2);
   for (let n = 0; n < N2; n++) {
     let sum3 = 0;
@@ -4332,28 +4266,6 @@ function dwt(x, wavelet = "haar") {
   if (n < 2) throw new Error("dwt: signal must have at least 2 samples");
   const half = Math.floor(n / 2);
   if (wavelet === "haar" || wavelet === "db1") {
-    if (n >= WASM_THRESHOLD && n % 2 === 0) {
-      const wasm = wasmLoader.getModule();
-      if (wasm) {
-        try {
-          const inAlloc = wasmLoader.allocateFloat64Array(x);
-          const approxAlloc = wasmLoader.allocateFloat64ArrayEmpty(half);
-          const detailAlloc = wasmLoader.allocateFloat64ArrayEmpty(half);
-          try {
-            wasm.dwt_wasm(inAlloc.ptr, approxAlloc.ptr, detailAlloc.ptr, n);
-            return {
-              approx: Array.from(approxAlloc.array),
-              detail: Array.from(detailAlloc.array)
-            };
-          } finally {
-            wasmLoader.free(inAlloc.ptr);
-            wasmLoader.free(approxAlloc.ptr);
-            wasmLoader.free(detailAlloc.ptr);
-          }
-        } catch {
-        }
-      }
-    }
     const approx = new Array(half);
     const detail = new Array(half);
     const s = 1 / Math.SQRT2;
@@ -4469,30 +4381,6 @@ function invFourier(F, omega, t) {
 function hilbertTransform(x) {
   const n = x.length;
   const N2 = nextPowerOf2(n);
-  if (N2 >= WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const paddedInput = new Array(N2).fill(0);
-        for (let i = 0; i < n; i++) paddedInput[i] = x[i];
-        const zeros4 = new Array(N2).fill(0);
-        const inReAlloc = wasmLoader.allocateFloat64Array(paddedInput);
-        const inImAlloc = wasmLoader.allocateFloat64Array(zeros4);
-        const outReAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
-        const outImAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
-        try {
-          wasm.hilbert_wasm(inReAlloc.ptr, inImAlloc.ptr, outReAlloc.ptr, outImAlloc.ptr, N2);
-          return Array.from(outImAlloc.array.slice(0, n));
-        } finally {
-          wasmLoader.free(inReAlloc.ptr);
-          wasmLoader.free(inImAlloc.ptr);
-          wasmLoader.free(outReAlloc.ptr);
-          wasmLoader.free(outImAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   const real = new Float64Array(N2);
   const imag = new Float64Array(N2);
   for (let i = 0; i < n; i++) real[i] = x[i];
@@ -4519,39 +4407,6 @@ async function spectrogram(x, opts) {
   const winType = opts?.window ?? "hann";
   const nfft = nextPowerOf2(windowSize);
   const nFreqs = nfft / 2 + 1;
-  if (x.length >= WASM_THRESHOLD && (winType === "hann" || winType === "hanning")) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const numFrames = Math.floor((x.length - windowSize) / hopSize) + 1;
-        if (numFrames > 0) {
-          const inAlloc = wasmLoader.allocateFloat64Array(x);
-          const outAlloc = wasmLoader.allocateFloat64ArrayEmpty(numFrames * nFreqs);
-          try {
-            const frames = wasm.spectrogram_wasm(
-              inAlloc.ptr,
-              outAlloc.ptr,
-              x.length,
-              windowSize,
-              hopSize
-            );
-            const magnitude2 = [];
-            const times2 = [];
-            const frequencies2 = Array.from({ length: nFreqs }, (_, i) => i / nfft);
-            for (let f = 0; f < frames; f++) {
-              magnitude2.push(Array.from(outAlloc.array.slice(f * nFreqs, (f + 1) * nFreqs)));
-              times2.push(f * hopSize + windowSize / 2);
-            }
-            return { magnitude: magnitude2, frequencies: frequencies2, times: times2 };
-          } finally {
-            wasmLoader.free(inAlloc.ptr);
-            wasmLoader.free(outAlloc.ptr);
-          }
-        }
-      } catch {
-      }
-    }
-  }
   const win = windowFunction(windowSize, winType);
   const magnitude = [];
   const times = [];
@@ -4609,26 +4464,6 @@ async function spectrogram(x, opts) {
 function periodogram(x, opts) {
   const nfft = opts?.nfft ?? nextPowerOf2(x.length);
   const winType = opts?.window ?? "hann";
-  if (x.length >= WASM_THRESHOLD && (winType === "hann" || winType === "hanning") && nfft === nextPowerOf2(x.length)) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const nFreqs2 = nfft / 2 + 1;
-        const inAlloc = wasmLoader.allocateFloat64Array(x);
-        const outAlloc = wasmLoader.allocateFloat64ArrayEmpty(nFreqs2);
-        try {
-          wasm.periodogram_wasm(inAlloc.ptr, outAlloc.ptr, x.length);
-          const psd2 = Array.from(outAlloc.array);
-          const frequencies2 = Array.from({ length: nFreqs2 }, (_, i) => i / nfft);
-          return { psd: psd2, frequencies: frequencies2 };
-        } finally {
-          wasmLoader.free(inAlloc.ptr);
-          wasmLoader.free(outAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   const win = windowFunction(x.length, winType);
   let winPower = 0;
   for (let i = 0; i < x.length; i++) winPower += win[i] * win[i];
@@ -4686,25 +4521,6 @@ function _sincFilter(order, cutoff, type) {
 function _convolve(x, h) {
   const n = x.length;
   const m = h.length;
-  if (n >= WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const inAlloc = wasmLoader.allocateFloat64Array(x);
-        const coeffAlloc = wasmLoader.allocateFloat64Array(h);
-        const outAlloc = wasmLoader.allocateFloat64ArrayEmpty(n);
-        try {
-          wasm.fir_filter_wasm(inAlloc.ptr, coeffAlloc.ptr, outAlloc.ptr, n, m);
-          return Array.from(outAlloc.array);
-        } finally {
-          wasmLoader.free(inAlloc.ptr);
-          wasmLoader.free(coeffAlloc.ptr);
-          wasmLoader.free(outAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   const offset = Math.floor(m / 2);
   const result = new Array(n).fill(0);
   for (let i = 0; i < n; i++) {
@@ -4917,10 +4733,11 @@ var UNARY_OPS = {
 };
 function runBinaryBitwiseWasm(op, a, b) {
   if (a.length !== b.length) return null;
+  const names = BINARY_OPS[op];
+  if (!wasmPolicyAllows(names.as, a.length)) return null;
   const wasm = getWasm();
   if (!wasm || !isAsWasm(wasm)) return null;
   const n = a.length;
-  const names = BINARY_OPS[op];
   try {
     return withAsI32(wasm, [a, b, new Int32Array(n)], (mod3, [ha, hb, hr]) => {
       mod3[names.as](ha, hb, hr);
@@ -4931,10 +4748,11 @@ function runBinaryBitwiseWasm(op, a, b) {
   }
 }
 function runUnaryBitwiseWasm(op, a) {
+  const names = UNARY_OPS[op];
+  if (!wasmPolicyAllows(names.as, a.length)) return null;
   const wasm = getWasm();
   if (!wasm || !isAsWasm(wasm)) return null;
   const n = a.length;
-  const names = UNARY_OPS[op];
   try {
     return withAsI32(wasm, [a, new Int32Array(n)], (mod3, [ha, hr]) => {
       mod3[names.as](ha, hr);
@@ -6657,7 +6475,7 @@ var besselJ1Dispatch = makeUnaryArrayDispatch({
 });
 function besselOrderDispatch(order, xs, asName, js) {
   const n = xs.length;
-  if (n >= WASM_SPECIAL_THRESHOLD) {
+  if (n >= WASM_SPECIAL_THRESHOLD && wasmPolicyAllows(asName, n)) {
     const wasm = getWasm();
     if (wasm && isAsWasm(wasm)) {
       try {
@@ -6919,7 +6737,7 @@ function ellipticPiIncompleteScalar(n, phi, m) {
 }
 function multiArrayDispatch(name254, inputs, js) {
   const n = inputs[0].length;
-  if (n >= WASM_SPECIAL_THRESHOLD) {
+  if (n >= WASM_SPECIAL_THRESHOLD && wasmPolicyAllows(name254, n)) {
     const wasm = getWasm();
     if (wasm && isAsWasm(wasm)) {
       try {
@@ -8573,8 +8391,6 @@ var typedDistributions = {
 
 // src/typed/geometry.ts
 import { computePool as computePool7 } from "@danielsimonjr/mathts-parallel";
-var GEOMETRY_WASM_THRESHOLD = 32;
-var HULL3D_WASM_THRESHOLD = 1024;
 function angle2D(v1, v2) {
   const dot9 = v1[0] * v2[0] + v1[1] * v2[1];
   const mag1 = Math.sqrt(v1[0] ** 2 + v1[1] ** 2);
@@ -8925,49 +8741,6 @@ function voronoiDiagram(points, bounds) {
       "voronoiDiagram: bounds must be a [xMin, yMin, xMax, yMax] tuple (the clipping box)"
     );
   }
-  const n = points.length;
-  if (n >= GEOMETRY_WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const flat = new Float64Array(n * 2);
-        for (let i = 0; i < n; i++) {
-          flat[i * 2] = points[i][0];
-          flat[i * 2 + 1] = points[i][1];
-        }
-        const ptsAlloc = wasmLoader.allocateFloat64Array(flat);
-        const boundsAlloc = wasmLoader.allocateFloat64Array(new Float64Array(bounds));
-        const maxVerts = 2 * n;
-        const maxEdges = 6 * n;
-        const vertsAlloc = wasmLoader.allocateFloat64ArrayEmpty(maxVerts * 2);
-        const edgesAlloc = wasmLoader.allocateInt32ArrayEmpty(maxEdges * 2);
-        try {
-          const packed = wasm.voronoi_wasm(
-            ptsAlloc.ptr,
-            n,
-            boundsAlloc.ptr,
-            vertsAlloc.ptr,
-            edgesAlloc.ptr,
-            maxVerts,
-            maxEdges
-          );
-          const numVerts = packed & 65535;
-          const vertices2 = [];
-          for (let i = 0; i < numVerts; i++) {
-            vertices2.push([vertsAlloc.array[i * 2], vertsAlloc.array[i * 2 + 1]]);
-          }
-          const regions2 = Array.from({ length: n }, () => []);
-          return { vertices: vertices2, regions: regions2 };
-        } finally {
-          wasmLoader.free(ptsAlloc.ptr);
-          wasmLoader.free(boundsAlloc.ptr);
-          wasmLoader.free(vertsAlloc.ptr);
-          wasmLoader.free(edgesAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   const triangles = delaunayTriangulation(points);
   const vertices = [];
   const triCircumcenters = /* @__PURE__ */ new Map();
@@ -9045,46 +8818,6 @@ function distanceNDSq(a, b) {
 function nearestNeighbor(points, query) {
   const n = points.length;
   if (n === 0) return null;
-  const dims = points[0].length;
-  if (n >= GEOMETRY_WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const flat = new Float64Array(n * dims);
-        for (let i = 0; i < n; i++) {
-          for (let d = 0; d < dims; d++) {
-            flat[i * dims + d] = points[i][d];
-          }
-        }
-        const ptsAlloc = wasmLoader.allocateFloat64Array(flat);
-        const stride = 3 + dims;
-        const treeAlloc = wasmLoader.allocateFloat64ArrayEmpty(n * stride);
-        const queryAlloc = wasmLoader.allocateFloat64Array(new Float64Array(query));
-        try {
-          const treeSize = wasm.kdtree_build_wasm(ptsAlloc.ptr, n, dims, treeAlloc.ptr);
-          const nearestIdx = wasm.kdtree_nearest_wasm(
-            treeAlloc.ptr,
-            queryAlloc.ptr,
-            dims,
-            treeSize
-          );
-          if (nearestIdx >= 0 && nearestIdx < n) {
-            const pt = points[nearestIdx];
-            let distSq = 0;
-            for (let d = 0; d < dims; d++) {
-              distSq += (pt[d] - query[d]) ** 2;
-            }
-            return { point: pt, index: nearestIdx, distance: Math.sqrt(distSq) };
-          }
-        } finally {
-          wasmLoader.free(ptsAlloc.ptr);
-          wasmLoader.free(treeAlloc.ptr);
-          wasmLoader.free(queryAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   const root2 = kdTree(points);
   return kdTreeNearest(root2, query);
 }
@@ -9093,45 +8826,6 @@ function convexHull3D(points) {
   if (n < 4) {
     throw new Error("convexHull3D: at least 4 non-coplanar points are required");
   }
-  if (n >= HULL3D_WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const flat = new Float64Array(n * 3);
-        for (let i = 0; i < n; i++) {
-          flat[i * 3] = points[i][0];
-          flat[i * 3 + 1] = points[i][1];
-          flat[i * 3 + 2] = points[i][2];
-        }
-        const ptsAlloc = wasmLoader.allocateFloat64Array(flat);
-        const maxFaces = 4 * n;
-        const facesAlloc = wasmLoader.allocateInt32ArrayEmpty(maxFaces * 3);
-        try {
-          const nFaces = wasm.convex_hull_3d_wasm(ptsAlloc.ptr, n, facesAlloc.ptr, maxFaces);
-          if (nFaces === -1) {
-            throw new Error("convexHull3D: WASM output buffer overflow \u2014 retrying with JS");
-          }
-          if (nFaces === 0) {
-            throw new Error("convexHull3D: degenerate input (all points co-planar or collinear)");
-          }
-          const result = [];
-          for (let i = 0; i < nFaces; i++) {
-            result.push([
-              facesAlloc.array[i * 3],
-              facesAlloc.array[i * 3 + 1],
-              facesAlloc.array[i * 3 + 2]
-            ]);
-          }
-          return result;
-        } finally {
-          wasmLoader.free(ptsAlloc.ptr);
-          wasmLoader.free(facesAlloc.ptr);
-        }
-      } catch (err) {
-        if (err instanceof Error && err.message.includes("degenerate")) throw err;
-      }
-    }
-  }
   return convexHull3DJS(points);
 }
 function convexHull3DJS(points) {
@@ -9309,7 +9003,7 @@ function polyDivModJS(num2, den) {
 }
 function polyMulDispatch(a, b) {
   const bigEnough = a.length >= WASM_POLY_THRESHOLD || b.length >= WASM_POLY_THRESHOLD;
-  if (bigEnough) {
+  if (bigEnough && wasmPolicyAllows("poly_mul_f64", Math.max(a.length, b.length))) {
     const wasm = getWasm();
     if (wasm && isAsWasm(wasm)) {
       try {
@@ -9328,7 +9022,7 @@ function polyMulDispatch(a, b) {
 function polyDivModDispatch(num2, den) {
   if (den.length === 0) throw new Error("Division by zero polynomial");
   const bigEnough = num2.length >= WASM_POLY_THRESHOLD;
-  if (bigEnough) {
+  if (bigEnough && wasmPolicyAllows("poly_div_mod_f64", num2.length)) {
     const wasm = getWasm();
     if (wasm && isAsWasm(wasm)) {
       try {
@@ -9431,7 +9125,7 @@ function discriminantJS(p) {
 }
 function resultantDispatch(p, q) {
   const bigEnough = p.length >= WASM_POLY_THRESHOLD || q.length >= WASM_POLY_THRESHOLD;
-  if (bigEnough) {
+  if (bigEnough && wasmPolicyAllows("poly_resultant_f64", Math.max(p.length, q.length))) {
     const wasm = getWasm();
     if (wasm && isAsWasm(wasm)) {
       try {
@@ -9449,7 +9143,7 @@ function resultantDispatch(p, q) {
 }
 function discriminantDispatch(p) {
   const bigEnough = p.length >= WASM_POLY_THRESHOLD;
-  if (bigEnough) {
+  if (bigEnough && wasmPolicyAllows("poly_discriminant_f64", p.length)) {
     const wasm = getWasm();
     if (wasm && isAsWasm(wasm)) {
       try {
@@ -9562,7 +9256,7 @@ function legendreFitJSFallback(xs, ys, degree3) {
 }
 function fitDispatch(xs, ys, degree3, asName, jsFallback) {
   if (xs.length !== ys.length) throw new Error("xs and ys must have the same length");
-  if (xs.length >= WASM_POLY_FIT_THRESHOLD) {
+  if (xs.length >= WASM_POLY_FIT_THRESHOLD && wasmPolicyAllows(asName, xs.length)) {
     const wasm = getWasm();
     if (wasm && isAsWasm(wasm)) {
       try {
@@ -11402,6 +11096,9 @@ function polyder(coeffs, n = 1) {
   return result;
 }
 function polynomialGCD(a, b) {
+  if (a.every(Number.isSafeInteger) && b.every(Number.isSafeInteger)) {
+    return integerPolynomialGCD(a, b);
+  }
   let r0 = trimPoly([...a]);
   let r1 = trimPoly([...b]);
   while (r1.length > 1 || r1[0] !== 0) {
@@ -11415,6 +11112,12 @@ function polynomialGCD(a, b) {
   }
   return r0;
 }
+function integerPolynomialGCD(a, b) {
+  const g = polyGcdZ(a.map(BigInt), b.map(BigInt));
+  if (g.length === 0) return [0];
+  const lead = Number(g[g.length - 1]);
+  return g.map((c) => Number(c) / lead);
+}
 function polynomialLCM(a, b) {
   const gcd2 = polynomialGCD(a, b);
   const [quotient] = polyDivMod(polymul(a, b), gcd2);
@@ -12583,7 +12286,7 @@ function tridiagSolveJS(diag2, lower, upper, rhs) {
 }
 function tridiagSolveDispatch(diag2, lower, upper, rhs) {
   const n = diag2.length;
-  if (n >= WASM_TRIDIAG_THRESHOLD) {
+  if (n >= WASM_TRIDIAG_THRESHOLD && wasmPolicyAllows("tridiag_solve_f64", n)) {
     const wasm = getWasm();
     if (wasm && isAsWasm(wasm)) {
       try {
@@ -12624,7 +12327,7 @@ function dividedDifferenceJS(xs, ys) {
 }
 function dividedDifferenceDispatch(xs, ys) {
   const n = xs.length;
-  if (n >= WASM_INTERP_THRESHOLD) {
+  if (n >= WASM_INTERP_THRESHOLD && wasmPolicyAllows("divided_difference_f64", n)) {
     const wasm = getWasm();
     if (wasm && isAsWasm(wasm)) {
       try {
@@ -13221,7 +12924,6 @@ function factory(name254, dependencies254, create, meta) {
 
 // src/numeric/solveODE.ts
 import { DenseMatrix as DenseMatrix3, lu, luSolve } from "@danielsimonjr/mathts-matrix";
-var WASM_ODE_THRESHOLD = 10;
 var name = "solveODE";
 var dependencies = [
   "typed",
@@ -14092,6 +13794,8 @@ function radauSolve(f, tspan, y0raw, options = {}) {
 var createSolveODE = /* @__PURE__ */ factory(
   name,
   dependencies,
+  // The deps are untyped (`any`), so the result is declared: without it the export
+  // inherits `any` from `typed(...)` instead of being a TypedFunction like the rest.
   ({
     typed: typed3,
     add: add5,
@@ -14109,143 +13813,6 @@ var createSolveODE = /* @__PURE__ */ factory(
     bignumber: bignumber2,
     unaryMinus: unaryMinus2
   }) => {
-    function _isPlainNumberArray(y0) {
-      if (!Array.isArray(y0) || y0.length < WASM_ODE_THRESHOLD) return false;
-      for (let i = 0; i < y0.length; i++) {
-        if (typeof y0[i] !== "number") return false;
-      }
-      return true;
-    }
-    function _rkWasmLoop(f, tspan, y0, options, butcherTableau) {
-      const wasm = wasmLoader.getModule();
-      if (!wasm) return null;
-      const dim = y0.length;
-      const a = butcherTableau.a;
-      const c = butcherTableau.c;
-      const b = butcherTableau.b;
-      const bp = butcherTableau.bp;
-      const numStages = c.length;
-      const t0 = tspan[0];
-      const tf = tspan[1];
-      const isForwards = tf > t0;
-      const tol = options.tol ? options.tol : 1e-4;
-      const minDelta = options.minDelta ? options.minDelta : 0.2;
-      const maxDelta = options.maxDelta ? options.maxDelta : 5;
-      const maxIter = options.maxIter ? options.maxIter : 1e4;
-      let h;
-      if (options.firstStep) {
-        h = isForwards ? options.firstStep : -options.firstStep;
-      } else {
-        const f0 = f(t0, y0);
-        const d0 = _rmsNorm(y0);
-        const d1 = _rmsNorm(Array.isArray(f0) ? f0 : [f0]);
-        const h0 = d0 < 1e-5 || d1 < 1e-5 ? 1e-6 : 0.01 * (d0 / d1);
-        const hMag = Math.min(h0, Math.abs(tf - t0));
-        h = isForwards ? hMag : -hMag;
-      }
-      const maxStepVal = options.maxStep;
-      const minStepVal = options.minStep;
-      const deltaB = new Float64Array(numStages);
-      for (let i = 0; i < numStages; i++) {
-        deltaB[i] = b[i] - bp[i];
-      }
-      const yAlloc = wasmLoader.allocateFloat64Array(y0);
-      const yNewAlloc = wasmLoader.allocateFloat64ArrayEmpty(dim);
-      const errorAlloc = wasmLoader.allocateFloat64ArrayEmpty(dim);
-      const tempAlloc = wasmLoader.allocateFloat64ArrayEmpty(dim);
-      const stageAlloc = wasmLoader.allocateFloat64ArrayEmpty(numStages * dim);
-      try {
-        let readVec2 = function(alloc) {
-          const arr10 = new Float64Array(wasm.memory.buffer, alloc.ptr, dim);
-          const result = new Array(dim);
-          for (let i = 0; i < dim; i++) {
-            result[i] = arr10[i];
-          }
-          return result;
-        }, writeVec2 = function(alloc, data) {
-          const arr10 = new Float64Array(wasm.memory.buffer, alloc.ptr, dim);
-          for (let i = 0; i < dim; i++) {
-            arr10[i] = data[i];
-          }
-        }, writeStage2 = function(stageIdx, data) {
-          const offset = stageIdx * dim;
-          const arr10 = new Float64Array(wasm.memory.buffer, stageAlloc.ptr, numStages * dim);
-          for (let i = 0; i < dim; i++) {
-            arr10[offset + i] = data[i];
-          }
-        }, trimStepNum2 = function(tn, tfn, hn) {
-          const next = tn + hn;
-          if (isForwards ? next > tfn : next < tfn) {
-            return tfn - tn;
-          }
-          return hn;
-        }, ongoing2 = function(tn, tfn) {
-          return isForwards ? tn < tfn : tn > tfn;
-        };
-        var readVec = readVec2, writeVec = writeVec2, writeStage = writeStage2, trimStepNum = trimStepNum2, ongoing = ongoing2;
-        const t = [t0];
-        const y = [y0.slice()];
-        let n = 0;
-        let iter = 0;
-        while (ongoing2(t[n], tf)) {
-          h = trimStepNum2(t[n], tf, h);
-          writeVec2(yAlloc, y[n]);
-          const k0 = f(t[n], y[n]);
-          writeStage2(0, k0);
-          for (let s = 1; s < numStages; s++) {
-            wasm.vectorCopy(yAlloc.ptr, dim, tempAlloc.ptr);
-            for (let j = 0; j < a[s].length; j++) {
-              const aCoeff = a[s][j];
-              if (aCoeff === 0) continue;
-              const kjPtr = stageAlloc.ptr + j * dim * 8;
-              wasm.vectorScale(kjPtr, h * aCoeff, dim, yNewAlloc.ptr);
-              wasm.vectorAdd(tempAlloc.ptr, yNewAlloc.ptr, dim, tempAlloc.ptr);
-            }
-            const tStage = t[n] + c[s] * h;
-            const yStage = readVec2(tempAlloc);
-            const ks = f(tStage, yStage);
-            writeStage2(s, ks);
-          }
-          wasm.vectorCopy(yAlloc.ptr, dim, yNewAlloc.ptr);
-          new Float64Array(wasm.memory.buffer, errorAlloc.ptr, dim).fill(0);
-          for (let s = 0; s < numStages; s++) {
-            const ksPtr = stageAlloc.ptr + s * dim * 8;
-            if (b[s] !== 0) {
-              wasm.vectorScale(ksPtr, h * b[s], dim, tempAlloc.ptr);
-              wasm.vectorAdd(yNewAlloc.ptr, tempAlloc.ptr, dim, yNewAlloc.ptr);
-            }
-            if (deltaB[s] !== 0) {
-              wasm.vectorScale(ksPtr, deltaB[s], dim, tempAlloc.ptr);
-              wasm.vectorAdd(errorAlloc.ptr, tempAlloc.ptr, dim, errorAlloc.ptr);
-            }
-          }
-          const TE = wasm.maxError(errorAlloc.ptr, dim);
-          if (TE < tol && tol / TE > 1 / 4) {
-            t.push(t[n] + h);
-            y.push(readVec2(yNewAlloc));
-            n++;
-          }
-          const delta = wasm.computeStepAdjustment(TE, tol, 5, minDelta, maxDelta);
-          h = h * delta;
-          if (maxStepVal !== void 0 && Math.abs(h) > maxStepVal) {
-            h = isForwards ? maxStepVal : -maxStepVal;
-          } else if (minStepVal !== void 0 && Math.abs(h) < minStepVal) {
-            h = isForwards ? minStepVal : -minStepVal;
-          }
-          iter++;
-          if (iter > maxIter) {
-            throw new Error("Maximum number of iterations reached, try changing options");
-          }
-        }
-        return { t, y };
-      } finally {
-        wasmLoader.free(yAlloc.ptr);
-        wasmLoader.free(yNewAlloc.ptr);
-        wasmLoader.free(errorAlloc.ptr);
-        wasmLoader.free(tempAlloc.ptr);
-        wasmLoader.free(stageAlloc.ptr);
-      }
-    }
     function _rk(butcherTableau) {
       return function(f, tspan, y0, options) {
         const wrongTSpan = !(tspan.length === 2 && (tspan.every(isNumOrBig) || tspan.every(isUnit)));
@@ -14274,13 +13841,6 @@ var createSolveODE = /* @__PURE__ */ factory(
           throw new Error('Inconsistent type of "t" dependant variables');
         }
         const hasBigNumbers = [t0, tf, ...y0, maxStep, minStep].some(isBigNumber);
-        if (!hasBigNumbers && !tspan.some(isUnit) && _isPlainNumberArray(y0)) {
-          try {
-            const wasmResult = _rkWasmLoop(f, tspan, y0, options, butcherTableau);
-            if (wasmResult !== null) return wasmResult;
-          } catch {
-          }
-        }
         const steps = 1;
         const tol = options.tol ? options.tol : 1e-4;
         const minDelta = options.minDelta ? options.minDelta : 0.2;
@@ -15122,7 +14682,6 @@ function solveDDE(f, tspan, history, delays, options = {}) {
 }
 
 // src/typed/numeric.ts
-var NUMERIC_WASM_THRESHOLD = 16;
 function findRoot(f, a, b, opts) {
   const tol = opts?.tol ?? 1e-12;
   const maxIter = opts?.maxIter ?? 100;
@@ -15312,27 +14871,6 @@ function globalMinimize(f, bounds, opts) {
 function leastSquares(A, b) {
   const m = A.length;
   const n = A[0].length;
-  if (m >= NUMERIC_WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const flatA = new Float64Array(m * n);
-        for (let i = 0; i < m; i++) for (let j = 0; j < n; j++) flatA[i * n + j] = A[i][j];
-        const aAlloc = wasmLoader.allocateFloat64Array(flatA);
-        const bAlloc = wasmLoader.allocateFloat64Array(new Float64Array(b));
-        const xAlloc = wasmLoader.allocateFloat64Array(new Float64Array(n));
-        try {
-          wasm.least_squares_wasm(aAlloc.ptr, bAlloc.ptr, m, n, xAlloc.ptr);
-          return Array.from(xAlloc.array);
-        } finally {
-          wasmLoader.free(aAlloc.ptr);
-          wasmLoader.free(bAlloc.ptr);
-          wasmLoader.free(xAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   const AtA = Array.from({ length: n }, () => new Array(n).fill(0));
   for (let i = 0; i < n; i++) {
     for (let j = 0; j < n; j++) {
@@ -15475,28 +15013,6 @@ function pchip(xs, ys, x) {
 }
 function bezierCurve(controlPoints, t) {
   if (controlPoints.length === 0) throw new Error("bezierCurve: need at least 1 control point");
-  const nPts = controlPoints.length;
-  const dims = controlPoints[0].length;
-  if (nPts >= NUMERIC_WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const flat = new Float64Array(nPts * dims);
-        for (let i = 0; i < nPts; i++)
-          for (let d = 0; d < dims; d++) flat[i * dims + d] = controlPoints[i][d];
-        const ctrlAlloc = wasmLoader.allocateFloat64Array(flat);
-        const resultAlloc = wasmLoader.allocateFloat64Array(new Float64Array(dims));
-        try {
-          wasm.bezier_eval_wasm(ctrlAlloc.ptr, nPts, dims, t, resultAlloc.ptr);
-          return Array.from(resultAlloc.array);
-        } finally {
-          wasmLoader.free(ctrlAlloc.ptr);
-          wasmLoader.free(resultAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   let points = controlPoints.map((p) => p.slice());
   while (points.length > 1) {
     const next = [];
@@ -15546,23 +15062,6 @@ function bspline(controlPoints, degree3, t) {
 }
 function loess(xs, ys, x, bandwidth = 0.3) {
   const n = xs.length;
-  if (n >= NUMERIC_WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const xsAlloc = wasmLoader.allocateFloat64Array(new Float64Array(xs));
-        const ysAlloc = wasmLoader.allocateFloat64Array(new Float64Array(ys));
-        try {
-          const result = wasm.loess_wasm(xsAlloc.ptr, ysAlloc.ptr, n, x, bandwidth);
-          return result;
-        } finally {
-          wasmLoader.free(xsAlloc.ptr);
-          wasmLoader.free(ysAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   const k = Math.max(2, Math.ceil(bandwidth * n));
   const dists = xs.map((xi, i) => ({ dist: Math.abs(xi - x), i }));
   dists.sort((a2, b2) => a2.dist - b2.dist);
@@ -15589,63 +15088,6 @@ function loess(xs, ys, x, bandwidth = 0.3) {
   return a + b * x;
 }
 function griddata(points, values, xi, yi) {
-  const n = points.length;
-  if (n >= NUMERIC_WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const flatPts = new Float64Array(n * 2);
-        for (let i = 0; i < n; i++) {
-          flatPts[i * 2] = points[i][0];
-          flatPts[i * 2 + 1] = points[i][1];
-        }
-        const ni = xi.length * yi.length;
-        const flatXi = new Float64Array(ni);
-        const flatYi = new Float64Array(ni);
-        let idx = 0;
-        for (let j = 0; j < yi.length; j++) {
-          for (let i = 0; i < xi.length; i++) {
-            flatXi[idx] = xi[i];
-            flatYi[idx] = yi[j];
-            idx++;
-          }
-        }
-        const ptsAlloc = wasmLoader.allocateFloat64Array(flatPts);
-        const valsAlloc = wasmLoader.allocateFloat64Array(new Float64Array(values));
-        const xiAlloc = wasmLoader.allocateFloat64Array(flatXi);
-        const yiAlloc = wasmLoader.allocateFloat64Array(flatYi);
-        const resultAlloc = wasmLoader.allocateFloat64Array(new Float64Array(ni));
-        try {
-          wasm.griddata_wasm(
-            ptsAlloc.ptr,
-            valsAlloc.ptr,
-            n,
-            xiAlloc.ptr,
-            yiAlloc.ptr,
-            ni,
-            resultAlloc.ptr
-          );
-          const result2d = [];
-          let k = 0;
-          for (let j = 0; j < yi.length; j++) {
-            const row2 = [];
-            for (let i = 0; i < xi.length; i++) {
-              row2.push(resultAlloc.array[k++]);
-            }
-            result2d.push(row2);
-          }
-          return result2d;
-        } finally {
-          wasmLoader.free(ptsAlloc.ptr);
-          wasmLoader.free(valsAlloc.ptr);
-          wasmLoader.free(xiAlloc.ptr);
-          wasmLoader.free(yiAlloc.ptr);
-          wasmLoader.free(resultAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   const result = [];
   const p = 2;
   for (let j = 0; j < yi.length; j++) {
@@ -15677,41 +15119,6 @@ function griddata(points, values, xi, yi) {
 function rbfInterpolate(points, values, xi, kernel = "gaussian") {
   const n = points.length;
   const dim = points[0].length;
-  if (kernel === "gaussian" && n >= NUMERIC_WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const ni = xi.length;
-        const flatPts = new Float64Array(n * dim);
-        for (let i = 0; i < n; i++)
-          for (let d = 0; d < dim; d++) flatPts[i * dim + d] = points[i][d];
-        const flatXi = new Float64Array(ni * dim);
-        for (let i = 0; i < ni; i++) for (let d = 0; d < dim; d++) flatXi[i * dim + d] = xi[i][d];
-        const ptsAlloc = wasmLoader.allocateFloat64Array(flatPts);
-        const valsAlloc = wasmLoader.allocateFloat64Array(new Float64Array(values));
-        const xiAlloc = wasmLoader.allocateFloat64Array(flatXi);
-        const resultAlloc = wasmLoader.allocateFloat64Array(new Float64Array(ni));
-        try {
-          wasm.rbf_interp_wasm(
-            ptsAlloc.ptr,
-            valsAlloc.ptr,
-            n,
-            dim,
-            xiAlloc.ptr,
-            ni,
-            resultAlloc.ptr
-          );
-          return Array.from(resultAlloc.array);
-        } finally {
-          wasmLoader.free(ptsAlloc.ptr);
-          wasmLoader.free(valsAlloc.ptr);
-          wasmLoader.free(xiAlloc.ptr);
-          wasmLoader.free(resultAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   let sumDist = 0;
   let count2 = 0;
   for (let i = 0; i < Math.min(n, 50); i++) {
@@ -15963,40 +15370,9 @@ function solveODESystem(f, y0, tspan, opts) {
     const k2 = f(t + h / 2, vadd(y, k1, h / 2));
     const k3 = f(t + h / 2, vadd(y, k2, h / 2));
     const k4 = f(t + h, vadd(y, k3, h));
-    let yNew;
-    const wasmMod = n >= 4 ? wasmLoader.getModule() : null;
-    if (wasmMod) {
-      try {
-        const yArr = new Float64Array(y);
-        const kPacked = new Float64Array(4 * n);
-        for (let i = 0; i < n; i++) {
-          kPacked[i] = k1[i];
-          kPacked[n + i] = k2[i];
-          kPacked[2 * n + i] = k3[i];
-          kPacked[3 * n + i] = k4[i];
-        }
-        const yAlloc = wasmLoader.allocateFloat64Array(yArr);
-        const kAlloc = wasmLoader.allocateFloat64Array(kPacked);
-        const rAlloc = wasmLoader.allocateFloat64Array(new Float64Array(n));
-        try {
-          wasmMod.ode_system_rk4_step_wasm(yAlloc.ptr, kAlloc.ptr, h, n, rAlloc.ptr);
-          yNew = Array.from(rAlloc.array);
-        } finally {
-          wasmLoader.free(yAlloc.ptr);
-          wasmLoader.free(kAlloc.ptr);
-          wasmLoader.free(rAlloc.ptr);
-        }
-      } catch {
-        yNew = new Array(n);
-        for (let i = 0; i < n; i++) {
-          yNew[i] = y[i] + h / 6 * (k1[i] + 2 * k2[i] + 2 * k3[i] + k4[i]);
-        }
-      }
-    } else {
-      yNew = new Array(n);
-      for (let i = 0; i < n; i++) {
-        yNew[i] = y[i] + h / 6 * (k1[i] + 2 * k2[i] + 2 * k3[i] + k4[i]);
-      }
+    const yNew = new Array(n);
+    for (let i = 0; i < n; i++) {
+      yNew[i] = y[i] + h / 6 * (k1[i] + 2 * k2[i] + 2 * k3[i] + k4[i]);
     }
     t += h;
     y = yNew;
@@ -16153,23 +15529,6 @@ function rank(A, tol = 1e-10) {
   const m = A.length;
   if (m === 0) return 0;
   const n = A[0].length;
-  if (m >= NUMERIC_WASM_THRESHOLD) {
-    const wasm = wasmLoader.getModule();
-    if (wasm) {
-      try {
-        const flat = new Float64Array(m * n);
-        for (let i = 0; i < m; i++) for (let j = 0; j < n; j++) flat[i * n + j] = A[i][j];
-        const aAlloc = wasmLoader.allocateFloat64Array(flat);
-        try {
-          const result = wasm.matrix_rank_wasm(aAlloc.ptr, m, n, tol);
-          return result;
-        } finally {
-          wasmLoader.free(aAlloc.ptr);
-        }
-      } catch {
-      }
-    }
-  }
   const M = A.map((row2) => row2.slice());
   let r = 0;
   for (let col = 0; col < n && r < m; col++) {
@@ -19305,7 +18664,7 @@ async function mannWhitneyTest(sample1, sample2, opts) {
   if (nTotal >= WASM_SORT_THRESHOLD) {
     const vals = new Float64Array(nTotal);
     for (let k = 0; k < nTotal; k++) vals[k] = combined[k].value;
-    const { argsortF64Dispatch: argsortF64Dispatch2 } = await import("./wasm-bridge-C44GQ3DS.js");
+    const { argsortF64Dispatch: argsortF64Dispatch2 } = await import("./wasm-bridge-74YOKWIS.js");
     const idx = argsortF64Dispatch2(vals);
     const sortedCombined = new Array(nTotal);
     for (let k = 0; k < nTotal; k++) sortedCombined[k] = combined[idx[k]];
@@ -23164,22 +22523,6 @@ var createLgamma = /* @__PURE__ */ factory(
     ];
     return typed3(name30, {
       Array: function(arr10) {
-        const wasm = wasmLoader.getModule();
-        if (wasm && arr10.length >= 100 && arr10.every((x) => typeof x === "number")) {
-          try {
-            const input = new Float64Array(arr10);
-            const inputAlloc = wasmLoader.allocateFloat64Array(input);
-            const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(arr10.length);
-            try {
-              wasm.lgammaArray(inputAlloc.ptr, arr10.length, resultAlloc.ptr);
-              return Array.from(resultAlloc.array);
-            } finally {
-              wasmLoader.free(inputAlloc.ptr);
-              wasmLoader.free(resultAlloc.ptr);
-            }
-          } catch {
-          }
-        }
         return arr10.map((x) => lgammaNumber(x));
       },
       number: lgammaNumber,
@@ -23516,27 +22859,7 @@ var createErf = /* @__PURE__ */ factory(
     return typed3("name", {
       number: erfNumber,
       "Array | Matrix": typed3.referToSelf(
-        (self) => (n) => {
-          if (Array.isArray(n) && n.length >= 100 && n.every((x) => typeof x === "number")) {
-            const wasm = wasmLoader.getModule();
-            if (wasm) {
-              try {
-                const input = new Float64Array(n);
-                const inputAlloc = wasmLoader.allocateFloat64Array(input);
-                const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(n.length);
-                try {
-                  wasm.erfArray(inputAlloc.ptr, n.length, resultAlloc.ptr);
-                  return Array.from(resultAlloc.array);
-                } finally {
-                  wasmLoader.free(inputAlloc.ptr);
-                  wasmLoader.free(resultAlloc.ptr);
-                }
-              } catch {
-              }
-            }
-          }
-          return deepMap(n, self);
-        }
+        (self) => (n) => deepMap(n, self)
       )
       // TODO: For complex numbers, use the approximation for the Faddeeva function
       //  from "More Efficient Computation of the Complex Error Function" (AMS)
@@ -24808,15 +24131,6 @@ function improveErrorMessage(err, fnName, value) {
 }
 
 // src/statistics/prod.ts
-var WASM_PROD_THRESHOLD = 100;
-function isFlatNumberArray(arr10) {
-  for (let i = 0; i < arr10.length; i++) {
-    if (typeof arr10[i] !== "number") {
-      return false;
-    }
-  }
-  return true;
-}
 var name76 = "prod";
 var dependencies76 = ["typed", "config", "multiplyScalar", "numeric", "parseNumberWithConfig"];
 var createProd = /* @__PURE__ */ factory(
@@ -24844,22 +24158,6 @@ var createProd = /* @__PURE__ */ factory(
       }
     });
     function _prod(array) {
-      if (Array.isArray(array) && array.length >= WASM_PROD_THRESHOLD) {
-        if (isFlatNumberArray(array)) {
-          const wasm = wasmLoader.getModule();
-          if (wasm) {
-            try {
-              const alloc = wasmLoader.allocateFloat64Array(array);
-              try {
-                return wasm.statsProd(alloc.ptr, array.length);
-              } finally {
-                wasmLoader.free(alloc.ptr);
-              }
-            } catch {
-            }
-          }
-        }
-      }
       let prod2;
       deepForEach(array, function(value) {
         try {
@@ -25045,27 +24343,6 @@ var createParseNumberWithConfig = /* @__PURE__ */ factory(
 );
 
 // src/matrix/transpose.ts
-var WASM_TRANSPOSE_THRESHOLD = 100;
-function isPlainNumberMatrix(matrix2) {
-  for (let i = 0; i < matrix2.length; i++) {
-    const row2 = matrix2[i];
-    for (let j = 0; j < row2.length; j++) {
-      if (typeof row2[j] !== "number") {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function flattenToFloat64(matrix2, rows, cols) {
-  const result = new Float64Array(rows * cols);
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < cols; j++) {
-      result[i * cols + j] = matrix2[i][j];
-    }
-  }
-  return result;
-}
 var name84 = "transpose";
 var dependencies84 = ["typed", "matrix"];
 var createTranspose = /* @__PURE__ */ factory(
@@ -25113,34 +24390,6 @@ var createTranspose = /* @__PURE__ */ factory(
     }
     function _denseTranspose(m, rows, columns) {
       const data = m._data;
-      const wasm = wasmLoader.getModule();
-      if (wasm && rows * columns >= WASM_TRANSPOSE_THRESHOLD && isPlainNumberMatrix(data)) {
-        try {
-          const flat = flattenToFloat64(data, rows, columns);
-          const input = wasmLoader.allocateFloat64Array(flat);
-          const output = wasmLoader.allocateFloat64ArrayEmpty(rows * columns);
-          try {
-            wasm.transpose(input.ptr, rows, columns, output.ptr);
-            const transposed2 = [];
-            for (let j = 0; j < columns; j++) {
-              const row2 = [];
-              for (let i = 0; i < rows; i++) {
-                row2[i] = output.array[j * rows + i];
-              }
-              transposed2[j] = row2;
-            }
-            return m.createDenseMatrix({
-              data: transposed2,
-              size: [columns, rows],
-              datatype: m._datatype
-            });
-          } finally {
-            wasmLoader.free(input.ptr);
-            wasmLoader.free(output.ptr);
-          }
-        } catch {
-        }
-      }
       const transposed = [];
       let transposedRow;
       for (let j = 0; j < columns; j++) {
@@ -25465,38 +24714,6 @@ var createDiag = /* @__PURE__ */ factory(
 );
 
 // src/matrix/kron.ts
-var WASM_KRON_THRESHOLD = 64;
-function isPlainNumber2D(arr10) {
-  for (let i = 0; i < arr10.length; i++) {
-    const row2 = arr10[i];
-    for (let j = 0; j < row2.length; j++) {
-      if (typeof row2[j] !== "number") {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function flatten2D(arr10, rows, cols) {
-  const result = new Float64Array(rows * cols);
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < cols; j++) {
-      result[i * cols + j] = arr10[i][j];
-    }
-  }
-  return result;
-}
-function unflatten2D(flat, rows, cols) {
-  const result = [];
-  for (let i = 0; i < rows; i++) {
-    const row2 = [];
-    for (let j = 0; j < cols; j++) {
-      row2.push(flat[i * cols + j]);
-    }
-    result.push(row2);
-  }
-  return result;
-}
 var name90 = "kron";
 var dependencies90 = ["typed", "matrix", "multiplyScalar"];
 var createKron = /* @__PURE__ */ factory(
@@ -25527,37 +24744,6 @@ var createKron = /* @__PURE__ */ factory(
         while (bdim++ < d) b = [b];
       }
       if (d === 1) return _kron1d(a, b);
-      if (d === 2) {
-        const aSize = arraySize(a);
-        const bSize = arraySize(b);
-        const aRows = aSize[0];
-        const aCols = aSize[1];
-        const bRows = bSize[0];
-        const bCols = bSize[1];
-        const totalElements = aRows * aCols * bRows * bCols;
-        const wasm = wasmLoader.getModule();
-        if (wasm && totalElements >= WASM_KRON_THRESHOLD && isPlainNumber2D(a) && isPlainNumber2D(b)) {
-          try {
-            const aFlat = flatten2D(a, aRows, aCols);
-            const bFlat = flatten2D(b, bRows, bCols);
-            const aAlloc = wasmLoader.allocateFloat64Array(aFlat);
-            const bAlloc = wasmLoader.allocateFloat64Array(bFlat);
-            const resultRows = aRows * bRows;
-            const resultCols = aCols * bCols;
-            const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(resultRows * resultCols);
-            try {
-              wasm.laKron(aAlloc.ptr, aRows, aCols, bAlloc.ptr, bRows, bCols);
-              const resultFlat = new Float64Array(resultAlloc.array);
-              return unflatten2D(resultFlat, resultRows, resultCols);
-            } finally {
-              wasmLoader.free(aAlloc.ptr);
-              wasmLoader.free(bAlloc.ptr);
-              wasmLoader.free(resultAlloc.ptr);
-            }
-          } catch {
-          }
-        }
-      }
       return a.flatMap(
         (aSlice) => b.map((bSlice) => _kron(aSlice, bSlice, d - 1))
       );
@@ -25962,8 +25148,7 @@ var createTrace = /* @__PURE__ */ factory(
 );
 
 // src/matrix/det.ts
-var WASM_DET_THRESHOLD = 25;
-function isPlainNumberMatrix2(matrix2) {
+function isPlainNumberMatrix(matrix2) {
   for (let i = 0; i < matrix2.length; i++) {
     const row2 = matrix2[i];
     for (let j = 0; j < row2.length; j++) {
@@ -25974,15 +25159,6 @@ function isPlainNumberMatrix2(matrix2) {
   }
   return true;
 }
-function flattenToFloat642(matrix2, rows, cols) {
-  const result = new Float64Array(rows * cols);
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < cols; j++) {
-      result[i * cols + j] = matrix2[i][j];
-    }
-  }
-  return result;
-}
 var name96 = "det";
 var dependencies96 = [
   "typed",
@@ -26045,22 +25221,6 @@ var createDet = /* @__PURE__ */ factory(
       }
     });
     function _det(matrix3, rows, _cols) {
-      const wasm = wasmLoader.getModule();
-      if (wasm && rows * rows >= WASM_DET_THRESHOLD && isPlainNumberMatrix2(matrix3)) {
-        try {
-          const flat = flattenToFloat642(matrix3, rows, rows);
-          const a = wasmLoader.allocateFloat64Array(flat);
-          const work = wasmLoader.allocateFloat64ArrayEmpty(rows * rows);
-          try {
-            const result = wasm.laDet(a.ptr, rows, work.ptr);
-            return result;
-          } finally {
-            wasmLoader.free(a.ptr);
-            wasmLoader.free(work.ptr);
-          }
-        } catch {
-        }
-      }
       if (rows === 1) {
         return clone(matrix3[0][0]);
       } else if (rows === 2) {
@@ -26068,12 +25228,12 @@ var createDet = /* @__PURE__ */ factory(
           multiply2(matrix3[0][0], matrix3[1][1]),
           multiply2(matrix3[1][0], matrix3[0][1])
         );
-      } else if (rows === 3 && isPlainNumberMatrix2(matrix3)) {
+      } else if (rows === 3 && isPlainNumberMatrix(matrix3)) {
         const a = matrix3[0][0], b = matrix3[0][1], c = matrix3[0][2];
         const d = matrix3[1][0], e = matrix3[1][1], f = matrix3[1][2];
         const g = matrix3[2][0], h = matrix3[2][1], i = matrix3[2][2];
         return a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g);
-      } else if (rows === 4 && isPlainNumberMatrix2(matrix3)) {
+      } else if (rows === 4 && isPlainNumberMatrix(matrix3)) {
         const a00 = matrix3[0][0], a01 = matrix3[0][1];
         const a02 = matrix3[0][2], a03 = matrix3[0][3];
         const a10 = matrix3[1][0], a11 = matrix3[1][1];
@@ -26306,42 +25466,12 @@ function csTdfs(j, k, w, head, next, post, stack) {
 }
 
 // src/algebra/sparse/csAmd.ts
-var WASM_AMD_THRESHOLD = 100;
 var name98 = "csAmd";
 var dependencies98 = ["add", "multiply", "transpose"];
 var createCsAmd = /* @__PURE__ */ factory(
   name98,
   dependencies98,
   ({ add: add5, multiply: multiply2, transpose: transpose5 }) => {
-    function _tryWasmAmd(a, n) {
-      const wasm = wasmLoader.getModule();
-      if (!wasm || !a._ptr || !a._index) return null;
-      const nnz = a._ptr[n];
-      if (nnz < WASM_AMD_THRESHOLD) return null;
-      try {
-        const colPtr = new Int32Array(a._ptr);
-        const rowIdx = new Int32Array(a._index);
-        const colPtrAlloc = wasmLoader.allocateInt32Array(colPtr);
-        const rowIdxAlloc = wasmLoader.allocateInt32Array(rowIdx);
-        const permAlloc = wasmLoader.allocateInt32ArrayEmpty(n);
-        const workAlloc = wasmLoader.allocateInt32ArrayEmpty(8 * (n + 1));
-        try {
-          wasm.amd(colPtrAlloc.ptr, rowIdxAlloc.ptr, n, permAlloc.ptr, workAlloc.ptr);
-          const perm = new Array(n);
-          for (let i = 0; i < n; i++) {
-            perm[i] = permAlloc.array[i];
-          }
-          return perm;
-        } finally {
-          wasmLoader.free(colPtrAlloc.ptr);
-          wasmLoader.free(rowIdxAlloc.ptr);
-          wasmLoader.free(permAlloc.ptr);
-          wasmLoader.free(workAlloc.ptr);
-        }
-      } catch {
-      }
-      return null;
-    }
     return function csAmd2(order, a) {
       if (!a || order <= 0 || order > 3) {
         return null;
@@ -26349,8 +25479,6 @@ var createCsAmd = /* @__PURE__ */ factory(
       const asize = a._size;
       const m = asize[0];
       const n = asize[1];
-      const wasmResult = _tryWasmAmd(a, n);
-      if (wasmResult !== null) return wasmResult;
       let lemax = 0;
       let dense = Math.max(16, 10 * Math.sqrt(n));
       dense = Math.min(n - 2, dense);
@@ -26720,50 +25848,12 @@ function csLeaf(i, j, w, first, maxfirst, prevleaf, ancestor) {
 }
 
 // src/algebra/sparse/csCounts.ts
-var WASM_COUNTS_THRESHOLD = 50;
 var name99 = "csCounts";
 var dependencies99 = ["transpose"];
 var createCsCounts = /* @__PURE__ */ factory(
   name99,
   dependencies99,
   ({ transpose: transpose5 }) => {
-    function _tryWasmCounts(a, parent, post, n) {
-      const wasm = wasmLoader.getModule();
-      if (!wasm || n < WASM_COUNTS_THRESHOLD || !a._index || !a._ptr) return null;
-      try {
-        const indexAlloc = wasmLoader.allocateInt32Array(new Int32Array(a._index));
-        const ptrAlloc = wasmLoader.allocateInt32Array(new Int32Array(a._ptr));
-        const parentAlloc = wasmLoader.allocateInt32Array(new Int32Array(parent));
-        const postAlloc = wasmLoader.allocateInt32Array(new Int32Array(post));
-        const colCountAlloc = wasmLoader.allocateInt32ArrayEmpty(n);
-        const workAlloc = wasmLoader.allocateInt32ArrayEmpty(3 * n);
-        try {
-          wasm.symbolicCholesky(
-            indexAlloc.ptr,
-            ptrAlloc.ptr,
-            n,
-            parentAlloc.ptr,
-            postAlloc.ptr,
-            colCountAlloc.ptr,
-            workAlloc.ptr
-          );
-          const colcount = new Array(n);
-          for (let i = 0; i < n; i++) {
-            colcount[i] = colCountAlloc.array[i];
-          }
-          return colcount;
-        } finally {
-          wasmLoader.free(indexAlloc.ptr);
-          wasmLoader.free(ptrAlloc.ptr);
-          wasmLoader.free(parentAlloc.ptr);
-          wasmLoader.free(postAlloc.ptr);
-          wasmLoader.free(colCountAlloc.ptr);
-          wasmLoader.free(workAlloc.ptr);
-        }
-      } catch {
-      }
-      return null;
-    }
     return function csCounts2(a, parent, post, ata) {
       if (!a || !parent || !post) {
         return null;
@@ -26771,10 +25861,6 @@ var createCsCounts = /* @__PURE__ */ factory(
       const asize = a._size;
       const m = asize[0];
       const n = asize[1];
-      if (!ata) {
-        const wasmResult = _tryWasmCounts(a, parent, post, n);
-        if (wasmResult !== null) return wasmResult;
-      }
       let i, j, k, J, p, p0, p1;
       const s = 4 * n + (ata ? n + m + 1 : 0);
       const w = [];
@@ -27239,42 +26325,6 @@ function createSolveValidation({ DenseMatrix: DenseMatrix7 }) {
 }
 
 // src/algebra/solver/lsolve.ts
-var WASM_LSOLVE_THRESHOLD = 16;
-function isPlainNumberMatrix3(matrix2) {
-  for (let i = 0; i < matrix2.length; i++) {
-    const row2 = matrix2[i];
-    for (let j = 0; j < row2.length; j++) {
-      if (typeof row2[j] !== "number") {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function isPlainNumberVector(vec) {
-  for (let i = 0; i < vec.length; i++) {
-    if (typeof vec[i][0] !== "number") {
-      return false;
-    }
-  }
-  return true;
-}
-function flattenToFloat643(matrix2, rows, cols) {
-  const result = new Float64Array(rows * cols);
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < cols; j++) {
-      result[i * cols + j] = matrix2[i][j];
-    }
-  }
-  return result;
-}
-function vectorToFloat64(vec) {
-  const result = new Float64Array(vec.length);
-  for (let i = 0; i < vec.length; i++) {
-    result[i] = vec[i][0];
-  }
-  return result;
-}
 var name102 = "lsolve";
 var dependencies102 = [
   "typed",
@@ -27319,38 +26369,6 @@ var createLsolve = /* @__PURE__ */ factory(
       const rows = m._size[0];
       const columns = m._size[1];
       const mdata = m._data;
-      const wasm = wasmLoader.getModule();
-      if (wasm && rows === columns && rows * rows >= WASM_LSOLVE_THRESHOLD && isPlainNumberMatrix3(mdata) && isPlainNumberVector(bdata)) {
-        try {
-          const lFlat = flattenToFloat643(mdata, rows, columns);
-          const bFlat = vectorToFloat64(bdata);
-          const lAlloc = wasmLoader.allocateFloat64Array(lFlat);
-          const bAlloc = wasmLoader.allocateFloat64Array(bFlat);
-          const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(rows);
-          try {
-            const success = wasm.laLsolve(lAlloc.ptr, bAlloc.ptr, rows, resultAlloc.ptr);
-            if (success === 0) {
-              throw new Error("Linear system cannot be solved since matrix is singular");
-            }
-            const x2 = [];
-            for (let i = 0; i < rows; i++) {
-              x2[i] = [resultAlloc.array[i]];
-            }
-            return new DenseMatrix7({
-              data: x2,
-              size: [rows, 1]
-            });
-          } finally {
-            wasmLoader.free(lAlloc.ptr);
-            wasmLoader.free(bAlloc.ptr);
-            wasmLoader.free(resultAlloc.ptr);
-          }
-        } catch (e) {
-          if (e instanceof Error && e.message.includes("singular")) {
-            throw e;
-          }
-        }
-      }
       const x = [];
       for (let j = 0; j < columns; j++) {
         const bj = bdata[j][0] || 0;
@@ -27564,42 +26582,6 @@ var createLsolveAll = /* @__PURE__ */ factory(
 );
 
 // src/algebra/solver/usolve.ts
-var WASM_USOLVE_THRESHOLD = 16;
-function isPlainNumberMatrix4(matrix2) {
-  for (let i = 0; i < matrix2.length; i++) {
-    const row2 = matrix2[i];
-    for (let j = 0; j < row2.length; j++) {
-      if (typeof row2[j] !== "number") {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function isPlainNumberVector2(vec) {
-  for (let i = 0; i < vec.length; i++) {
-    if (typeof vec[i][0] !== "number") {
-      return false;
-    }
-  }
-  return true;
-}
-function flattenToFloat644(matrix2, rows, cols) {
-  const result = new Float64Array(rows * cols);
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < cols; j++) {
-      result[i * cols + j] = matrix2[i][j];
-    }
-  }
-  return result;
-}
-function vectorToFloat642(vec) {
-  const result = new Float64Array(vec.length);
-  for (let i = 0; i < vec.length; i++) {
-    result[i] = vec[i][0];
-  }
-  return result;
-}
 var name104 = "usolve";
 var dependencies104 = [
   "typed",
@@ -27644,38 +26626,6 @@ var createUsolve = /* @__PURE__ */ factory(
       const rows = m._size[0];
       const columns = m._size[1];
       const mdata = m._data;
-      const wasm = wasmLoader.getModule();
-      if (wasm && rows === columns && rows * rows >= WASM_USOLVE_THRESHOLD && isPlainNumberMatrix4(mdata) && isPlainNumberVector2(bdata)) {
-        try {
-          const uFlat = flattenToFloat644(mdata, rows, columns);
-          const bFlat = vectorToFloat642(bdata);
-          const uAlloc = wasmLoader.allocateFloat64Array(uFlat);
-          const bAlloc = wasmLoader.allocateFloat64Array(bFlat);
-          const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(rows);
-          try {
-            const success = wasm.laUsolve(uAlloc.ptr, bAlloc.ptr, rows, resultAlloc.ptr);
-            if (success === 0) {
-              throw new Error("Linear system cannot be solved since matrix is singular");
-            }
-            const x2 = [];
-            for (let i = 0; i < rows; i++) {
-              x2[i] = [resultAlloc.array[i]];
-            }
-            return new DenseMatrix7({
-              data: x2,
-              size: [rows, 1]
-            });
-          } finally {
-            wasmLoader.free(uAlloc.ptr);
-            wasmLoader.free(bAlloc.ptr);
-            wasmLoader.free(resultAlloc.ptr);
-          }
-        } catch (e) {
-          if (e instanceof Error && e.message.includes("singular")) {
-            throw e;
-          }
-        }
-      }
       const x = [];
       for (let j = columns - 1; j >= 0; j--) {
         const bj = bdata[j][0] || 0;
@@ -28645,27 +27595,6 @@ var createConcat = /* @__PURE__ */ factory(
 );
 
 // src/matrix/inv.ts
-var WASM_INV_THRESHOLD = 16;
-function isPlainNumberMatrix5(matrix2) {
-  for (let i = 0; i < matrix2.length; i++) {
-    const row2 = matrix2[i];
-    for (let j = 0; j < row2.length; j++) {
-      if (typeof row2[j] !== "number") {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function flattenToFloat645(matrix2, rows, cols) {
-  const result = new Float64Array(rows * cols);
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < cols; j++) {
-      result[i * cols + j] = matrix2[i][j];
-    }
-  }
-  return result;
-}
 var name116 = "inv";
 var dependencies116 = [
   "typed",
@@ -28734,38 +27663,6 @@ var createInv = /* @__PURE__ */ factory(
     });
     function _inv4(mat, rows, cols) {
       let r, s, f, value, temp;
-      const wasm = wasmLoader.getModule();
-      if (wasm && rows >= 3 && rows * rows >= WASM_INV_THRESHOLD && isPlainNumberMatrix5(mat)) {
-        try {
-          const flat = flattenToFloat645(mat, rows, rows);
-          const input = wasmLoader.allocateFloat64Array(flat);
-          const result = wasmLoader.allocateFloat64ArrayEmpty(rows * rows);
-          const work = wasmLoader.allocateFloat64ArrayEmpty(rows * 2 * rows);
-          try {
-            const success = wasm.laInv(input.ptr, rows, result.ptr, work.ptr);
-            if (success === 0) {
-              throw Error("Cannot calculate inverse, determinant is zero");
-            }
-            const invMatrix = [];
-            for (let i = 0; i < rows; i++) {
-              const row2 = [];
-              for (let j = 0; j < rows; j++) {
-                row2[j] = result.array[i * rows + j];
-              }
-              invMatrix[i] = row2;
-            }
-            return invMatrix;
-          } finally {
-            wasmLoader.free(input.ptr);
-            wasmLoader.free(result.ptr);
-            wasmLoader.free(work.ptr);
-          }
-        } catch (e) {
-          if (e instanceof Error && e.message.includes("determinant is zero")) {
-            throw e;
-          }
-        }
-      }
       if (rows === 1) {
         value = mat[0][0];
         if (value === 0) {
@@ -29826,6 +28723,8 @@ var dependencies127 = ["typed", "add", "multiply", "Complex", "number"];
 var createZpk2tf = /* @__PURE__ */ factory(
   name127,
   dependencies127,
+  // The deps are untyped (`any`), so the result is declared: without it the export
+  // inherits `any` from `typed(...)` instead of being a TypedFunction like the rest.
   ({ typed: typed3, add: add5, multiply: multiply2, Complex: Complex13, number: number2 }) => {
     return typed3(name127, {
       "Array,Array,number": function(z, p, k) {
@@ -29885,7 +28784,7 @@ import { _switch as _switch2 } from "@danielsimonjr/mathts-core/internal";
 
 // src/statistics/cumsum.ts
 import { neumaierCumsum as neumaierCumsum2 } from "@danielsimonjr/mathts-core";
-function isFlatNumberArray2(arr10) {
+function isFlatNumberArray(arr10) {
   for (let i = 0; i < arr10.length; i++) {
     if (typeof arr10[i] !== "number") {
       return false;
@@ -29932,7 +28831,7 @@ var createCumSum = /* @__PURE__ */ factory(
       if (array.length === 0) {
         return [];
       }
-      if (isFlatNumberArray2(array)) {
+      if (isFlatNumberArray(array)) {
         const result = new Array(array.length);
         neumaierCumsum2(array, result);
         return result;
@@ -29984,7 +28883,7 @@ var createCumSum = /* @__PURE__ */ factory(
 
 // src/statistics/sum.ts
 import { pairwiseSum as pairwiseSum2 } from "@danielsimonjr/mathts-core";
-function isFlatNumberArray3(arr10) {
+function isFlatNumberArray2(arr10) {
   for (let i = 0; i < arr10.length; i++) {
     if (typeof arr10[i] !== "number") {
       return false;
@@ -30016,7 +28915,7 @@ var createSum = /* @__PURE__ */ factory(
       }
     });
     function _sum(array) {
-      if (Array.isArray(array) && isFlatNumberArray3(array)) {
+      if (Array.isArray(array) && isFlatNumberArray2(array)) {
         return pairwiseSum2(array);
       }
       let sum3;
@@ -30824,7 +29723,6 @@ var createMatAlgo10xSids = /* @__PURE__ */ factory(
 );
 
 // src/arithmetic/gcd.ts
-var WASM_GCD_ARRAY_THRESHOLD = 50;
 var name140 = "gcd";
 var dependencies140 = [
   "typed",
@@ -30898,14 +29796,9 @@ var createGcd = /* @__PURE__ */ factory(
         ),
         Array: typed3.referToSelf((self) => (array) => {
           if (array.length === 1 && Array.isArray(array[0]) && is1d(array[0])) {
-            const flat = array[0];
-            const wasmResult = _tryWasmGcdArray(flat);
-            if (wasmResult !== null) return wasmResult;
-            return self(...flat);
+            return self(...array[0]);
           }
           if (is1d(array)) {
-            const wasmResult = _tryWasmGcdArray(array);
-            if (wasmResult !== null) return wasmResult;
             return self(...array);
           }
           throw new Error("gcd() supports only 1d matrices!");
@@ -30915,27 +29808,6 @@ var createGcd = /* @__PURE__ */ factory(
         })
       }
     );
-    function _tryWasmGcdArray(array) {
-      if (array.length < WASM_GCD_ARRAY_THRESHOLD) return null;
-      const wasm = wasmLoader.getModule();
-      if (!wasm) return null;
-      const n = array.length;
-      const data = new Float64Array(n);
-      for (let i = 0; i < n; i++) {
-        if (typeof array[i] !== "number" || !isInteger(array[i])) {
-          return null;
-        }
-        data[i] = array[i];
-      }
-      const alloc = wasmLoader.allocateFloat64Array(data);
-      try {
-        return wasm.gcdArray(alloc.ptr, n);
-      } catch {
-        return null;
-      } finally {
-        wasmLoader.free(alloc.ptr);
-      }
-    }
     function _gcdNumber(a, b) {
       if (!isInteger(a) || !isInteger(b)) {
         throw new Error("Parameters in function gcd must be integer numbers");
@@ -32988,15 +31860,6 @@ var createComposition = /* @__PURE__ */ factory(
 );
 
 // src/matrix/partitionSelect.ts
-var WASM_PARTITION_SELECT_THRESHOLD = 100;
-function isFlatNumberArray4(arr10) {
-  for (let i = 0; i < arr10.length; i++) {
-    if (typeof arr10[i] !== "number") {
-      return false;
-    }
-  }
-  return true;
-}
 var name171 = "partitionSelect";
 var dependencies171 = ["typed", "isNumeric", "isNaN", "compare"];
 var createPartitionSelect = /* @__PURE__ */ factory(
@@ -33042,29 +31905,6 @@ var createPartitionSelect = /* @__PURE__ */ factory(
           return arr10[i];
         }
       }
-      const wasm = wasmLoader.getModule();
-      if (wasm && arr10.length >= WASM_PARTITION_SELECT_THRESHOLD && isFlatNumberArray4(arr10)) {
-        const isAsc = compare3 === asc;
-        const isDesc = compare3 === desc;
-        if (isAsc || isDesc) {
-          try {
-            const effectiveK = isDesc ? arr10.length - 1 - k : k;
-            const data = wasmLoader.allocateFloat64Array(arr10);
-            const work = wasmLoader.allocateFloat64ArrayEmpty(arr10.length);
-            try {
-              const result = wasm.partitionSelect(data.ptr, arr10.length, effectiveK, work.ptr);
-              for (let i = 0; i < arr10.length; i++) {
-                arr10[i] = work.array[i];
-              }
-              return result;
-            } finally {
-              wasmLoader.free(data.ptr);
-              wasmLoader.free(work.ptr);
-            }
-          } catch {
-          }
-        }
-      }
       let from = 0;
       let to3 = arr10.length - 1;
       while (from < to3) {
@@ -33233,27 +32073,6 @@ var createPinv = /* @__PURE__ */ factory(
 );
 
 // src/algebra/decomposition/qr.ts
-var WASM_QR_THRESHOLD = 16;
-function isPlainNumberMatrix6(matrix2) {
-  for (let i = 0; i < matrix2.length; i++) {
-    const row2 = matrix2[i];
-    for (let j = 0; j < row2.length; j++) {
-      if (typeof row2[j] !== "number") {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function flattenToFloat646(matrix2, rows, cols) {
-  const result = new Float64Array(rows * cols);
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < cols; j++) {
-      result[i * cols + j] = matrix2[i][j];
-    }
-  }
-  return result;
-}
 var name173 = "qr";
 var dependencies173 = [
   "typed",
@@ -33313,44 +32132,6 @@ var createQr = /* @__PURE__ */ factory(
     function _denseQRimpl(m) {
       const rows = m._size[0];
       const cols = m._size[1];
-      const wasm = wasmLoader.getModule();
-      if (wasm && rows * cols >= WASM_QR_THRESHOLD && isPlainNumberMatrix6(m._data)) {
-        try {
-          const flat = flattenToFloat646(m._data, rows, cols);
-          const aAlloc = wasmLoader.allocateFloat64Array(flat);
-          const qAlloc = wasmLoader.allocateFloat64ArrayEmpty(rows * rows);
-          try {
-            wasm.qrDecomposition(aAlloc.ptr, rows, cols, qAlloc.ptr);
-            const Rdata2 = [];
-            for (let i2 = 0; i2 < rows; i2++) {
-              Rdata2[i2] = [];
-              for (let j2 = 0; j2 < cols; j2++) {
-                Rdata2[i2][j2] = aAlloc.array[i2 * cols + j2];
-              }
-            }
-            const Qdata2 = [];
-            for (let i2 = 0; i2 < rows; i2++) {
-              Qdata2[i2] = [];
-              for (let j2 = 0; j2 < rows; j2++) {
-                Qdata2[i2][j2] = qAlloc.array[i2 * rows + j2];
-              }
-            }
-            const Q3 = matrix2(Qdata2);
-            const R2 = matrix2(Rdata2);
-            return {
-              Q: Q3,
-              R: R2,
-              toString: function() {
-                return "Q: " + this.Q.toString() + "\nR: " + this.R.toString();
-              }
-            };
-          } finally {
-            wasmLoader.free(aAlloc.ptr);
-            wasmLoader.free(qAlloc.ptr);
-          }
-        } catch {
-        }
-      }
       const Q2 = identity2([rows], "dense");
       const Qdata = Q2._data;
       const R = m.clone();
@@ -33843,15 +32624,6 @@ var createEqualText = /* @__PURE__ */ factory(
 );
 
 // src/statistics/max.ts
-var WASM_MAX_THRESHOLD = 100;
-function isFlatNumberArray5(arr10) {
-  for (let i = 0; i < arr10.length; i++) {
-    if (typeof arr10[i] !== "number") {
-      return false;
-    }
-  }
-  return true;
-}
 var name178 = "max";
 var dependencies178 = ["typed", "config", "numeric", "larger", "isNaN"];
 var createMax = /* @__PURE__ */ factory(
@@ -33882,22 +32654,6 @@ var createMax = /* @__PURE__ */ factory(
       }
     }
     function _max(array) {
-      if (Array.isArray(array) && array.length >= WASM_MAX_THRESHOLD) {
-        if (isFlatNumberArray5(array)) {
-          const wasm = wasmLoader.getModule();
-          if (wasm) {
-            try {
-              const alloc = wasmLoader.allocateFloat64Array(array);
-              try {
-                return wasm.statsMax(alloc.ptr, array.length);
-              } finally {
-                wasmLoader.free(alloc.ptr);
-              }
-            } catch {
-            }
-          }
-        }
-      }
       let res;
       deepForEach(array, function(value) {
         try {
@@ -33922,15 +32678,6 @@ var createMax = /* @__PURE__ */ factory(
 );
 
 // src/statistics/min.ts
-var WASM_MIN_THRESHOLD = 100;
-function isFlatNumberArray6(arr10) {
-  for (let i = 0; i < arr10.length; i++) {
-    if (typeof arr10[i] !== "number") {
-      return false;
-    }
-  }
-  return true;
-}
 var name179 = "min";
 var dependencies179 = ["typed", "config", "numeric", "smaller", "isNaN"];
 var createMin = /* @__PURE__ */ factory(
@@ -33961,22 +32708,6 @@ var createMin = /* @__PURE__ */ factory(
       }
     }
     function _min(array) {
-      if (Array.isArray(array) && array.length >= WASM_MIN_THRESHOLD) {
-        if (isFlatNumberArray6(array)) {
-          const wasm = wasmLoader.getModule();
-          if (wasm) {
-            try {
-              const alloc = wasmLoader.allocateFloat64Array(array);
-              try {
-                return wasm.statsMin(alloc.ptr, array.length);
-              } finally {
-                wasmLoader.free(alloc.ptr);
-              }
-            } catch {
-            }
-          }
-        }
-      }
       let min2;
       deepForEach(array, function(value) {
         try {
@@ -34092,7 +32823,6 @@ var createNullish = /* @__PURE__ */ factory(
 );
 
 // src/arithmetic/hypot.ts
-var WASM_HYPOT_THRESHOLD = 50;
 var name181 = "hypot";
 var dependencies181 = [
   "typed",
@@ -34122,28 +32852,7 @@ var createHypot = /* @__PURE__ */ factory(
       Array: _hypot,
       Matrix: (M) => _hypot(flatten2(M.toArray(), true))
     });
-    function _tryWasmHypot(args) {
-      if (args.length < WASM_HYPOT_THRESHOLD) return null;
-      const wasm = wasmLoader.getModule();
-      if (!wasm) return null;
-      const n = args.length;
-      const data = new Float64Array(n);
-      for (let i = 0; i < n; i++) {
-        if (typeof args[i] !== "number") return null;
-        data[i] = args[i];
-      }
-      const alloc = wasmLoader.allocateFloat64Array(data);
-      try {
-        return wasm.hypotArray(alloc.ptr, n);
-      } catch {
-        return null;
-      } finally {
-        wasmLoader.free(alloc.ptr);
-      }
-    }
     function _hypot(args) {
-      const wasmResult = _tryWasmHypot(args);
-      if (wasmResult !== null) return wasmResult;
       let result = 0;
       let largest = 0;
       for (let i = 0; i < args.length; i++) {
@@ -34472,8 +33181,6 @@ var createDistance = /* @__PURE__ */ factory(
       return sqrt2(result);
     }
     function _distancePairwise(a) {
-      const wasmResult = _tryWasmPairwise(a);
-      if (wasmResult !== null) return wasmResult;
       const result = [];
       let pointA = [];
       let pointB = [];
@@ -34491,37 +33198,6 @@ var createDistance = /* @__PURE__ */ factory(
       }
       return result;
     }
-    function _tryWasmPairwise(a) {
-      const wasm = wasmLoader.getModule();
-      if (!wasm) return null;
-      const numPoints = a.length;
-      const dims = a[0].length;
-      for (let i = 0; i < numPoints; i++) {
-        for (let d = 0; d < dims; d++) {
-          if (typeof a[i][d] !== "number") return null;
-        }
-      }
-      const p1Alloc = wasmLoader.allocateFloat64ArrayEmpty(dims);
-      const p2Alloc = wasmLoader.allocateFloat64ArrayEmpty(dims);
-      try {
-        const result = [];
-        for (let i = 0; i < numPoints - 1; i++) {
-          for (let d = 0; d < dims; d++) {
-            p1Alloc.array[d] = a[i][d];
-          }
-          for (let j = i + 1; j < numPoints; j++) {
-            for (let d = 0; d < dims; d++) {
-              p2Alloc.array[d] = a[j][d];
-            }
-            result.push(wasm.distanceND(p1Alloc.ptr, p2Alloc.ptr, dims));
-          }
-        }
-        return result;
-      } finally {
-        wasmLoader.free(p1Alloc.ptr);
-        wasmLoader.free(p2Alloc.ptr);
-      }
-    }
   }
 );
 
@@ -37158,11 +35834,14 @@ var createDiff = /* @__PURE__ */ factory(
           return _recursive(arr10, dim);
         }
       },
-      // typed-function's runtime `referTo` is single-call variadic
-      // (`referTo(...signatures, callback)`); the imported TypedFunction interface
-      // models it curried, so narrow to the real contract via `unknown`.
-      "Array, BigNumber": typed3.referTo("Array,number", (selfAn) => (arr10, dim) => selfAn(arr10, number2(dim))),
-      "Matrix, BigNumber": typed3.referTo("Matrix,number", (selfMn) => (arr10, dim) => selfMn(arr10, number2(dim)))
+      "Array, BigNumber": typed3.referTo(
+        "Array,number",
+        (selfAn) => (arr10, dim) => selfAn(arr10, number2(dim))
+      ),
+      "Matrix, BigNumber": typed3.referTo(
+        "Matrix,number",
+        (selfMn) => (arr10, dim) => selfMn(arr10, number2(dim))
+      )
     });
     function _recursive(arr10, dim) {
       if (isMatrix(arr10)) {
@@ -37219,7 +35898,6 @@ var createDiff = /* @__PURE__ */ factory(
 );
 
 // src/matrix/sqrtm.ts
-var WASM_SQRTM_THRESHOLD = 16;
 var name211 = "sqrtm";
 var dependencies211 = [
   "typed",
@@ -37240,62 +35918,6 @@ var createSqrtm = /* @__PURE__ */ factory(
   ({ typed: typed3, abs: abs2, add: add5, multiply: multiply2, map: map3, sqrt: sqrt2, subtract: subtract3, inv: inv3, size: size2, max: max2, identity: identity2 }) => {
     const _maxIterations = 1e3;
     const _tolerance = 1e-6;
-    function _tryWasmSqrtm(A, n) {
-      const wasm = wasmLoader.getModule();
-      if (!wasm || n * n < WASM_SQRTM_THRESHOLD) return null;
-      const data = isMatrix(A) ? A._data : A;
-      if (!data || !Array.isArray(data)) return null;
-      try {
-        const flat = new Float64Array(n * n);
-        for (let i = 0; i < n; i++) {
-          const row2 = data[i];
-          if (!Array.isArray(row2)) return null;
-          for (let j = 0; j < n; j++) {
-            const val = row2[j];
-            if (typeof val !== "number") return null;
-            flat[i * n + j] = val;
-          }
-        }
-        const matrixAlloc = wasmLoader.allocateFloat64Array(flat);
-        const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(n * n);
-        const workAlloc = wasmLoader.allocateFloat64ArrayEmpty(5 * n * n);
-        try {
-          const status = wasm.sqrtm(
-            matrixAlloc.ptr,
-            n,
-            resultAlloc.ptr,
-            _tolerance,
-            _maxIterations,
-            workAlloc.ptr
-          );
-          if (status > 0) {
-            const result = [];
-            for (let i = 0; i < n; i++) {
-              const row2 = [];
-              for (let j = 0; j < n; j++) {
-                row2[j] = resultAlloc.array[i * n + j];
-              }
-              result[i] = row2;
-            }
-            if (isMatrix(A)) {
-              const matA = A;
-              return matA.createDenseMatrix({
-                data: result,
-                size: [n, n],
-                datatype: matA._datatype
-              });
-            }
-            return result;
-          }
-        } finally {
-          wasmLoader.free(matrixAlloc.ptr);
-          wasmLoader.free(resultAlloc.ptr);
-          wasmLoader.free(workAlloc.ptr);
-        }
-      } catch {
-      }
-      return null;
-    }
     function _denmanBeavers(A) {
       let error;
       let iterations = 0;
@@ -37328,8 +35950,6 @@ var createSqrtm = /* @__PURE__ */ factory(
             const rows = sizeArray[0];
             const cols = sizeArray[1];
             if (rows === cols) {
-              const wasmResult = _tryWasmSqrtm(A, rows);
-              if (wasmResult !== null) return wasmResult;
               return _denmanBeavers(A);
             } else {
               throw new RangeError(
@@ -37348,27 +35968,6 @@ var createSqrtm = /* @__PURE__ */ factory(
 );
 
 // src/algebra/decomposition/lup.ts
-var WASM_LUP_THRESHOLD = 16;
-function isPlainNumberMatrix7(matrix2) {
-  for (let i = 0; i < matrix2.length; i++) {
-    const row2 = matrix2[i];
-    for (let j = 0; j < row2.length; j++) {
-      if (typeof row2[j] !== "number") {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function flattenToFloat647(matrix2, rows, cols) {
-  const result = new Float64Array(rows * cols);
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < cols; j++) {
-      result[i * cols + j] = matrix2[i][j];
-    }
-  }
-  return result;
-}
 var name212 = "lup";
 var dependencies212 = [
   "typed",
@@ -37424,66 +36023,6 @@ var createLup = /* @__PURE__ */ factory(
       const rows = m._size[0];
       const columns = m._size[1];
       let n = Math.min(rows, columns);
-      const wasm = wasmLoader.getModule();
-      if (wasm && rows === columns && rows * rows >= WASM_LUP_THRESHOLD && isPlainNumberMatrix7(m._data)) {
-        try {
-          const flat = flattenToFloat647(m._data, rows, columns);
-          const aAlloc = wasmLoader.allocateFloat64Array(flat);
-          const permAlloc = wasmLoader.allocateInt32ArrayEmpty(rows);
-          try {
-            const result = wasm.luDecomposition(aAlloc.ptr, rows, permAlloc.ptr);
-            if (result !== 0) {
-              throw new Error("Matrix is singular and cannot be decomposed");
-            }
-            const ldata2 = [];
-            const udata2 = [];
-            for (let i2 = 0; i2 < rows; i2++) {
-              ldata2[i2] = [];
-              udata2[i2] = [];
-              for (let j2 = 0; j2 < columns; j2++) {
-                const val = aAlloc.array[i2 * columns + j2];
-                if (i2 > j2) {
-                  ldata2[i2][j2] = val;
-                  udata2[i2][j2] = 0;
-                } else if (i2 === j2) {
-                  ldata2[i2][j2] = 1;
-                  udata2[i2][j2] = val;
-                } else {
-                  ldata2[i2][j2] = 0;
-                  udata2[i2][j2] = val;
-                }
-              }
-            }
-            const p2 = [];
-            for (let i2 = 0; i2 < rows; i2++) {
-              p2[i2] = permAlloc.array[i2];
-            }
-            const l2 = new DenseMatrix7({
-              data: ldata2,
-              size: [rows, n]
-            });
-            const u2 = new DenseMatrix7({
-              data: udata2,
-              size: [n, columns]
-            });
-            return {
-              L: l2,
-              U: u2,
-              p: p2,
-              toString: function() {
-                return "L: " + this.L.toString() + "\nU: " + this.U.toString() + "\nP: " + this.p;
-              }
-            };
-          } finally {
-            wasmLoader.free(aAlloc.ptr);
-            wasmLoader.free(permAlloc.ptr);
-          }
-        } catch (e) {
-          if (e instanceof Error && e.message.includes("singular")) {
-            throw e;
-          }
-        }
-      }
       const data = clone(m._data);
       const ldata = [];
       const lsize = [rows, n];
@@ -38367,8 +36906,6 @@ var createIntersect = /* @__PURE__ */ factory(
       return x.length === 4 && isNumeric2(x[0]) && isNumeric2(x[1]) && isNumeric2(x[2]) && isNumeric2(x[3]);
     }
     function _intersect2d(p1a, p1b, p2a, p2b) {
-      const wasmResult = _tryWasmIntersect2d(p1a, p1b, p2a, p2b);
-      if (wasmResult !== void 0) return wasmResult;
       const o1 = p1a;
       const o2 = p2a;
       const d1 = subtract3(o1, p1b);
@@ -38394,34 +36931,6 @@ var createIntersect = /* @__PURE__ */ factory(
       );
       return add5(multiply2(d1, t), o1);
     }
-    function _tryWasmIntersect2d(p1a, p1b, p2a, p2b) {
-      const wasm = wasmLoader.getModule();
-      if (!wasm) return void 0;
-      if (typeof p1a[0] !== "number" || typeof p1a[1] !== "number" || typeof p1b[0] !== "number" || typeof p1b[1] !== "number" || typeof p2a[0] !== "number" || typeof p2a[1] !== "number" || typeof p2b[0] !== "number" || typeof p2b[1] !== "number") {
-        return void 0;
-      }
-      const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(3);
-      try {
-        wasm.intersect2DInfiniteLines(
-          p1a[0],
-          p1a[1],
-          p1b[0],
-          p1b[1],
-          p2a[0],
-          p2a[1],
-          p2b[0],
-          p2b[1],
-          resultAlloc.ptr
-        );
-        const exists = resultAlloc.array[2];
-        if (exists === 0) {
-          return null;
-        }
-        return [resultAlloc.array[0], resultAlloc.array[1]];
-      } finally {
-        wasmLoader.free(resultAlloc.ptr);
-      }
-    }
     function _intersect3dHelper(a, b, c, d, e, f, g, h, i, j, k, l) {
       const add1 = multiplyScalar2(
         subtract3(a, b),
@@ -38503,15 +37012,6 @@ var createIntersect = /* @__PURE__ */ factory(
 );
 
 // src/statistics/mean.ts
-var WASM_MEAN_THRESHOLD = 100;
-function isFlatNumberArray7(arr10) {
-  for (let i = 0; i < arr10.length; i++) {
-    if (typeof arr10[i] !== "number") {
-      return false;
-    }
-  }
-  return true;
-}
 var name219 = "mean";
 var dependencies219 = ["typed", "add", "divide"];
 var createMean = /* @__PURE__ */ factory(
@@ -38542,22 +37042,6 @@ var createMean = /* @__PURE__ */ factory(
       }
     }
     function _mean2(array) {
-      if (Array.isArray(array) && array.length >= WASM_MEAN_THRESHOLD) {
-        if (isFlatNumberArray7(array)) {
-          const wasm = wasmLoader.getModule();
-          if (wasm) {
-            try {
-              const alloc = wasmLoader.allocateFloat64Array(array);
-              try {
-                return wasm.statsMean(alloc.ptr, array.length);
-              } finally {
-                wasmLoader.free(alloc.ptr);
-              }
-            } catch {
-            }
-          }
-        }
-      }
       let sum3;
       let num2 = 0;
       deepForEach(array, function(value) {
@@ -38642,7 +37126,7 @@ var createMedian = /* @__PURE__ */ factory(
 
 // src/statistics/variance.ts
 import { sumSquaredDeviations as sumSquaredDeviations2 } from "@danielsimonjr/mathts-core";
-function isFlatNumberArray8(arr10) {
+function isFlatNumberArray3(arr10) {
   for (let i = 0; i < arr10.length; i++) {
     if (typeof arr10[i] !== "number") {
       return false;
@@ -38687,7 +37171,7 @@ var createVariance = /* @__PURE__ */ factory(
       if (array.length === 0) {
         throw new SyntaxError("Function variance requires one or more parameters (0 provided)");
       }
-      if (Array.isArray(array) && isFlatNumberArray8(array)) {
+      if (Array.isArray(array) && isFlatNumberArray3(array)) {
         const nn = array.length;
         const ssd = sumSquaredDeviations2(array);
         switch (normalization) {
@@ -39015,12 +37499,13 @@ var createMultinomial = /* @__PURE__ */ factory(
 );
 
 // src/signal/freqz.ts
-var WASM_FREQZ_THRESHOLD = 32;
 var name225 = "freqz";
 var dependencies225 = ["typed", "add", "multiply", "Complex", "divide", "matrix"];
 var createFreqz = /* @__PURE__ */ factory(
   name225,
   dependencies225,
+  // The deps are untyped (`any`), so the result is declared: without it the export
+  // inherits `any` from `typed(...)` instead of being a TypedFunction like the rest.
   ({ typed: typed3, add: add5, multiply: multiply2, Complex: Complex13, divide: divide2, matrix: matrix2 }) => {
     return typed3(name225, {
       "Array, Array": function(b, a) {
@@ -39068,47 +37553,7 @@ var createFreqz = /* @__PURE__ */ factory(
         };
       }
     });
-    function _tryWasmFreqz(b, a, w) {
-      const wasm = wasmLoader.getModule();
-      if (!wasm || w.length < WASM_FREQZ_THRESHOLD) return null;
-      try {
-        const bAlloc = wasmLoader.allocateFloat64Array(b);
-        const aAlloc = wasmLoader.allocateFloat64Array(a);
-        const wAlloc = wasmLoader.allocateFloat64Array(w);
-        const hRealAlloc = wasmLoader.allocateFloat64ArrayEmpty(w.length);
-        const hImagAlloc = wasmLoader.allocateFloat64ArrayEmpty(w.length);
-        try {
-          wasm.freqz(
-            bAlloc.ptr,
-            b.length,
-            aAlloc.ptr,
-            a.length,
-            wAlloc.ptr,
-            w.length,
-            hRealAlloc.ptr,
-            hImagAlloc.ptr
-          );
-          const h = [];
-          for (let i = 0; i < w.length; i++) {
-            h.push(Complex13(hRealAlloc.array[i], hImagAlloc.array[i]));
-          }
-          return { h, w };
-        } finally {
-          wasmLoader.free(bAlloc.ptr);
-          wasmLoader.free(aAlloc.ptr);
-          wasmLoader.free(wAlloc.ptr);
-          wasmLoader.free(hRealAlloc.ptr);
-          wasmLoader.free(hImagAlloc.ptr);
-        }
-      } catch {
-      }
-      return null;
-    }
     function _freqz(b, a, w) {
-      const wasmResult = _tryWasmFreqz(b, a, w);
-      if (wasmResult !== null) {
-        return wasmResult;
-      }
       const num2 = [];
       const den = [];
       for (let i = 0; i < w.length; i++) {
@@ -40220,16 +38665,6 @@ var createIndex = /* @__PURE__ */ factory(
 );
 
 // src/matrix/eigs/complexEigs.ts
-var WASM_EIGS_THRESHOLD = 16;
-function flattenToFloat648(matrix2, rows, cols) {
-  const result = new Float64Array(rows * cols);
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < cols; j++) {
-      result[i * cols + j] = matrix2[i][j];
-    }
-  }
-  return result;
-}
 function createComplexEigs({
   addScalar: addScalar2,
   subtract: subtract3,
@@ -40255,54 +38690,6 @@ function createComplexEigs({
   dot: dot9
 }) {
   function complexEigs(arr10, N2, prec, type, findVectors = true) {
-    if (!findVectors && type === "number" && N2 * N2 >= WASM_EIGS_THRESHOLD) {
-      const wasm = wasmLoader.getModule();
-      if (wasm) {
-        try {
-          const flat = flattenToFloat648(arr10, N2, N2);
-          const matrixAlloc = wasmLoader.allocateFloat64Array(flat);
-          const eigenvaluesRealAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
-          const eigenvaluesImagAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
-          const workAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2 * N2);
-          try {
-            const iterations = wasm.qrAlgorithm(
-              matrixAlloc.ptr,
-              N2,
-              eigenvaluesRealAlloc.ptr,
-              eigenvaluesImagAlloc.ptr,
-              workAlloc.ptr,
-              1e3,
-              // maxIterations
-              typeof prec === "number" ? prec : 1e-12
-            );
-            if (iterations >= 0) {
-              const values2 = [];
-              for (let i = 0; i < N2; i++) {
-                const re3 = eigenvaluesRealAlloc.array[i];
-                const im3 = eigenvaluesImagAlloc.array[i];
-                if (Math.abs(im3) < 1e-14) {
-                  values2.push(re3);
-                } else {
-                  values2.push(complex3(re3, im3));
-                }
-              }
-              values2.sort((a, b) => {
-                const absA = typeof a === "number" ? Math.abs(a) : Math.sqrt(a.re ** 2 + a.im ** 2);
-                const absB = typeof b === "number" ? Math.abs(b) : Math.sqrt(b.re ** 2 + b.im ** 2);
-                return absA - absB;
-              });
-              return { values: values2 };
-            }
-          } finally {
-            wasmLoader.free(matrixAlloc.ptr);
-            wasmLoader.free(eigenvaluesRealAlloc.ptr);
-            wasmLoader.free(eigenvaluesImagAlloc.ptr);
-            wasmLoader.free(workAlloc.ptr);
-          }
-        } catch {
-        }
-      }
-    }
     const R = balance(arr10, N2, prec, type, findVectors);
     reduceToHessenberg(arr10, N2, prec, type, findVectors, R);
     const { values, C } = iterateUntilTriangular(arr10, N2, prec, type, findVectors);
@@ -40713,16 +39100,6 @@ function createComplexEigs({
 }
 
 // src/matrix/eigs/realSymmetric.ts
-var WASM_EIGS_THRESHOLD2 = 16;
-function flattenToFloat649(matrix2, rows, cols) {
-  const result = new Float64Array(rows * cols);
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < cols; j++) {
-      result[i * cols + j] = matrix2[i][j];
-    }
-  }
-  return result;
-}
 function createRealSymmetric({
   config: config2,
   addScalar: addScalar2,
@@ -40760,62 +39137,6 @@ function createRealSymmetric({
   }
   function diag2(x, precision, computeVectors) {
     const N2 = x.length;
-    const wasm = wasmLoader.getModule();
-    if (wasm && N2 * N2 >= WASM_EIGS_THRESHOLD2) {
-      try {
-        const flat = flattenToFloat649(x, N2, N2);
-        const matrixAlloc = wasmLoader.allocateFloat64Array(flat);
-        const eigenvaluesAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2);
-        const eigenvectorsAlloc = computeVectors ? wasmLoader.allocateFloat64ArrayEmpty(N2 * N2) : { ptr: 0, array: new Float64Array(0) };
-        const workAlloc = wasmLoader.allocateFloat64ArrayEmpty(N2 * N2);
-        try {
-          const iterations = wasm.eigsSymmetric(
-            matrixAlloc.ptr,
-            N2,
-            eigenvaluesAlloc.ptr,
-            eigenvectorsAlloc.ptr,
-            workAlloc.ptr,
-            1e3,
-            // maxIterations
-            precision
-          );
-          if (iterations >= 0) {
-            const values = Array(N2);
-            for (let i = 0; i < N2; i++) {
-              values[i] = eigenvaluesAlloc.array[i];
-            }
-            if (!computeVectors) {
-              const sortedValues = values.map((v, i) => ({ v, i })).sort((a, b) => Math.abs(a.v) - Math.abs(b.v)).map((x2) => x2.v);
-              return { values: sortedValues };
-            }
-            const eigenvectors = [];
-            const sortedIndices = values.map((v, i) => ({ v, i })).sort((a, b) => Math.abs(a.v) - Math.abs(b.v)).map((x2) => x2.i);
-            for (const origIdx of sortedIndices) {
-              const vector = Array(N2);
-              for (let i = 0; i < N2; i++) {
-                vector[i] = eigenvectorsAlloc.array[i * N2 + origIdx];
-              }
-              eigenvectors.push({
-                value: values[origIdx],
-                vector
-              });
-            }
-            return {
-              values: sortedIndices.map((i) => values[i]),
-              eigenvectors
-            };
-          }
-        } finally {
-          wasmLoader.free(matrixAlloc.ptr);
-          wasmLoader.free(eigenvaluesAlloc.ptr);
-          if (computeVectors) {
-            wasmLoader.free(eigenvectorsAlloc.ptr);
-          }
-          wasmLoader.free(workAlloc.ptr);
-        }
-      } catch {
-      }
-    }
     const e0 = Math.abs(precision / N2);
     let psi;
     let Sij;
@@ -41338,42 +39659,6 @@ function csIpvec(p, b) {
 }
 
 // src/algebra/solver/lusolve.ts
-var WASM_LUSOLVE_THRESHOLD = 16;
-function isPlainNumberMatrix8(matrix2) {
-  for (let i = 0; i < matrix2.length; i++) {
-    const row2 = matrix2[i];
-    for (let j = 0; j < row2.length; j++) {
-      if (typeof row2[j] !== "number") {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function isPlainNumberVector3(vec) {
-  for (let i = 0; i < vec.length; i++) {
-    if (typeof vec[i][0] !== "number") {
-      return false;
-    }
-  }
-  return true;
-}
-function flattenToFloat6410(matrix2, rows, cols) {
-  const result = new Float64Array(rows * cols);
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < cols; j++) {
-      result[i * cols + j] = matrix2[i][j];
-    }
-  }
-  return result;
-}
-function vectorToFloat643(vec) {
-  const result = new Float64Array(vec.length);
-  for (let i = 0; i < vec.length; i++) {
-    result[i] = vec[i][0];
-  }
-  return result;
-}
 var name238 = "lusolve";
 var dependencies238 = ["typed", "matrix", "lup", "slu", "usolve", "lsolve", "DenseMatrix"];
 var createLusolve = /* @__PURE__ */ factory(
@@ -41385,102 +39670,12 @@ var createLusolve = /* @__PURE__ */ factory(
     });
     return typed3(name238, {
       "Array, Array | Matrix": function(a, b) {
-        const rows = a.length;
-        const columns = a[0]?.length || 0;
-        const wasm = wasmLoader.getModule();
-        if (wasm && rows === columns && rows * rows >= WASM_LUSOLVE_THRESHOLD && isPlainNumberMatrix8(a)) {
-          const aMatrix2 = matrix2(a);
-          const bMatrix = solveValidation(aMatrix2, b, true);
-          const bdata = bMatrix._data;
-          if (isPlainNumberVector3(bdata) && bdata.length === rows) {
-            try {
-              const aFlat = flattenToFloat6410(a, rows, columns);
-              const bFlat = vectorToFloat643(bdata);
-              const aAlloc = wasmLoader.allocateFloat64Array(aFlat);
-              const bAlloc = wasmLoader.allocateFloat64Array(bFlat);
-              const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(rows);
-              const workAlloc = wasmLoader.allocateFloat64ArrayEmpty(rows * rows);
-              try {
-                const success = wasm.laSolve(
-                  aAlloc.ptr,
-                  bAlloc.ptr,
-                  rows,
-                  resultAlloc.ptr,
-                  workAlloc.ptr
-                );
-                if (success === 0) {
-                  throw new Error("Linear system cannot be solved since matrix is singular");
-                }
-                const x2 = [];
-                for (let i = 0; i < rows; i++) {
-                  x2[i] = [resultAlloc.array[i]];
-                }
-                return x2;
-              } finally {
-                wasmLoader.free(aAlloc.ptr);
-                wasmLoader.free(bAlloc.ptr);
-                wasmLoader.free(resultAlloc.ptr);
-                wasmLoader.free(workAlloc.ptr);
-              }
-            } catch (e) {
-              if (e instanceof Error && e.message.includes("singular")) {
-                throw e;
-              }
-            }
-          }
-        }
         const aMatrix = matrix2(a);
         const d = lup2(aMatrix);
         const x = _lusolve(d.L, d.U, d.p, null, b);
         return x.valueOf();
       },
       "DenseMatrix, Array | Matrix": function(a, b) {
-        const rows = a._size[0];
-        const columns = a._size[1];
-        const wasm = wasmLoader.getModule();
-        if (wasm && rows === columns && rows * rows >= WASM_LUSOLVE_THRESHOLD && isPlainNumberMatrix8(a._data)) {
-          const bMatrix = solveValidation(a, b, true);
-          const bdata = bMatrix._data;
-          if (isPlainNumberVector3(bdata) && bdata.length === rows) {
-            try {
-              const aFlat = flattenToFloat6410(a._data, rows, columns);
-              const bFlat = vectorToFloat643(bdata);
-              const aAlloc = wasmLoader.allocateFloat64Array(aFlat);
-              const bAlloc = wasmLoader.allocateFloat64Array(bFlat);
-              const resultAlloc = wasmLoader.allocateFloat64ArrayEmpty(rows);
-              const workAlloc = wasmLoader.allocateFloat64ArrayEmpty(rows * rows);
-              try {
-                const success = wasm.laSolve(
-                  aAlloc.ptr,
-                  bAlloc.ptr,
-                  rows,
-                  resultAlloc.ptr,
-                  workAlloc.ptr
-                );
-                if (success === 0) {
-                  throw new Error("Linear system cannot be solved since matrix is singular");
-                }
-                const x = [];
-                for (let i = 0; i < rows; i++) {
-                  x[i] = [resultAlloc.array[i]];
-                }
-                return new DenseMatrix7({
-                  data: x,
-                  size: [rows, 1]
-                });
-              } finally {
-                wasmLoader.free(aAlloc.ptr);
-                wasmLoader.free(bAlloc.ptr);
-                wasmLoader.free(resultAlloc.ptr);
-                wasmLoader.free(workAlloc.ptr);
-              }
-            } catch (e) {
-              if (e instanceof Error && e.message.includes("singular")) {
-                throw e;
-              }
-            }
-          }
-        }
         const d = lup2(a);
         return _lusolve(d.L, d.U, d.p, null, b);
       },
@@ -41603,15 +39798,6 @@ var createCorr = /* @__PURE__ */ factory(
 );
 
 // src/statistics/mad.ts
-var WASM_MAD_THRESHOLD = 500;
-function isPlainNumberArray2(arr10) {
-  for (let i = 0; i < arr10.length; i++) {
-    if (typeof arr10[i] !== "number") {
-      return false;
-    }
-  }
-  return true;
-}
 var name240 = "mad";
 var dependencies240 = ["typed", "abs", "map", "median", "subtract"];
 var createMad = /* @__PURE__ */ factory(
@@ -41631,19 +39817,6 @@ var createMad = /* @__PURE__ */ factory(
       if (flat.length === 0) {
         throw new Error("Cannot calculate median absolute deviation (mad) of an empty array");
       }
-      const wasm = wasmLoader.getModule();
-      if (wasm && flat.length >= WASM_MAD_THRESHOLD && isPlainNumberArray2(flat)) {
-        try {
-          const aAlloc = wasmLoader.allocateFloat64Array(flat);
-          try {
-            const result = wasm.statsMad(aAlloc.ptr, flat.length);
-            return result;
-          } finally {
-            wasmLoader.free(aAlloc.ptr);
-          }
-        } catch {
-        }
-      }
       try {
         const med = median2(flat);
         return median2(
@@ -43146,7 +41319,6 @@ var createDerivative = /* @__PURE__ */ factory(
 
 // src/arithmetic/norm.ts
 import { norm2 as norm23 } from "@danielsimonjr/mathts-core";
-var WASM_NORM_THRESHOLD = 100;
 var name245 = "norm";
 var dependencies245 = [
   "typed",
@@ -43205,39 +41377,6 @@ var createNorm = /* @__PURE__ */ factory(
         return _norm(x, p);
       }
     });
-    function _tryWasmVectorNorm(x, p) {
-      const size2 = x.size();
-      if (size2.length !== 1 || size2[0] < WASM_NORM_THRESHOLD) return null;
-      const wasm = wasmLoader.getModule();
-      if (!wasm) return null;
-      const arr10 = x.toArray();
-      const n = arr10.length;
-      const data = new Float64Array(n);
-      for (let i = 0; i < n; i++) {
-        if (typeof arr10[i] !== "number") return null;
-        data[i] = arr10[i];
-      }
-      const alloc = wasmLoader.allocateFloat64Array(data);
-      try {
-        if (p === 1) {
-          return wasm.norm1(alloc.ptr, n);
-        }
-        if (p === 2) {
-          return wasm.norm2(alloc.ptr, n);
-        }
-        if (p === Number.POSITIVE_INFINITY || p === "inf") {
-          return wasm.normInf(alloc.ptr, n);
-        }
-        if (typeof p === "number" && !isNaN(p) && p !== 0) {
-          return wasm.normP(alloc.ptr, n, p);
-        }
-        return null;
-      } catch {
-        return null;
-      } finally {
-        wasmLoader.free(alloc.ptr);
-      }
-    }
     function _vectorNormPlusInfinity(x) {
       let pinf = 0;
       x.forEach(function(value) {
@@ -43259,8 +41398,6 @@ var createNorm = /* @__PURE__ */ factory(
       return ninf || 0;
     }
     function _vectorNorm(x, p) {
-      const wasmResult = _tryWasmVectorNorm(x, p);
-      if (wasmResult !== null) return wasmResult;
       if (p === Number.POSITIVE_INFINITY || p === "inf") {
         return _vectorNormPlusInfinity(x);
       }
@@ -44021,7 +42158,7 @@ var createRotationMatrix = /* @__PURE__ */ factory(
 
 // src/algebra/decomposition/schur.ts
 import { matrixSchur, DenseMatrix as NativeDenseMatrix } from "@danielsimonjr/mathts-matrix";
-function isPlainNumberMatrix9(matrix2) {
+function isPlainNumberMatrix2(matrix2) {
   for (let i = 0; i < matrix2.length; i++) {
     const row2 = matrix2[i];
     for (let j = 0; j < row2.length; j++) {
@@ -44051,7 +42188,7 @@ var createSchur = /* @__PURE__ */ factory(
       }
     });
     function _schur(data) {
-      if (!isPlainNumberMatrix9(data)) {
+      if (!isPlainNumberMatrix2(data)) {
         throw new TypeError("schur: only real (number) matrices are supported");
       }
       const n = data.length;
@@ -57661,6 +55798,7 @@ export {
   isNumeric,
   isPositive,
   isPrime2 as isPrime,
+  isWasmLoaded,
   isZero3 as isZero,
   istft,
   jacobiCN,
@@ -57726,6 +55864,7 @@ export {
   linregress,
   linsolve,
   ljungBox,
+  loadWasm,
   loess,
   log,
   log10,