@danielsimonjr/mathts-functions 0.2.12 → 0.2.14

package/dist/index.js

@@ -144,6 +144,7 @@ __export(typed_exports, {
   equalScalar: () => equalScalar,
   equalText: () => equalText,
   erfc: () => erfc,
+  erfcScalar: () => erfcScalar,
   erfi: () => erfi,
   eulerPhi: () => eulerPhi,
   eventDetection: () => eventDetection,
@@ -170,6 +171,7 @@ __export(typed_exports, {
   fresnelS: () => fresnelS,
   fullSimplify: () => fullSimplify,
   functionExpand: () => functionExpand,
+  fuseUnaryChain: () => fuseUnaryChain,
   gammaDist: () => gammaDist,
   gammaPDF: () => gammaPDF,
   gammainc: () => gammainc,
@@ -459,6 +461,81 @@ __export(typed_exports, {
 // src/typed/arithmetic.ts
 import { mathTyped, Complex, Fraction, BigNumber } from "@danielsimonjr/mathts-core";
 import { computePool } from "@danielsimonjr/mathts-parallel";
+
+// src/wasm/elementwise/wasm-bridge.ts
+var WASM_ELEMENTWISE_THRESHOLD = 1024;
+function getWasm() {
+  try {
+    return wasmLoader.getModule();
+  } catch {
+    return null;
+  }
+}
+var scratchBase = -1;
+function elementwiseUnaryDispatch(op, xs) {
+  const n = xs.length;
+  if (n < WASM_ELEMENTWISE_THRESHOLD) return null;
+  const wasm = getWasm();
+  if (!wasm) return null;
+  const fn = wasm[`simd_${op}_array`];
+  const mem = wasm.memory;
+  if (typeof fn !== "function" || !(mem instanceof WebAssembly.Memory)) return null;
+  try {
+    const need = 2 * n * 8;
+    if (scratchBase < 0) scratchBase = mem.buffer.byteLength;
+    if (scratchBase + need > mem.buffer.byteLength) {
+      mem.grow(Math.ceil((scratchBase + need - mem.buffer.byteLength) / 65536));
+    }
+    const inOff = scratchBase;
+    const outOff = scratchBase + n * 8;
+    new Float64Array(mem.buffer, inOff, n).set(xs);
+    fn(inOff, outOff, n);
+    const result = new Float64Array(n);
+    result.set(new Float64Array(mem.buffer, outOff, n));
+    return result;
+  } catch {
+    return null;
+  }
+}
+function elementwiseChainDispatch(ops, xs) {
+  const n = xs.length;
+  if (ops.length === 0 || n < WASM_ELEMENTWISE_THRESHOLD) return null;
+  const wasm = getWasm();
+  if (!wasm) return null;
+  const mem = wasm.memory;
+  if (!(mem instanceof WebAssembly.Memory)) return null;
+  const kernels = [];
+  for (const op of ops) {
+    const fn = wasm[`simd_${op}_array`];
+    if (typeof fn !== "function") return null;
+    kernels.push(fn);
+  }
+  try {
+    const need = 2 * n * 8;
+    if (scratchBase < 0) scratchBase = mem.buffer.byteLength;
+    if (scratchBase + need > mem.buffer.byteLength) {
+      mem.grow(Math.ceil((scratchBase + need - mem.buffer.byteLength) / 65536));
+    }
+    const bufA = scratchBase;
+    const bufB = scratchBase + n * 8;
+    new Float64Array(mem.buffer, bufA, n).set(xs);
+    let cur = bufA;
+    let other = bufB;
+    for (const fn of kernels) {
+      fn(cur, other, n);
+      const t = cur;
+      cur = other;
+      other = t;
+    }
+    const result = new Float64Array(n);
+    result.set(new Float64Array(mem.buffer, cur, n));
+    return result;
+  } catch {
+    return null;
+  }
+}
+
+// src/typed/arithmetic.ts
 var add = mathTyped("add", {
   "number, number": (a, b) => a + b,
   "bigint, bigint": (a, b) => a + b,
@@ -594,6 +671,8 @@ var abs = mathTyped("abs", {
   BigNumber: (a) => a.abs(),
   // Parallel array abs
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("abs", a);
+    if (wasm) return wasm;
     const result = await computePool.abs(a);
     return result.result;
   }
@@ -693,6 +772,8 @@ var exp = mathTyped("exp", {
   BigNumber: (a) => a.exp(),
   // Parallel array exp
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("exp", a);
+    if (wasm) return wasm;
     const result = await computePool.exp(a);
     return result.result;
   }
@@ -704,6 +785,8 @@ var log = mathTyped("log", {
   "number, number": (a, base) => Math.log(a) / Math.log(base),
   // Parallel array log
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("log", a);
+    if (wasm) return wasm;
     const result = await computePool.log(a);
     return result.result;
   }
@@ -714,6 +797,8 @@ var log10 = mathTyped("log10", {
   BigNumber: (a) => a.log10(),
   // Parallel array log10
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("log10", a);
+    if (wasm) return wasm;
     if (computePool.shouldParallelize(a.length)) {
       const r = await computePool.applyKernel(a, "(x) => Math.log10(x)");
       return r.result;
@@ -729,6 +814,8 @@ var log2 = mathTyped("log2", {
   BigNumber: (a) => a.log2(),
   // Parallel array log2
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("log2", a);
+    if (wasm) return wasm;
     if (computePool.shouldParallelize(a.length)) {
       const r = await computePool.applyKernel(a, "(x) => Math.log2(x)");
       return r.result;
@@ -742,6 +829,8 @@ var log1p = mathTyped("log1p", {
   number: (a) => Math.log1p(a),
   // Parallel array log1p
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("log1p", a);
+    if (wasm) return wasm;
     if (computePool.shouldParallelize(a.length)) {
       const r = await computePool.applyKernel(a, "(x) => Math.log1p(x)");
       return r.result;
@@ -755,6 +844,8 @@ var expm1 = mathTyped("expm1", {
   number: (a) => Math.expm1(a),
   // Parallel array expm1
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("expm1", a);
+    if (wasm) return wasm;
     if (computePool.shouldParallelize(a.length)) {
       const r = await computePool.applyKernel(a, "(x) => Math.expm1(x)");
       return r.result;
@@ -920,6 +1011,8 @@ var sinh = mathTyped("sinh", {
   BigNumber: (a) => a.sinh(),
   // Parallel array sinh
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("sinh", a);
+    if (wasm) return wasm;
     if (computePool.shouldParallelize(a.length)) {
       const r = await computePool.applyKernel(a, "(x) => Math.sinh(x)");
       return r.result;
@@ -950,6 +1043,8 @@ var tanh = mathTyped("tanh", {
   BigNumber: (a) => a.tanh(),
   // Parallel array tanh
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("tanh", a);
+    if (wasm) return wasm;
     if (computePool.shouldParallelize(a.length)) {
       const r = await computePool.applyKernel(a, "(x) => Math.tanh(x)");
       return r.result;
@@ -1214,6 +1309,8 @@ var sin = mathTyped2("sin", {
   BigNumber: (a) => a.sin(),
   // Parallel Float64Array sin
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("sin", a);
+    if (wasm) return wasm;
     const result = await computePool2.sin(a);
     return result.result;
   }
@@ -1224,6 +1321,8 @@ var cos = mathTyped2("cos", {
   BigNumber: (a) => a.cos(),
   // Parallel Float64Array cos
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("cos", a);
+    if (wasm) return wasm;
     const result = await computePool2.cos(a);
     return result.result;
   }
@@ -1234,6 +1333,8 @@ var tan = mathTyped2("tan", {
   BigNumber: (a) => a.tan(),
   // Parallel Float64Array tan
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("tan", a);
+    if (wasm) return wasm;
     const result = await computePool2.tan(a);
     return result.result;
   }
@@ -1244,6 +1345,8 @@ var csc = mathTyped2("csc", {
   BigNumber: (a) => BigNumber2.fromNumber(1).divide(a.sin()),
   // Parallel array csc
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("csc", a);
+    if (wasm) return wasm;
     if (computePool2.shouldParallelize(a.length)) {
       const r = await computePool2.applyKernel(a, "(x) => 1 / Math.sin(x)");
       return r.result;
@@ -1259,6 +1362,8 @@ var sec = mathTyped2("sec", {
   BigNumber: (a) => BigNumber2.fromNumber(1).divide(a.cos()),
   // Parallel array sec
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("sec", a);
+    if (wasm) return wasm;
     if (computePool2.shouldParallelize(a.length)) {
       const r = await computePool2.applyKernel(a, "(x) => 1 / Math.cos(x)");
       return r.result;
@@ -1274,6 +1379,8 @@ var cot = mathTyped2("cot", {
   BigNumber: (a) => BigNumber2.fromNumber(1).divide(a.tan()),
   // Parallel array cot
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("cot", a);
+    if (wasm) return wasm;
     if (computePool2.shouldParallelize(a.length)) {
       const r = await computePool2.applyKernel(a, "(x) => 1 / Math.tan(x)");
       return r.result;
@@ -1329,6 +1436,8 @@ var atan = mathTyped2("atan", {
   BigNumber: (a) => a.atan(),
   // Parallel array atan
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("atan", a);
+    if (wasm) return wasm;
     if (computePool2.shouldParallelize(a.length)) {
       const r = await computePool2.applyKernel(a, "(x) => Math.atan(x)");
       return r.result;
@@ -1389,6 +1498,8 @@ var atanh = mathTyped2("atanh", {
   BigNumber: (a) => a.atanh(),
   // Parallel array atanh (values outside (-1, 1) produce NaN or ±Infinity, matching Math.atanh behavior)
   Float64Array: async (a) => {
+    const wasm = elementwiseUnaryDispatch("atanh", a);
+    if (wasm) return wasm;
     if (computePool2.shouldParallelize(a.length)) {
       const r = await computePool2.applyKernel(a, "(x) => Math.atanh(x)");
       return r.result;
@@ -1974,7 +2085,7 @@ import { computePool as computePool4 } from "@danielsimonjr/mathts-parallel";
 
 // src/wasm/signal/wasm-bridge.ts
 var WASM_SIGNAL_THRESHOLD = 4096;
-function getWasm() {
+function getWasm2() {
   try {
     return wasmLoader.getModule();
   } catch {
@@ -2184,7 +2295,7 @@ function chirpZTransformJS(samples, m, phiStartRe, phiStartIm, phiStepRe, phiSte
 }
 function applyWindowDispatch(samples, windowName) {
   const wt = windowTypeCode(windowName);
-  const wasm = getWasm();
+  const wasm = getWasm2();
   if (wasm) {
     const rustFn = wasm["apply_window_f64"];
     if (typeof rustFn === "function") {
@@ -2215,7 +2326,7 @@ function welchPSDDispatch(samples, frameLength, overlap, windowName) {
   const n = samples.length;
   const wt = windowTypeCode(windowName);
   if (n >= WASM_SIGNAL_THRESHOLD && n >= frameLength) {
-    const wasm = getWasm();
+    const wasm = getWasm2();
     if (wasm) {
       const rustFn = wasm["welch_psd_f64"];
       if (typeof rustFn === "function") {
@@ -2254,7 +2365,7 @@ function welchPSDDispatch(samples, frameLength, overlap, windowName) {
 function bartlettPSDDispatch(samples, frameLength) {
   const n = samples.length;
   if (n >= WASM_SIGNAL_THRESHOLD && n >= frameLength) {
-    const wasm = getWasm();
+    const wasm = getWasm2();
     if (wasm) {
       const rustFn = wasm["bartlett_psd_f64"];
       if (typeof rustFn === "function") {
@@ -2288,7 +2399,7 @@ function bartlettPSDDispatch(samples, frameLength) {
 function goertzelDispatch(samples, targetFreq, sampleRate) {
   const n = samples.length;
   if (n >= WASM_SIGNAL_THRESHOLD) {
-    const wasm = getWasm();
+    const wasm = getWasm2();
     if (wasm) {
       const rustFn = wasm["goertzel_f64"];
       if (typeof rustFn === "function") {
@@ -2320,7 +2431,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) {
-    const wasm = getWasm();
+    const wasm = getWasm2();
     if (wasm) {
       const rustFn = wasm["chirp_z_transform_f64"];
       if (typeof rustFn === "function") {
@@ -3409,7 +3520,7 @@ var BINARY_OPS = {
 var UNARY_OPS = {
   bitNot: { rust: "bitNotArray", as: "bitNot_i32_array" }
 };
-function getWasm2() {
+function getWasm3() {
   try {
     return wasmLoader.getModule();
   } catch {
@@ -3417,7 +3528,7 @@ function getWasm2() {
   }
 }
 function getBinaryKernel(op) {
-  const wasm = getWasm2();
+  const wasm = getWasm3();
   if (!wasm) return null;
   const names = BINARY_OPS[op];
   const rust = wasm[names.rust];
@@ -3431,7 +3542,7 @@ function getBinaryKernel(op) {
   return null;
 }
 function getUnaryKernel(op) {
-  const wasm = getWasm2();
+  const wasm = getWasm3();
   if (!wasm) return null;
   const names = UNARY_OPS[op];
   const rust = wasm[names.rust];
@@ -4120,7 +4231,7 @@ import { computePool as computePool6 } from "@danielsimonjr/mathts-parallel";
 
 // src/wasm/special/wasm-bridge.ts
 var WASM_SPECIAL_THRESHOLD = 1024;
-function getWasm3() {
+function getWasm4() {
   try {
     return wasmLoader.getModule();
   } catch {
@@ -4186,7 +4297,7 @@ function airyBiJS(xs) {
 function besselJ0Dispatch(xs) {
   const n = xs.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["bessel_j0_f64"];
@@ -4217,7 +4328,7 @@ function besselJ0Dispatch(xs) {
 function besselJ1Dispatch(xs) {
   const n = xs.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["bessel_j1_f64"];
@@ -4250,7 +4361,7 @@ function besselJDispatch(order, xs) {
   if (order === 1) return besselJ1Dispatch(xs);
   const n = xs.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["bessel_j_f64"];
@@ -4281,7 +4392,7 @@ function besselJDispatch(order, xs) {
 function besselY0Dispatch(xs) {
   const n = xs.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["bessel_y0_f64"];
@@ -4312,7 +4423,7 @@ function besselY0Dispatch(xs) {
 function besselY1Dispatch(xs) {
   const n = xs.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["bessel_y1_f64"];
@@ -4345,7 +4456,7 @@ function besselYDispatch(order, xs) {
   if (order === 1) return besselY1Dispatch(xs);
   const n = xs.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["bessel_y_f64"];
@@ -4376,7 +4487,7 @@ function besselYDispatch(order, xs) {
 function airyAiDispatch(xs) {
   const n = xs.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["airy_ai_f64"];
@@ -4409,7 +4520,7 @@ function airyAiDispatch(xs) {
 function airyBiDispatch(xs) {
   const n = xs.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["airy_bi_f64"];
@@ -4472,7 +4583,7 @@ function lgammaJS(xs) {
 function lgammaDispatch(xs) {
   const n = xs.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["lgamma_f64"];
@@ -4709,7 +4820,7 @@ function ellipticPiIncompleteScalar(n, phi, m) {
 function carlsonRCDispatch(xs, ys) {
   const n = xs.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["carlson_rc_f64"];
@@ -4740,7 +4851,7 @@ function carlsonRCDispatch(xs, ys) {
 function carlsonRFDispatch(xs, ys, zs) {
   const n = xs.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["carlson_rf_f64"];
@@ -4773,7 +4884,7 @@ function carlsonRFDispatch(xs, ys, zs) {
 function carlsonRDDispatch(xs, ys, zs) {
   const n = xs.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["carlson_rd_f64"];
@@ -4806,7 +4917,7 @@ function carlsonRDDispatch(xs, ys, zs) {
 function carlsonRJDispatch(xs, ys, zs, ps) {
   const n = xs.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["carlson_rj_f64"];
@@ -4841,7 +4952,7 @@ function carlsonRJDispatch(xs, ys, zs, ps) {
 function ellipticFIncompleteDispatch(phis, ms) {
   const n = phis.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["elliptic_f_incomplete_f64"];
@@ -4872,7 +4983,7 @@ function ellipticFIncompleteDispatch(phis, ms) {
 function ellipticEIncompleteDispatch(phis, ms) {
   const n = phis.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["elliptic_e_incomplete_f64"];
@@ -4903,7 +5014,7 @@ function ellipticEIncompleteDispatch(phis, ms) {
 function ellipticPiIncompleteDispatch(ns, phis, ms) {
   const n = ns.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["elliptic_pi_incomplete_f64"];
@@ -4994,7 +5105,7 @@ function ellipticEJS(ms) {
 function ellipticKDispatch(ms) {
   const n = ms.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["elliptic_k_f64"];
@@ -5027,7 +5138,7 @@ function ellipticKDispatch(ms) {
 function ellipticEDispatch(ms) {
   const n = ms.length;
   if (n >= WASM_SPECIAL_THRESHOLD) {
-    const wasm = getWasm3();
+    const wasm = getWasm4();
     if (wasm) {
       try {
         const rustFn = wasm["elliptic_e_f64"];
@@ -6075,7 +6186,11 @@ async function mapArray(x, scalar, buildKernel) {
 }
 var erfc = mathTyped9("erfc", {
   number: erfcScalar,
-  Float64Array: (x) => mapArray(x, erfcScalar, () => kernelSource([_erfSeries, _erfcCF, erfcScalar], "(x) => erfcScalar(x)"))
+  Float64Array: (x) => {
+    const wasm = elementwiseUnaryDispatch("erfc", x);
+    if (wasm) return Promise.resolve(wasm);
+    return mapArray(x, erfcScalar, () => kernelSource([_erfSeries, _erfcCF, erfcScalar], "(x) => erfcScalar(x)"));
+  }
 });
 var erfi = mathTyped9("erfi", {
   number: erfiScalar,
@@ -6440,6 +6555,38 @@ var typedSpecial = {
   ellipticPi
 };
 
+// src/typed/fused.ts
+var SCALAR = {
+  abs: Math.abs,
+  sin: Math.sin,
+  cos: Math.cos,
+  tan: Math.tan,
+  exp: Math.exp,
+  log: Math.log,
+  atan: Math.atan,
+  sinh: Math.sinh,
+  tanh: Math.tanh,
+  atanh: Math.atanh,
+  expm1: Math.expm1,
+  log1p: Math.log1p,
+  log2: Math.log2,
+  log10: Math.log10,
+  sec: (x) => 1 / Math.cos(x),
+  csc: (x) => 1 / Math.sin(x),
+  cot: (x) => 1 / Math.tan(x),
+  erfc: erfcScalar
+};
+function fuseUnaryChain(ops, xs) {
+  const wasm = elementwiseChainDispatch(ops, xs);
+  if (wasm) return wasm;
+  const out = Float64Array.from(xs);
+  for (const op of ops) {
+    const f = SCALAR[op];
+    for (let i = 0; i < out.length; i++) out[i] = f(out[i]);
+  }
+  return out;
+}
+
 // src/typed/distributions.ts
 import { mathTyped as mathTyped10 } from "@danielsimonjr/mathts-core";
 import { computePool as computePool7 } from "@danielsimonjr/mathts-parallel";
@@ -7529,7 +7676,7 @@ async function distanceMatrix(points) {
 
 // src/wasm/poly/wasm-bridge.ts
 var WASM_POLY_THRESHOLD = 256;
-function getWasm4() {
+function getWasm5() {
   try {
     return wasmLoader.getModule();
   } catch {
@@ -7574,7 +7721,7 @@ function polyDivModJS(num, den) {
 function polyMulDispatch(a, b) {
   const bigEnough = a.length >= WASM_POLY_THRESHOLD || b.length >= WASM_POLY_THRESHOLD;
   if (bigEnough) {
-    const wasm = getWasm4();
+    const wasm = getWasm5();
     if (wasm) {
       try {
         const rustFn = wasm["poly_mul_f64"];
@@ -7606,7 +7753,7 @@ function polyDivModDispatch(num, den) {
   if (den.length === 0) throw new Error("Division by zero polynomial");
   const bigEnough = num.length >= WASM_POLY_THRESHOLD;
   if (bigEnough) {
-    const wasm = getWasm4();
+    const wasm = getWasm5();
     if (wasm) {
       try {
         const rustFn = wasm["poly_div_mod_f64"];
@@ -7734,7 +7881,7 @@ function discriminantJS(p) {
 function resultantDispatch(p, q) {
   const bigEnough = p.length >= WASM_POLY_THRESHOLD || q.length >= WASM_POLY_THRESHOLD;
   if (bigEnough) {
-    const wasm = getWasm4();
+    const wasm = getWasm5();
     if (wasm) {
       try {
         const rustFn = wasm["poly_resultant_f64"];
@@ -7761,7 +7908,7 @@ function resultantDispatch(p, q) {
 function discriminantDispatch(p) {
   const bigEnough = p.length >= WASM_POLY_THRESHOLD;
   if (bigEnough) {
-    const wasm = getWasm4();
+    const wasm = getWasm5();
     if (wasm) {
       try {
         const rustFn = wasm["poly_discriminant_f64"];
@@ -7882,7 +8029,7 @@ function fitDispatch(xs, ys, degree2, rustName, asName, jsFallback) {
   if (xs.length !== ys.length) throw new Error("xs and ys must have the same length");
   const bigEnough = xs.length >= WASM_POLY_FIT_THRESHOLD;
   if (bigEnough) {
-    const wasm = getWasm4();
+    const wasm = getWasm5();
     if (wasm) {
       try {
         const rustFn = wasm[rustName];
@@ -8881,7 +9028,7 @@ async function romberg(f, a, b, tol = 1e-12, options = {}) {
 // src/wasm/interpolation/wasm-bridge.ts
 var WASM_TRIDIAG_THRESHOLD = 1024;
 var WASM_INTERP_THRESHOLD = 256;
-function getWasm5() {
+function getWasm6() {
   try {
     return wasmLoader.getModule();
   } catch {
@@ -8917,7 +9064,7 @@ function tridiagSolveJS(diag2, lower, upper, rhs) {
 function tridiagSolveDispatch(diag2, lower, upper, rhs) {
   const n = diag2.length;
   if (n >= WASM_TRIDIAG_THRESHOLD) {
-    const wasm = getWasm5();
+    const wasm = getWasm6();
     if (wasm) {
       try {
         const rustFn = wasm["tridiag_solve_f64"];
@@ -8978,7 +9125,7 @@ function dividedDifferenceJS(xs, ys) {
 function dividedDifferenceDispatch(xs, ys) {
   const n = xs.length;
   if (n >= WASM_INTERP_THRESHOLD) {
-    const wasm = getWasm5();
+    const wasm = getWasm6();
     if (wasm) {
       try {
         const rustFn = wasm["divided_difference_f64"];
@@ -45773,6 +45920,7 @@ export {
   equalText,
   erf,
   erfc,
+  erfcScalar,
   erfi,
   eulerPhi,
   evaluate,
@@ -45877,6 +46025,7 @@ export {
   fresnelS,
   fullSimplify,
   functionExpand,
+  fuseUnaryChain,
   gamma,
   gammaDist,
   gammaPDF,

package/dist/typed/arithmetic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmetic.d.ts","sourceRoot":"","sources":["../../src/typed/arithmetic.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"arithmetic.d.ts","sourceRoot":"","sources":["../../src/typed/arithmetic.ts"],"names":[],"mappings":"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"}

package/dist/typed/fused.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Op-fusion public API (Tier 3 of the WASM pairing gap plan).
+ *
+ * Applies a *chain* of unary elementwise ops with the array resident in WASM
+ * memory across the whole chain, so the JS↔wasm transfer is paid **once**, not
+ * once per op. This is the structural lever the per-op benchmarks pointed to:
+ * a single op barely beats (or loses to) JS once the copy is counted, but a
+ * chain of K ops amortizes that one copy over K kernels.
+ *
+ *   fuseUnaryChain(['sin', 'exp'], xs)  // = exp(sin(x)), one copy in + one out
+ *
+ * Falls back to a sequential JS scalar pass when WASM is unavailable or the
+ * array is below threshold, so the result is always correct.
+ */
+import { type WasmElementwiseOp } from '../wasm/elementwise/wasm-bridge.js';
+/**
+ * Apply `ops` left-to-right over `xs` (i.e. `ops[last](…ops[0](x))`), fused in
+ * WASM when possible. Returns a new `Float64Array`; never mutates `xs`.
+ */
+export declare function fuseUnaryChain(ops: WasmElementwiseOp[], xs: Float64Array): Float64Array;
+//# sourceMappingURL=fused.d.ts.map

package/dist/typed/fused.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fused.d.ts","sourceRoot":"","sources":["../../src/typed/fused.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,oCAAoC,CAAC;AAyB5C;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,iBAAiB,EAAE,EAAE,EAAE,EAAE,YAAY,GAAG,YAAY,CASvF"}

package/dist/typed/index.d.ts

@@ -29,6 +29,7 @@ export { typedComplex } from './complex.js';
 export * from './set.js';
 export { typedSet } from './set.js';
 export * from './special.js';
+export * from './fused.js';
 export { typedSpecial } from './special.js';
 export * from './distributions.js';
 export { typedDistributions } from './distributions.js';

package/dist/typed/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/typed/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAOH,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAGtD,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1C,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAK5C,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGpC,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAGxD,cAAc,eAAe,CAAC;AAG9B,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,kBAAkB,CAAC;AAGjC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,cAAc,CAAC;AAG7B,cAAc,oBAAoB,CAAC;AAGnC,cAAc,YAAY,CAAC;AAG3B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,iBAAiB,CAAC;AAWhC,cAAc,iBAAiB,CAAC;AAGhC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAGvC,cAAc,UAAU,CAAC;AAIzB,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI1C,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGpD,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAsCtC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8B1B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/typed/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAOH,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAGtD,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1C,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAK5C,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGpC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAGxD,cAAc,eAAe,CAAC;AAG9B,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG5C,cAAc,kBAAkB,CAAC;AAGjC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,cAAc,CAAC;AAG7B,cAAc,oBAAoB,CAAC;AAGnC,cAAc,YAAY,CAAC;AAG3B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,iBAAiB,CAAC;AAWhC,cAAc,iBAAiB,CAAC;AAGhC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAGvC,cAAc,UAAU,CAAC;AAIzB,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI1C,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGpD,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAsCtC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8B1B,CAAC"}

package/dist/typed/special.d.ts

@@ -12,6 +12,10 @@
  *
  * @packageDocumentation
  */
+/** 64-bit float (default for decimals) */
+type f64 = number;
+/** Complementary error function erfc(x) = 1 - erf(x). */
+export declare function erfcScalar(x: f64): f64;
 /**
  * Complementary error function: erfc(x) = 1 - erf(x).
  *
@@ -466,4 +470,5 @@ export declare const typedSpecial: {
     ellipticEIncomplete: import("typed-function").TypedFunction;
     ellipticPi: import("typed-function").TypedFunction;
 };
+export {};
 //# sourceMappingURL=special.d.ts.map

package/dist/typed/special.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"special.d.ts","sourceRoot":"","sources":["../../src/typed/special.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"special.d.ts","sourceRoot":"","sources":["../../src/typed/special.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AA6CH,0CAA0C;AAC1C,KAAK,GAAG,GAAG,MAAM,CAAC;AAmGlB,yDAAyD;AACzD,wBAAgB,UAAU,CAAC,CAAC,EAAE,GAAG,GAAG,GAAG,CAKtC;AAw5BD;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI,wCAOf,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,IAAI,wCAIf,CAAC;AAMH;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,wCAQjB,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI,wCAQf,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,wCAQnB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,wCASpB,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,wCAQlB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,wCAIlB,CAAC;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,wCAUnB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,wCAUnB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,wCAUnB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,wCAUnB,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,wCAgBlB,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,wCAgBlB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,wCAQlB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,wCAYlB,CAAC;AAMH;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,SAAS,wCAUpB,CAAC;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,SAAS,wCAWpB,CAAC;AAMH;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,wCAQrB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,wCAQnB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,wCAQpB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,wCAQpB,CAAC;AAMH;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,wCAInB,CAAC;AAMH;;;;;GAKG;AACH,eAAO,MAAM,WAAW,wCAMtB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,WAAW,wCAMtB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,WAAW,wCAMtB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,aAAa,wCAMxB,CAAC;AAMH;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,wCAInB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,wCAInB,CAAC;AAMH;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,wCAQjB,CAAC;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,MAAM,wCAQjB,CAAC;AAUH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,SAAS,wCAMpB,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,wCAMpB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,wCAMpB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,wCAMpB,CAAC;AAYH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,wCAMpB,CAAC;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,wCAM9B,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,wCAMrB,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCxB,CAAC"}

package/dist/typed/trigonometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trigonometry.d.ts","sourceRoot":"","sources":["../../src/typed/trigonometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAiBH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAUd,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAUd,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAUd,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAed,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAed,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAed,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAqBf,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAoBf,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAef,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,KAAK,wCAEhB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAGf,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAGf,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAGf,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,KAAK,wCAehB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,KAAK,wCAehB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,KAAK,wCAehB,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,SAAS,wCAEpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS,wCAEpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,KAAK,wCAKhB,CAAC;AAMH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;CA2B7B,CAAC"}
+{"version":3,"file":"trigonometry.d.ts","sourceRoot":"","sources":["../../src/typed/trigonometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAkBH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAYd,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAYd,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAYd,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAiBd,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAiBd,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAiBd,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAqBf,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAoBf,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAiBf,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,KAAK,wCAEhB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAGf,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAGf,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAGf,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,KAAK,wCAehB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,KAAK,wCAehB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,KAAK,wCAiBhB,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,SAAS,wCAEpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS,wCAEpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,KAAK,wCAKhB,CAAC;AAMH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;CA2B7B,CAAC"}

package/dist/wasm/elementwise/wasm-bridge.d.ts

@@ -0,0 +1,27 @@
+/** Element-count threshold above which the WASM kernel beats JS. */
+export declare const WASM_ELEMENTWISE_THRESHOLD = 1024;
+/**
+ * Unary ops with a Rust `simd_<op>_array` kernel that is benchmark-confirmed
+ * net-faster than JS (see tools/benchmark/wasm/{elementwise,transcendental}.bench.mjs).
+ * Excluded after measuring (JS wins): sqrt, cbrt, asin, acos, cosh, asinh, acosh.
+ */
+export declare const WASM_ELEMENTWISE_OPS: readonly ["abs", "sin", "cos", "tan", "exp", "log", "atan", "sinh", "tanh", "atanh", "expm1", "log1p", "log2", "log10", "sec", "csc", "cot", "erfc"];
+export type WasmElementwiseOp = (typeof WASM_ELEMENTWISE_OPS)[number];
+/**
+ * Apply a unary elementwise op over `xs` via the Rust `simd_<op>_array` kernel.
+ * Returns the result, or `null` (below threshold, wasm unavailable, kernel
+ * missing, or any failure) — in which case the caller uses its JS/parallel path.
+ * Never throws.
+ */
+export declare function elementwiseUnaryDispatch(op: WasmElementwiseOp, xs: Float64Array): Float64Array | null;
+/**
+ * Op-fusion (Tier 3): apply a *chain* of unary ops with the data resident in
+ * wasm memory the whole time — one copy-in, one copy-out, regardless of chain
+ * length. `fuseUnaryChain([sin, exp])` computes `exp(sin(x))` paying the JS↔wasm
+ * transfer once instead of once per op. Ping-pongs between two scratch buffers
+ * (the simd kernels are out-of-place). Returns null (caller applies the chain in
+ * JS) below threshold, when wasm is unavailable, or any kernel is missing.
+ * Never throws.
+ */
+export declare function elementwiseChainDispatch(ops: WasmElementwiseOp[], xs: Float64Array): Float64Array | null;
+//# sourceMappingURL=wasm-bridge.d.ts.map

package/dist/wasm/elementwise/wasm-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-bridge.d.ts","sourceRoot":"","sources":["../../../src/wasm/elementwise/wasm-bridge.ts"],"names":[],"mappings":"AAoBA,oEAAoE;AACpE,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,sJAOvB,CAAC;AACX,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAyBtE;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,iBAAiB,EAAE,EAAE,EAAE,YAAY,GAAG,YAAY,GAAG,IAAI,CA0BrG;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,iBAAiB,EAAE,EAAE,EAAE,EAAE,YAAY,GAAG,YAAY,GAAG,IAAI,CAqCxG"}

package/dist/wasm/wasm-manifest.json

@@ -1,3 +1,3 @@
 {
-  "mathts.wasm": "sha384-oONMJGNzrFf5H4dPkE7U6ceOD2fBdFtJbrZitiNZOb/CcMvZVXY3g6ZTB/DtVDKy"
+  "mathts.wasm": "sha384-Qxm1yVKyyLXqqjH9qAfYxdsZDgvHQOtck+kldt9l/0AaJCFcHAqTglsyuDPjv622"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-functions",
-  "version": "0.2.12",
+  "version": "0.2.14",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",
@@ -22,7 +22,7 @@
     "build": "tsup src/index.ts --format esm --clean && tsc -p tsconfig.dts.json && node scripts/copy-wasm.mjs",
     "dev": "tsup src/index.ts --format esm --dts --watch",
     "test": "vitest run",
-    "test:diff": "node tests/diff-special.test.mjs",
+    "test:diff": "node tests/diff-special.test.mjs && node tests/diff-elementwise.test.mjs && node tests/diff-fusion.test.mjs",
     "golden:gen": "python -X utf8 tests/golden/gen_special_goldens.py",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",