@danielsimonjr/mathts-functions 0.64.3 → 0.66.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 = {};
@@ -22,6 +24,10 @@ __export(typed_exports, {
   CENTRALITY_WORKER_THRESHOLD: () => CENTRALITY_WORKER_THRESHOLD,
   DIST_WORKER_THRESHOLD: () => DIST_WORKER_THRESHOLD,
   GAUSS_WORKER_THRESHOLD: () => GAUSS_WORKER_THRESHOLD,
+  GL4ConvergenceError: () => GL4ConvergenceError,
+  GL4_A: () => GL4_A,
+  GL4_B: () => GL4_B,
+  GL4_C: () => GL4_C,
   GPU_ELEMENTWISE_OPS: () => GPU_ELEMENTWISE_OPS,
   GPU_MIN_ELEMENTS: () => GPU_MIN_ELEMENTS2,
   GPU_REDUCE_OPS: () => GPU_REDUCE_OPS,
@@ -204,6 +210,7 @@ __export(typed_exports, {
   gammaPDF: () => gammaPDF,
   gammainc: () => gammainc,
   gammaincp: () => gammaincp,
+  gaussLegendre4: () => gaussLegendre4,
   gaussQuad: () => gaussQuad,
   gcd: () => gcd,
   geometricPMF: () => geometricPMF,
@@ -395,6 +402,7 @@ __export(typed_exports, {
   random: () => random,
   randomInt: () => randomInt,
   rank: () => rank,
+  rationalNullspace: () => rationalNullspace,
   rayleighDist: () => rayleighDist,
   rbfInterpolate: () => rbfInterpolate,
   re: () => re,
@@ -1342,7 +1350,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 +1361,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;
@@ -1680,6 +1689,8 @@ var pow = mathTyped2("pow", {
   // Dual numbers (forward-mode AD): constant or variable exponent.
   "Dual, number": (a, b) => a.powConst(b),
   "Dual, Dual": (a, b) => a.pow(b),
+  // Dimensional power, including physics-mode `e^2` (elementary charge squared).
+  "Unit, number": (a, b) => a.pow(b),
   // Matrix power A^n for a square 2-D array and non-negative integer n, via binary
   // exponentiation on the native DenseMatrix backend (accelerated matmul, B2). Element-
   // wise power is `dotPow`; negative/fractional matrix powers need eigendecomposition —
@@ -3681,7 +3692,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 +3711,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 +3737,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 +3758,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 +3780,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 +3942,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 +4222,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 +4234,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 +4246,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 +4258,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 +4274,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 +4389,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 +4415,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 +4472,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 +4529,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 +4741,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 +4756,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 +6483,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 +6745,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 +8399,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 +8749,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 +8826,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 +8834,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 +9011,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 +9030,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 +9133,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 +9151,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 +9264,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 +11104,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,9 +11120,15 @@ 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);
+  const gcd3 = polynomialGCD(a, b);
+  const [quotient] = polyDivMod(polymul(a, b), gcd3);
   const leading = quotient[quotient.length - 1];
   if (leading !== 0 && leading !== 1) {
     return quotient.map((c) => c / leading);
@@ -12583,7 +12294,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 +12335,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 +12932,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 +13802,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 +13821,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 +13849,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;
@@ -14556,6 +14124,109 @@ function quad(f, a, b, opts) {
   return panel(a, b, 0);
 }
 
+// src/numeric/rational-nullspace.ts
+import { Fraction as Fraction2, isFraction as isFraction2 } from "@danielsimonjr/mathts-core";
+function gcd2(a, b) {
+  let x = a < 0n ? -a : a;
+  let y = b < 0n ? -b : b;
+  while (y !== 0n) {
+    const t = y;
+    y = x % y;
+    x = t;
+  }
+  return x;
+}
+function lcm2(a, b) {
+  if (a === 0n || b === 0n) return 0n;
+  return a / gcd2(a, b) * b;
+}
+function entryToFraction(value, row2, col) {
+  if (isFraction2(value)) return value;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new TypeError(
+      `rationalNullspace: entry [${row2}, ${col}] must be a finite number or a Fraction`
+    );
+  }
+  return Number.isInteger(value) ? new Fraction2(value, 1) : Fraction2.fromNumber(value);
+}
+function integerize(vec) {
+  let scale4 = 1n;
+  for (const f of vec) {
+    if (f.numerator !== 0n) scale4 = lcm2(scale4, f.denominator);
+  }
+  const ints = vec.map((f) => f.numerator * scale4 / f.denominator);
+  let content2 = 0n;
+  for (const x of ints) {
+    if (x !== 0n) content2 = gcd2(content2, x);
+  }
+  if (content2 === 0n) content2 = 1n;
+  const reduced = ints.map((x) => x / content2);
+  const first = reduced.find((x) => x !== 0n) ?? 0n;
+  const sign3 = first < 0n ? -1n : 1n;
+  return reduced.map((x) => new Fraction2(sign3 * x, 1n));
+}
+function rref(matrix2) {
+  const rows = matrix2.length;
+  const cols = rows === 0 ? 0 : matrix2[0].length;
+  const pivotCols = [];
+  let r = 0;
+  for (let c = 0; c < cols && r < rows; c++) {
+    let pivotRow = -1;
+    for (let i = r; i < rows; i++) {
+      if (matrix2[i][c].numerator !== 0n) {
+        pivotRow = i;
+        break;
+      }
+    }
+    if (pivotRow === -1) continue;
+    if (pivotRow !== r) {
+      const swap = matrix2[r];
+      matrix2[r] = matrix2[pivotRow];
+      matrix2[pivotRow] = swap;
+    }
+    const pivot = matrix2[r][c];
+    for (let j = 0; j < cols; j++) matrix2[r][j] = matrix2[r][j].div(pivot);
+    for (let i = 0; i < rows; i++) {
+      if (i === r || matrix2[i][c].numerator === 0n) continue;
+      const factor2 = matrix2[i][c];
+      for (let j = 0; j < cols; j++) {
+        matrix2[i][j] = matrix2[i][j].sub(factor2.mul(matrix2[r][j]));
+      }
+    }
+    pivotCols.push(c);
+    r++;
+  }
+  return pivotCols;
+}
+function rationalNullspace(matrix2) {
+  if (matrix2.length === 0) return { basis: [], rank: 0 };
+  const cols = matrix2[0].length;
+  for (let i = 0; i < matrix2.length; i++) {
+    if (!Array.isArray(matrix2[i]) || matrix2[i].length !== cols) {
+      throw new TypeError(
+        `rationalNullspace: row ${i} has length ${matrix2[i]?.length ?? "n/a"}; expected ${cols}`
+      );
+    }
+  }
+  const reduced = matrix2.map((row2, i) => row2.map((value, j) => entryToFraction(value, i, j)));
+  const pivotCols = rref(reduced);
+  const pivotSet = new Set(pivotCols);
+  const basis = [];
+  const zero = new Fraction2(0n, 1n);
+  const one = new Fraction2(1n, 1n);
+  for (let free = 0; free < cols; free++) {
+    if (pivotSet.has(free)) continue;
+    const vec = new Array(cols);
+    for (let j = 0; j < cols; j++) vec[j] = zero;
+    vec[free] = one;
+    for (let i = 0; i < pivotCols.length; i++) {
+      vec[pivotCols[i]] = zero.sub(reduced[i][free]);
+    }
+    basis.push(integerize(vec));
+  }
+  return { basis, rank: pivotCols.length };
+}
+
 // src/numeric/solveParabolicPDE.ts
 function asSpaceFn(c, dflt) {
   if (c === void 0) return () => dflt;
@@ -15121,8 +14792,126 @@ function solveDDE(f, tspan, history, delays, options = {}) {
   };
 }
 
+// src/numeric/gauss-legendre4.ts
+var SQRT3_OVER_6 = Math.sqrt(3) / 6;
+var GL4_C = [0.5 - SQRT3_OVER_6, 0.5 + SQRT3_OVER_6];
+var GL4_A = [
+  [0.25, 0.25 - SQRT3_OVER_6],
+  [0.25 + SQRT3_OVER_6, 0.25]
+];
+var GL4_B = [0.5, 0.5];
+var GL4ConvergenceError = class extends Error {
+  constructor(message = "Picard iteration did not converge") {
+    super(message);
+    this.name = "GL4ConvergenceError";
+  }
+};
+function assertFiniteVector(label, v) {
+  for (let i = 0; i < v.length; i++) {
+    if (!Number.isFinite(v[i])) {
+      throw new TypeError(`${label}[${i}] must be a finite number`);
+    }
+  }
+}
+function gaussLegendre4(f, y0, tspan, options) {
+  if (y0.length === 0) {
+    throw new TypeError("y0 must be a non-empty vector");
+  }
+  assertFiniteVector("y0", y0);
+  const t0 = tspan[0];
+  const t1 = tspan[1];
+  if (!Number.isFinite(t0) || !Number.isFinite(t1)) {
+    throw new TypeError("tspan entries must be finite numbers");
+  }
+  const picardTol = options?.picardTol ?? 1e-12;
+  const picardMaxIter = options?.picardMaxIter ?? 64;
+  if (!(picardTol > 0) || !Number.isFinite(picardTol)) {
+    throw new TypeError("picardTol must be a positive finite number");
+  }
+  if (!Number.isInteger(picardMaxIter) || picardMaxIter < 1) {
+    throw new TypeError("picardMaxIter must be a positive integer");
+  }
+  if (t0 === t1) {
+    return { t: [t0], y: [y0.slice()] };
+  }
+  const span = t1 - t0;
+  let nSteps;
+  if (options?.steps !== void 0) {
+    nSteps = options.steps;
+    if (!Number.isInteger(nSteps) || nSteps < 1) {
+      throw new TypeError("steps must be a positive integer");
+    }
+  } else if (options?.h !== void 0) {
+    const hAbs = options.h;
+    if (!(hAbs > 0) || !Number.isFinite(hAbs)) {
+      throw new TypeError("h must be a positive finite number");
+    }
+    nSteps = Math.max(1, Math.ceil(Math.abs(span) / hAbs));
+  } else {
+    nSteps = 100;
+  }
+  const h = span / nSteps;
+  const n = y0.length;
+  const c0 = GL4_C[0];
+  const c1 = GL4_C[1];
+  const a00 = GL4_A[0][0];
+  const a01 = GL4_A[0][1];
+  const a10 = GL4_A[1][0];
+  const a11 = GL4_A[1][1];
+  const b0 = GL4_B[0];
+  const b1 = GL4_B[1];
+  const t = [t0];
+  const y = [y0.slice()];
+  let tn = t0;
+  let yn = y0.slice();
+  for (let step = 0; step < nSteps; step++) {
+    let Y0 = yn.slice();
+    let Y1 = yn.slice();
+    let converged = false;
+    const next = new Array(n);
+    for (let iter = 0; iter < picardMaxIter; iter++) {
+      const k0 = f(tn + c0 * h, Y0);
+      const k1 = f(tn + c1 * h, Y1);
+      if (k0.length !== n || k1.length !== n) {
+        throw new TypeError(`f must return a vector of length ${n}`);
+      }
+      assertFiniteVector("f(t, y)", k0);
+      assertFiniteVector("f(t, y)", k1);
+      let maxDiff = 0;
+      const nY0 = new Array(n);
+      const nY1 = new Array(n);
+      for (let i = 0; i < n; i++) {
+        nY0[i] = yn[i] + h * (a00 * k0[i] + a01 * k1[i]);
+        nY1[i] = yn[i] + h * (a10 * k0[i] + a11 * k1[i]);
+        const d0 = Math.abs(nY0[i] - Y0[i]);
+        const d1 = Math.abs(nY1[i] - Y1[i]);
+        if (d0 > maxDiff) maxDiff = d0;
+        if (d1 > maxDiff) maxDiff = d1;
+      }
+      Y0 = nY0;
+      Y1 = nY1;
+      if (maxDiff <= picardTol) {
+        for (let i = 0; i < n; i++) {
+          next[i] = yn[i] + h * (b0 * k0[i] + b1 * k1[i]);
+        }
+        converged = true;
+        break;
+      }
+    }
+    if (!converged) {
+      throw new GL4ConvergenceError(
+        `Picard iteration did not converge within ${picardMaxIter} iterations (step h=${h})`
+      );
+    }
+    tn += h;
+    yn = next;
+    t.push(tn);
+    y.push(yn.slice());
+  }
+  return { t, y };
+}
+
 // 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 +15101,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 +15243,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 +15292,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 +15318,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 +15349,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 +15600,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 +15759,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 +18894,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]];
@@ -20186,12 +19775,12 @@ function rowReduce(A, tol = 1e-10) {
   return M;
 }
 function matrixRank(A, tol = 1e-10) {
-  const rref = rowReduce(A, tol);
+  const rref2 = rowReduce(A, tol);
   let r = 0;
-  for (let i = 0; i < rref.length; i++) {
+  for (let i = 0; i < rref2.length; i++) {
     let nonzero = false;
-    for (let j = 0; j < rref[i].length; j++) {
-      if (Math.abs(rref[i][j]) > tol) {
+    for (let j = 0; j < rref2[i].length; j++) {
+      if (Math.abs(rref2[i][j]) > tol) {
         nonzero = true;
         break;
       }
@@ -20531,11 +20120,11 @@ async function jordanForm(A) {
   return { J, P: P2 };
 }
 function matrixRankInternal(A, tol) {
-  const rref = rowReduce(A, tol);
+  const rref2 = rowReduce(A, tol);
   let r = 0;
-  for (let i = 0; i < rref.length; i++) {
-    for (let j = 0; j < rref[i].length; j++) {
-      if (Math.abs(rref[i][j]) > tol) {
+  for (let i = 0; i < rref2.length; i++) {
+    for (let j = 0; j < rref2[i].length; j++) {
+      if (Math.abs(rref2[i][j]) > tol) {
         r++;
         break;
       }
@@ -20595,11 +20184,11 @@ async function buildJordanBlocks(A, lambda, algebraicMult, geoMult, n, tol) {
   return blocks;
 }
 function findKernelVector(A, n, tol) {
-  const rref = rowReduce(A, tol);
+  const rref2 = rowReduce(A, tol);
   const pivotCols = /* @__PURE__ */ new Set();
   for (let i = 0; i < n; i++) {
     for (let j = 0; j < n; j++) {
-      if (Math.abs(rref[i][j]) > tol) {
+      if (Math.abs(rref2[i][j]) > tol) {
         pivotCols.add(j);
         break;
       }
@@ -20621,8 +20210,8 @@ function findKernelVector(A, n, tol) {
   v[freeCol] = 1;
   for (let i = 0; i < n; i++) {
     for (let j = 0; j < n; j++) {
-      if (Math.abs(rref[i][j]) > tol) {
-        v[j] = -rref[i][freeCol];
+      if (Math.abs(rref2[i][j]) > tol) {
+        v[j] = -rref2[i][freeCol];
         break;
       }
     }
@@ -20755,7 +20344,7 @@ import { enableGpu, disableGpu, isGpuEnabled as isGpuEnabled3, GPU_MIN_ELEMENTS
 
 // src/typed/relational.ts
 import naturalSort from "javascript-natural-sort";
-import { mathTyped as mathTyped14, Complex as Complex6, BigNumber as BigNumber6, Fraction as Fraction2 } from "@danielsimonjr/mathts-core";
+import { mathTyped as mathTyped14, Complex as Complex6, BigNumber as BigNumber6, Fraction as Fraction3 } from "@danielsimonjr/mathts-core";
 var REL_TOL = 1e-12;
 var ABS_TOL = 1e-15;
 function numbersNearlyEqual(x, y) {
@@ -20779,7 +20368,7 @@ function typeNameOf(x) {
   if (typeof x === "string") return "string";
   if (x instanceof Complex6) return "Complex";
   if (x instanceof BigNumber6) return "BigNumber";
-  if (x instanceof Fraction2) return "Fraction";
+  if (x instanceof Fraction3) return "Fraction";
   if (Array.isArray(x)) return "Array";
   if (typeof x === "object") return "Object";
   return typeof x;
@@ -20917,7 +20506,7 @@ function _numericCompare(x, y) {
   let ny;
   if (x instanceof BigNumber6) {
     nx = x.toNumber();
-  } else if (x instanceof Fraction2) {
+  } else if (x instanceof Fraction3) {
     nx = x.valueOf();
   } else if (typeof x === "bigint") {
     nx = Number(x);
@@ -20926,7 +20515,7 @@ function _numericCompare(x, y) {
   }
   if (y instanceof BigNumber6) {
     ny = y.toNumber();
-  } else if (y instanceof Fraction2) {
+  } else if (y instanceof Fraction3) {
     ny = y.valueOf();
   } else if (typeof y === "bigint") {
     ny = Number(y);
@@ -21346,7 +20935,7 @@ import {
 } from "@danielsimonjr/mathts-expression";
 import {
   Complex as Complex9,
-  Fraction as Fraction4,
+  Fraction as Fraction5,
   I,
   PHI,
   SQRT2,
@@ -21354,11 +20943,12 @@ import {
   LN2 as LN22,
   LN10,
   LOG2E,
-  LOG10E
+  LOG10E,
+  Unit as Unit2
 } from "@danielsimonjr/mathts-core";
 
 // src/factories/scope.ts
-import { mathTyped as mathTyped18, Complex as Complex7, Fraction as Fraction3, BigNumber as BigNumber8 } from "@danielsimonjr/mathts-core";
+import { mathTyped as mathTyped18, Complex as Complex7, Fraction as Fraction4, BigNumber as BigNumber8 } from "@danielsimonjr/mathts-core";
 
 // src/typed/typed-bridge.ts
 import { registerNativeTypes } from "@danielsimonjr/mathts-core";
@@ -21473,7 +21063,7 @@ var factoryScope = {
   // Class constructors (uppercase) — factories use `new BigNumber(...)` etc.
   Complex: Complex7,
   BigNumber: BigNumber8,
-  Fraction: Fraction3,
+  Fraction: Fraction4,
   // Matrix bridge classes
   DenseMatrix: MathJSDenseMatrix,
   SparseMatrix: MathJSSparseMatrix,
@@ -21487,7 +21077,7 @@ var factoryScope = {
     if (typeof x === "number") return BigNumber8.fromNumber(x);
     return BigNumber8.fromNumber(Number(x.valueOf()));
   },
-  fraction: (n, d) => new Fraction3(n, d ?? 1),
+  fraction: (n, d) => new Fraction4(n, d ?? 1),
   number: Number,
   // Matrix helper factories
   createDenseMatrix: (data) => new MathJSDenseMatrix(data),
@@ -22013,7 +21603,7 @@ var dependencies10 = ["typed", "BigNumber", "complex", "Fraction"];
 var createSign = /* @__PURE__ */ factory(
   name10,
   dependencies10,
-  ({ typed: typed3, BigNumber: BigNumber9, complex: complex3, Fraction: Fraction5 }) => {
+  ({ typed: typed3, BigNumber: BigNumber9, complex: complex3, Fraction: Fraction6 }) => {
     return typed3(name10, {
       number: signNumber,
       Complex: function(x) {
@@ -22026,7 +21616,7 @@ var createSign = /* @__PURE__ */ factory(
         return x > 0n ? 1n : x < 0n ? -1n : 0n;
       },
       Fraction: function(x) {
-        return x.n === 0n ? new Fraction5(0) : new Fraction5(x.s);
+        return x.n === 0n ? new Fraction6(0) : new Fraction6(x.s);
       },
       // deep map collection, skip zeros since sign(0) = 0
       "Array | Matrix": typed3.referToSelf(
@@ -23164,22 +22754,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 +23090,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 +24362,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 +24389,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 +24574,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 +24621,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 +24945,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 +24975,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 +25379,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 +25390,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 +25452,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 +25459,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 +25697,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 +25710,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 +26079,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 +26092,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 +26556,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 +26600,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 +26813,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 +26857,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;
@@ -27911,7 +27092,7 @@ var createCbrt = /* @__PURE__ */ factory(
     matrix: matrix2,
     Complex: Complex13,
     BigNumber: BigNumber9,
-    Fraction: Fraction5
+    Fraction: Fraction6
   }) => {
     return typed3(name106, {
       number: cbrtNumber,
@@ -27969,7 +27150,7 @@ var createCbrt = /* @__PURE__ */ factory(
       if (isBigNumber(value)) {
         return new BigNumber9(1).div(3);
       } else if (isFraction(value)) {
-        return new Fraction5(1, 3);
+        return new Fraction6(1, 3);
       } else {
         return 1 / 3;
       }
@@ -28410,7 +27591,7 @@ var dependencies112 = ["typed", "config", "matrix", "BigNumber", "?Fraction"];
 var createXgcd = /* @__PURE__ */ factory(
   name112,
   dependencies112,
-  ({ typed: typed3, config: config2, matrix: matrix2, BigNumber: BigNumber9, Fraction: Fraction5 }) => {
+  ({ typed: typed3, config: config2, matrix: matrix2, BigNumber: BigNumber9, Fraction: Fraction6 }) => {
     const typedSignatures = {
       "number, number": function(a, b) {
         const res = xgcdNumber(a, b);
@@ -28418,7 +27599,7 @@ var createXgcd = /* @__PURE__ */ factory(
       },
       "BigNumber, BigNumber": _xgcdBigNumber
     };
-    if (Fraction5) {
+    if (Fraction6) {
       typedSignatures["Fraction, Fraction"] = _xgcdFraction;
     }
     return typed3(name112, typedSignatures);
@@ -28456,14 +27637,14 @@ var createXgcd = /* @__PURE__ */ factory(
       return config2.matrix === "Array" ? res : matrix2(res);
     }
     function _xgcdFraction(a, b) {
-      if (!Fraction5) {
+      if (!Fraction6) {
         throw new Error("Fraction is not available");
       }
       let t;
       let q;
       let r;
-      const zero = new Fraction5(0);
-      const one = new Fraction5(1);
+      const zero = new Fraction6(0);
+      const one = new Fraction6(1);
       let x = zero;
       let lastx = one;
       let y = one;
@@ -28645,27 +27826,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 +27894,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) {
@@ -29250,7 +28378,7 @@ var createBernoulli = /* @__PURE__ */ factory(
     isInteger: _isInteger,
     number: number2,
     BigNumber: BigNumber9,
-    Fraction: Fraction5
+    Fraction: Fraction6
   }) => {
     const numberCache = [void 0];
     const fractionCache = [void 0];
@@ -29267,7 +28395,7 @@ var createBernoulli = /* @__PURE__ */ factory(
       ),
       "bigint | Fraction": (index) => _bernoulli(
         number2(index),
-        (n) => new Fraction5(n),
+        (n) => new Fraction6(n),
         fractionCache,
         (a, b) => a.add(b),
         (a, b) => a.mul(b),
@@ -29826,6 +28954,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 +29015,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 +29062,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 +29114,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 +29146,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 +29954,6 @@ var createMatAlgo10xSids = /* @__PURE__ */ factory(
 );
 
 // src/arithmetic/gcd.ts
-var WASM_GCD_ARRAY_THRESHOLD = 50;
 var name140 = "gcd";
 var dependencies140 = [
   "typed",
@@ -30898,14 +30027,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 +30039,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");
@@ -32137,7 +31240,7 @@ var createCompare = /* @__PURE__ */ factory(
     equalScalar: equalScalar3,
     matrix: matrix2,
     BigNumber: BigNumber9,
-    Fraction: Fraction5,
+    Fraction: Fraction6,
     DenseMatrix: DenseMatrix7,
     concat: concat3
   }) => {
@@ -32165,7 +31268,7 @@ var createCompare = /* @__PURE__ */ factory(
           return x === y ? 0n : x > y ? 1n : -1n;
         },
         "Fraction, Fraction": function(x, y) {
-          return new Fraction5(x.compare(y));
+          return new Fraction6(x.compare(y));
         },
         "Complex, Complex": function() {
           throw new TypeError("No ordering relation is defined for complex numbers");
@@ -32841,8 +31944,8 @@ var createInvmod = /* @__PURE__ */ factory(
       if (equal2(b, 0)) throw new Error("Divisor must be non zero");
       const res = xgcd2(a, b);
       const resVal = res.valueOf();
-      const [gcd2, invValue] = resVal;
-      if (!equal2(gcd2, 1)) return NaN;
+      const [gcd3, invValue] = resVal;
+      if (!equal2(gcd3, 1)) return NaN;
       let inv3 = mod3(invValue, b);
       if (smaller2(inv3, 0)) inv3 = add5(inv3, b);
       return inv3;
@@ -32988,15 +32091,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 +32136,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) {
@@ -33215,9 +32286,9 @@ var createPinv = /* @__PURE__ */ factory(
       return M;
     }
     function _rankFact(mat, rows, cols) {
-      const rref = _rref(mat, rows, cols);
-      const C = mat.map((row2) => row2.filter((_, j) => j < rows && !_isZero(dot9(rref[j], rref[j]))));
-      const F = rref.filter((_, i) => !_isZero(dot9(rref[i], rref[i])));
+      const rref2 = _rref(mat, rows, cols);
+      const C = mat.map((row2) => row2.filter((_, j) => j < rows && !_isZero(dot9(rref2[j], rref2[j]))));
+      const F = rref2.filter((_, i) => !_isZero(dot9(rref2[i], rref2[i])));
       return { C, F };
     }
     function _isZero(x) {
@@ -33233,27 +32304,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 +32363,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 +32855,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 +32885,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 +32909,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 +32939,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 +33054,6 @@ var createNullish = /* @__PURE__ */ factory(
 );
 
 // src/arithmetic/hypot.ts
-var WASM_HYPOT_THRESHOLD = 50;
 var name181 = "hypot";
 var dependencies181 = [
   "typed",
@@ -34122,28 +33083,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 +33412,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 +33429,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);
-      }
-    }
   }
 );
 
@@ -36497,33 +35404,33 @@ var dependencies203 = ["typed", "Unit"];
 var createCreateUnit = /* @__PURE__ */ factory(
   name203,
   dependencies203,
-  ({ typed: typed3, Unit: Unit2 }) => {
+  ({ typed: typed3, Unit: Unit3 }) => {
     return typed3(name203, {
       // General function signature. First parameter is an object where each property is the definition of a new unit. The object keys are the unit names and the values are the definitions. The values can be objects, strings, or Units. If a property is an empty object or an empty string, a new base unit is created. The second parameter is the options.
       "Object, Object": function(obj, options) {
-        return Unit2.createUnit(obj, options);
+        return Unit3.createUnit(obj, options);
       },
       // Same as above but without the options.
       Object: function(obj) {
-        return Unit2.createUnit(obj, {});
+        return Unit3.createUnit(obj, {});
       },
       // Shortcut method for creating one unit.
       "string, Unit | string | Object, Object": function(name254, def, options) {
         const obj = {};
         obj[name254] = def;
-        return Unit2.createUnit(obj, options);
+        return Unit3.createUnit(obj, options);
       },
       // Same as above but without the options.
       "string, Unit | string | Object": function(name254, def) {
         const obj = {};
         obj[name254] = def;
-        return Unit2.createUnit(obj, {});
+        return Unit3.createUnit(obj, {});
       },
       // Without a definition, creates a base unit.
       string: function(name254) {
         const obj = {};
         obj[name254] = {};
-        return Unit2.createUnit(obj, {});
+        return Unit3.createUnit(obj, {});
       }
     });
   }
@@ -36535,22 +35442,22 @@ var dependencies204 = ["typed", "Unit"];
 var createUnitFunction = /* @__PURE__ */ factory(
   name204,
   dependencies204,
-  ({ typed: typed3, Unit: Unit2 }) => {
+  ({ typed: typed3, Unit: Unit3 }) => {
     return typed3(name204, {
       Unit: function(x) {
         return x.clone();
       },
       string: function(x) {
-        if (Unit2.isValuelessUnit(x)) {
-          return new Unit2(null, x);
+        if (Unit3.isValuelessUnit(x)) {
+          return new Unit3(null, x);
         }
-        return Unit2.parse(x, { allowNoUnits: true });
+        return Unit3.parse(x, { allowNoUnits: true });
       },
       "number | BigNumber | Fraction | Complex, string | Unit": function(value, unit2) {
-        return new Unit2(value, unit2);
+        return new Unit3(value, unit2);
       },
       "number | BigNumber | Fraction": function(value) {
-        return new Unit2(value);
+        return new Unit3(value);
       },
       "Array | Matrix": typed3.referToSelf(
         (self) => (x) => deepMap(x, self)
@@ -37158,11 +36065,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 +36129,6 @@ var createDiff = /* @__PURE__ */ factory(
 );
 
 // src/matrix/sqrtm.ts
-var WASM_SQRTM_THRESHOLD = 16;
 var name211 = "sqrtm";
 var dependencies211 = [
   "typed",
@@ -37240,62 +36149,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 +36181,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 +36199,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 +36254,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 +37137,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 +37162,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 +37243,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 +37273,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 +37357,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 +37402,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 +37730,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 +37784,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 +38896,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 +38921,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 +39331,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 +39368,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 +39890,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 +39901,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 +40029,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 +40048,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 +41550,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 +41608,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 +41629,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 +42389,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 +42419,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;
@@ -44477,9 +42845,9 @@ function unitFactory(name254, valueStr, unitStr) {
   return factory(
     name254,
     dependencies254,
-    ({ config: config2, Unit: Unit2, BigNumber: BigNumber9 }) => {
+    ({ config: config2, Unit: Unit3, BigNumber: BigNumber9 }) => {
       const value = config2.number === "BigNumber" ? new BigNumber9(valueStr) : parseFloat(valueStr);
-      const unit2 = new Unit2(value, unitStr);
+      const unit2 = new Unit3(value, unitStr);
       unit2.fixPrefix = true;
       return unit2;
     }
@@ -45422,18 +43790,64 @@ var mathScope = {
   }
 }
 var parse = factoryScope.parse;
-var evaluate = createEvaluate(parse, mathScope);
-function compileExpr(expr) {
-  return _compileExpression(parse, mathScope, expr);
+var _evaluate = createEvaluate(parse, mathScope);
+var ELEMENTARY_CHARGE_COULOMB = 1602176634e-28;
+function elementaryChargeUnit() {
+  return new Unit2(ELEMENTARY_CHARGE_COULOMB, "C");
+}
+function isMapScope(scope) {
+  const candidate = scope;
+  return typeof candidate.has === "function" && typeof candidate.get === "function" && typeof candidate.set === "function";
+}
+function physicsScope(scope) {
+  const charge = elementaryChargeUnit();
+  if (scope == null) return { e: charge };
+  if (isMapScope(scope)) {
+    if (scope.has("e")) return scope;
+    return {
+      has(key2) {
+        return key2 === "e" || scope.has(key2);
+      },
+      get(key2) {
+        return key2 === "e" ? charge : scope.get(key2);
+      },
+      set(key2, value) {
+        scope.set(key2, value);
+      }
+    };
+  }
+  if (Object.prototype.hasOwnProperty.call(scope, "e")) return scope;
+  return { e: charge, ...scope };
+}
+function evaluate(exprOrExprs, scope, options) {
+  const bound = options?.physics === true ? physicsScope(scope) : scope;
+  const inner = options?.unsafe === true ? { unsafe: true } : void 0;
+  if (Array.isArray(exprOrExprs)) return _evaluate(exprOrExprs, bound, inner);
+  return _evaluate(exprOrExprs, bound, inner);
+}
+function compileExpr(expr, options) {
+  const compiled = _compileExpression(
+    parse,
+    mathScope,
+    expr,
+    options?.unsafe === true ? { unsafe: true } : void 0
+  );
+  if (options?.physics !== true) return compiled;
+  return {
+    evaluate(scope) {
+      return compiled.evaluate(physicsScope(scope));
+    }
+  };
 }
-function parser() {
+function parser(options) {
   const scope = {};
+  const callOptions = options?.physics === true || options?.unsafe === true ? { physics: options.physics, unsafe: options.unsafe } : void 0;
   return {
     /** The live scope object — assignments during `evaluate` land here. */
     scope,
     /** Evaluate an expression against the retained scope. */
     evaluate(expr) {
-      return evaluate(expr, scope);
+      return evaluate(expr, scope, callOptions);
     },
     /** Read a retained variable. */
     get(name254) {
@@ -45468,7 +43882,7 @@ function reviver(_key, value) {
       case "Complex":
         return Complex9.fromJSON(tagged);
       case "Fraction":
-        return Fraction4.fromJSON(tagged);
+        return Fraction5.fromJSON(tagged);
       case "number":
         if (tagged.value === "Infinity") return Infinity;
         if (tagged.value === "-Infinity") return -Infinity;
@@ -47007,6 +45421,89 @@ function config(options) {
   return { ...shared };
 }
 
+// src/numeric/propagate-uncertainty.ts
+function asFiniteNumber(label, value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new TypeError(`${label} is not a finite number`);
+  }
+  return value;
+}
+function partialDerivative2(expr, name254, values) {
+  const node = derivative2(expr, name254);
+  return asFiniteNumber(`partial of "${expr}" with respect to "${name254}"`, node.evaluate(values));
+}
+function propagateUncertainty(expr, values, sigmas, options) {
+  if (typeof expr !== "string" || expr.length === 0) {
+    throw new TypeError("expr must be a non-empty string");
+  }
+  if (values === null || typeof values !== "object") {
+    throw new TypeError("values must be an object of finite numbers");
+  }
+  const names = Object.keys(values);
+  const point = {};
+  for (const name254 of names) {
+    point[name254] = asFiniteNumber(`values.${name254}`, values[name254]);
+  }
+  const covariance = options?.covariance;
+  if (covariance !== void 0 && sigmas !== void 0) {
+    throw new TypeError("pass either sigmas or covariance, not both");
+  }
+  if (sigmas !== void 0 && (sigmas === null || typeof sigmas !== "object")) {
+    throw new TypeError("sigmas must be an object of finite numbers");
+  }
+  const partials = {};
+  const gradient2 = [];
+  for (const name254 of names) {
+    const d = partialDerivative2(expr, name254, point);
+    partials[name254] = d;
+    gradient2.push(d);
+  }
+  const value = asFiniteNumber(`value of "${expr}"`, evaluate(expr, point));
+  let variance2;
+  if (covariance !== void 0) {
+    const n = names.length;
+    if (covariance.length !== n) {
+      throw new TypeError(`covariance must be ${n}\xD7${n} to match values`);
+    }
+    variance2 = 0;
+    for (let i = 0; i < n; i++) {
+      const row2 = covariance[i];
+      if (row2 === void 0 || row2.length !== n) {
+        throw new TypeError(`covariance must be ${n}\xD7${n} to match values`);
+      }
+      let acc = 0;
+      for (let j = 0; j < n; j++) {
+        const sij = asFiniteNumber(`covariance[${i}][${j}]`, row2[j]);
+        acc += sij * gradient2[j];
+      }
+      variance2 += gradient2[i] * acc;
+    }
+  } else {
+    variance2 = 0;
+    if (sigmas !== void 0) {
+      for (const key2 of Object.keys(sigmas)) {
+        if (!Object.prototype.hasOwnProperty.call(point, key2)) {
+          throw new TypeError(`sigmas.${key2} has no matching value`);
+        }
+      }
+      for (let i = 0; i < names.length; i++) {
+        const name254 = names[i];
+        if (!Object.prototype.hasOwnProperty.call(sigmas, name254)) continue;
+        const sigma = asFiniteNumber(`sigmas.${name254}`, sigmas[name254]);
+        if (sigma < 0) {
+          throw new RangeError(`sigmas.${name254} must be >= 0`);
+        }
+        variance2 += (gradient2[i] * sigma) ** 2;
+      }
+    }
+  }
+  if (variance2 < 0) {
+    if (variance2 > -1e-12) variance2 = 0;
+    else throw new RangeError("covariance produced a negative variance");
+  }
+  return { value, sigma: Math.sqrt(variance2), partials };
+}
+
 // src/help.ts
 import { createHelpClass, embeddedDocs } from "@danielsimonjr/mathts-expression";
 var savedConfig = {};
@@ -51320,8 +49817,8 @@ function intToRatPoly(p) {
 }
 function ratPolyToInt(p) {
   if (p.length === 0) return { poly: [], den: 1n };
-  let lcm2 = 1n;
-  const gcd2 = (a, b) => {
+  let lcm3 = 1n;
+  const gcd3 = (a, b) => {
     let x = a < 0n ? -a : a;
     let y = b < 0n ? -b : b;
     while (y !== 0n) {
@@ -51332,10 +49829,10 @@ function ratPolyToInt(p) {
     return x;
   };
   for (const r of p) {
-    const g = gcd2(lcm2, r.den);
-    lcm2 = lcm2 / g * r.den;
+    const g = gcd3(lcm3, r.den);
+    lcm3 = lcm3 / g * r.den;
   }
-  return { poly: trim(p.map((r) => r.num * lcm2 / r.den)), den: lcm2 };
+  return { poly: trim(p.map((r) => r.num * lcm3 / r.den)), den: lcm3 };
 }
 function rpAdd(a, b) {
   const n = Math.max(a.length, b.length);
@@ -57139,6 +55636,10 @@ export {
   DIST_WORKER_THRESHOLD,
   EARTH_RADIUS_KM,
   GAUSS_WORKER_THRESHOLD,
+  GL4ConvergenceError,
+  GL4_A,
+  GL4_B,
+  GL4_C,
   GPU_ELEMENTWISE_OPS,
   GPU_MIN_ELEMENTS2 as GPU_MIN_ELEMENTS,
   GPU_REDUCE_OPS,
@@ -57561,6 +56062,7 @@ export {
   gammainc,
   gammaincp,
   gasConstant,
+  gaussLegendre4,
   gaussQuad,
   gaussianKDE,
   gaussianProcessRegression,
@@ -57661,6 +56163,7 @@ export {
   isNumeric,
   isPositive,
   isPrime2 as isPrime,
+  isWasmLoaded,
   isZero3 as isZero,
   istft,
   jacobiCN,
@@ -57726,6 +56229,7 @@ export {
   linregress,
   linsolve,
   ljungBox,
+  loadWasm,
   loess,
   log,
   log10,
@@ -57901,6 +56405,7 @@ export {
   permutationTest,
   permutations,
   permutationsGen,
+  physicsScope,
   pickRandom,
   piecewise,
   pinv,
@@ -57940,6 +56445,7 @@ export {
   procrustes,
   prod,
   projectVector,
+  propagateUncertainty,
   proportionCI,
   proportionZTest,
   protonMass,
@@ -57968,6 +56474,7 @@ export {
   range,
   rank,
   rankdata,
+  rationalNullspace,
   rationalize,
   rayPlaneIntersect,
   rayTriangleIntersect,