@series-inc/rundot-kinetix 0.0.0-bootstrap.0

package/src/kinetix-deterministic-math.mjs

@@ -0,0 +1,1044 @@
+// Deterministic Math shim — the platform math contract for the console-native
+// R3F lab (sim-driven parity phase 3+).
+//
+// JS engines agree bitwise on IEEE-754 arithmetic (+ - * / sqrt fma-free) but
+// NOT on Math transcendentals: measured on 2026-07-06, Node 24 (V8 13.x) and
+// Chromium 148 (V8 14.x) differ bitwise on sin, cos, tan, log, log10, asin,
+// acos, sinh, cosh, tanh, expm1 — and JavaScriptCore differs again. Any
+// game value that flows through these into vertex buffers or uniforms breaks
+// bit-exact stream parity across hosts.
+//
+// Fix: replace the differing functions with fdlibm-style implementations
+// built ONLY from operations that are deterministic across engines (IEEE
+// arithmetic, sqrt, bit manipulation via typed arrays, and Math.pow — the
+// sole remaining native transcendental, verified bit-identical across V8
+// 13/14 and JavaScriptCore on 2026-07-09; log2/hypot/cbrt failed that JSC
+// battery and are shimmed below). Accuracy stays within ~1-2 ulp of
+// correctly-rounded; determinism is exact because every host runs this code.
+//
+// Single source of truth: the implementation lives in DETERMINISTIC_MATH_SOURCE
+// (an installable IIFE string) so the browser capture harness can inject it
+// via addInitScript and the headless host can eval the identical bytes.
+
+export const DETERMINISTIC_MATH_SOURCE = `(() => {
+  if (globalThis.__deterministicMathInstalled) return;
+  globalThis.__deterministicMathInstalled = true;
+
+  const f64 = new Float64Array(1);
+  const u32 = new Uint32Array(f64.buffer);
+  // Little-endian assumed (x86_64/arm64); index 1 = high word.
+  const HI = (x) => { f64[0] = x; return u32[1] | 0; };
+  const LO = (x) => { f64[0] = x; return u32[0] | 0; };
+  const fromWords = (hi, lo) => { u32[1] = hi >>> 0; u32[0] = lo >>> 0; return f64[0]; };
+  const setHi = (x, hi) => { f64[0] = x; u32[1] = hi >>> 0; return f64[0]; };
+  const setLo = (x, lo) => { f64[0] = x; u32[0] = lo >>> 0; return f64[0]; };
+
+  const abs = Math.abs, sqrt = Math.sqrt, floor = Math.floor;
+
+  const two1023 = 8.98846567431157953865e+307;
+  function scalbn2(x, n) {
+    let hx = HI(x), lx = LO(x);
+    let k = (hx & 0x7ff00000) >> 20;
+    if (k === 0) {
+      if ((lx | (hx & 0x7fffffff)) === 0) return x;
+      x *= 18014398509481984.0;
+      hx = HI(x);
+      k = ((hx & 0x7ff00000) >> 20) - 54;
+      if (n < -50000) return 1e-300 * x;
+    }
+    if (k === 0x7ff) return x + x;
+    k = k + n;
+    if (k > 0x7fe) return 1e300 * (x > 0 ? 1e300 : -1e300);
+    if (k > 0) return setHi(x, (hx & 0x800fffff) | (k << 20));
+    if (k <= -54) {
+      if (n > 50000) return 1e300 * (x > 0 ? 1e300 : -1e300);
+      return 1e-300 * (x > 0 ? 1e-300 : -1e-300);
+    }
+    k += 54;
+    x = setHi(x, (hx & 0x800fffff) | (k << 20));
+    return x * 5.55112312578270211816e-17; // 2^-54
+  }
+
+  // ---- __kernel_sin / __kernel_cos / __kernel_tan (fdlibm) ----------------
+  const S1 = -1.66666666666666324348e-01, S2 = 8.33333333332248946124e-03,
+        S3 = -1.98412698298579493134e-04, S4 = 2.75573137070700676789e-06,
+        S5 = -2.50507602534068634195e-08, S6 = 1.58969099521155010221e-10;
+  function kernelSin(x, y, iy) {
+    const z = x * x;
+    const v = z * x;
+    const r = S2 + z * (S3 + z * (S4 + z * (S5 + z * S6)));
+    if (iy === 0) return x + v * (S1 + z * r);
+    return x - ((z * (0.5 * y - v * r) - y) - v * S1);
+  }
+  const C1 = 4.16666666666666019037e-02, C2 = -1.38888888888741095749e-03,
+        C3 = 2.48015872894767294178e-05, C4 = -2.75573143513906633035e-07,
+        C5 = 2.08757232129817482790e-09, C6 = -1.13596475577881948265e-11;
+  function kernelCos(x, y) {
+    const z = x * x;
+    const r = z * (C1 + z * (C2 + z * (C3 + z * (C4 + z * (C5 + z * C6)))));
+    const hz = 0.5 * z;
+    const w = 1.0 - hz;
+    return w + (((1.0 - w) - hz) + (z * r - x * y));
+  }
+  const T = [
+    3.33333333333334091986e-01, 1.33333333333201242699e-01, 5.39682539762260521377e-02,
+    2.18694882948595424599e-02, 8.86323982359930005737e-03, 3.59207910759131235356e-03,
+    1.45620945432529025516e-03, 5.88041240820264096874e-04, 2.46463134818469906812e-04,
+    7.81794442939557092300e-05, 7.14072491382608190305e-05, -1.85586374855275456654e-05,
+    2.59073051863633712884e-05,
+  ];
+  const pio4 = 7.85398163397448278999e-01, pio4lo = 3.06161699786838301793e-17;
+  function kernelTan(x, y, iy) {
+    let z, r, v, w, s;
+    const hx = HI(x);
+    const ix = hx & 0x7fffffff;
+    if (ix >= 0x3FE59428) { // |x| >= 0.6744
+      if (hx < 0) { x = -x; y = -y; }
+      z = pio4 - x;
+      w = pio4lo - y;
+      x = z + w; y = 0.0;
+    }
+    z = x * x;
+    w = z * z;
+    r = T[1] + w * (T[3] + w * (T[5] + w * (T[7] + w * (T[9] + w * T[11]))));
+    v = z * (T[2] + w * (T[4] + w * (T[6] + w * (T[8] + w * (T[10] + w * T[12])))));
+    s = z * x;
+    r = y + z * (s * (r + v) + y);
+    r += T[0] * s;
+    w = x + r;
+    if (ix >= 0x3FE59428) {
+      v = iy;
+      return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));
+    }
+    if (iy === 1) return w;
+    // compute -1/(x+r) accurately
+    z = w;
+    z = setLo(z, 0);
+    v = r - (z - x);
+    let t = -1.0 / w;
+    let a = t;
+    a = setLo(a, 0);
+    s = 1.0 + a * z;
+    return a + t * (s + a * v);
+  }
+
+  // ---- __rem_pio2 (fdlibm, incl. Payne-Hanek for large args) ---------------
+  const twoOverPi = [
+    0xA2F983, 0x6E4E44, 0x1529FC, 0x2757D1, 0xF534DD, 0xC0DB62, 0x95993C, 0x439041,
+    0xFE5163, 0xABDEBB, 0xC561B7, 0x246E3A, 0x424DD2, 0xE00649, 0x2EEA09, 0xD1921C,
+    0xFE1DEB, 0x1CB129, 0xA73EE8, 0x8235F5, 0x2EBB44, 0x84E99C, 0x7026B4, 0x5F7E41,
+    0x3991D6, 0x398353, 0x39F49C, 0x845F8B, 0xBDF928, 0x3B1FF8, 0x97FFDE, 0x05980F,
+    0xEF2F11, 0x8B5A0A, 0x6D1F6D, 0x367ECF, 0x27CB09, 0xB74F46, 0x3F669E, 0x5FEA2D,
+    0x7527BA, 0xC7EBE5, 0xF17B3D, 0x0739F7, 0x8A5292, 0xEA6BFB, 0x5FB11F, 0x8D5D08,
+    0x560330, 0x46FC7B, 0x6BABF0, 0xCFBC20, 0x9AF436, 0x1DA9E3, 0x91615E, 0xE61B08,
+    0x659985, 0x5F14A0, 0x68408D, 0xFFD880, 0x4D7327, 0x310606, 0x1556CA, 0x73A8C9,
+    0x60E27B, 0xC08C6B,
+  ];
+  const PIo2 = [
+    1.57079625129699707031e+00, 7.54978941586159635335e-08, 5.39030252995776476554e-15,
+    3.28200341580791294123e-22, 1.27065575308067607349e-29, 1.22933308981111328932e-36,
+    2.73370053816464559624e-44, 2.16741683877804819444e-51,
+  ];
+  const two24 = 1.67772160000000000000e+07, twon24 = 5.96046447753906250000e-08;
+  function kernelRemPio2(x, y, e0, nx) {
+    // prec = 2 (double), jk = 4
+    const jk = 4, jp = 4;
+    let jx = nx - 1;
+    let jv = ((e0 - 3) / 24) | 0; if (jv < 0) jv = 0;
+    let q0 = e0 - 24 * (jv + 1);
+    const f = new Array(20).fill(0);
+    const q = new Array(20).fill(0);
+    const iq = new Array(20).fill(0);
+    const fw0 = new Array(20).fill(0);
+    let i, j, k, m, n, ih, z, fw, carry;
+    for (i = 0, j = jv - jx; i <= jx + jk; i++, j++) f[i] = j < 0 ? 0 : twoOverPi[j];
+    for (i = 0; i <= jk; i++) {
+      fw = 0;
+      for (j = 0; j <= jx; j++) fw += x[j] * f[jx + i - j];
+      q[i] = fw;
+    }
+    let jz = jk;
+    let recomputeNeeded = true;
+    while (recomputeNeeded) {
+      recomputeNeeded = false;
+      // distill q[] into iq[] reversingly
+      for (i = 0, j = jz, z = q[jz]; j > 0; i++, j--) {
+        fw = Math.floor(twon24 * z);
+        iq[i] = (z - two24 * fw) | 0;
+        z = q[j - 1] + fw;
+      }
+      z = scalbn2(z, q0);
+      z -= 8.0 * floor(z * 0.125);
+      n = z | 0;
+      z -= n;
+      ih = 0;
+      if (q0 > 0) {
+        i = (iq[jz - 1] >> (24 - q0));
+        n += i;
+        iq[jz - 1] -= i << (24 - q0);
+        ih = iq[jz - 1] >> (23 - q0);
+      } else if (q0 === 0) ih = iq[jz - 1] >> 23;
+      else if (z >= 0.5) ih = 2;
+      if (ih > 0) {
+        n += 1; carry = 0;
+        for (i = 0; i < jz; i++) {
+          j = iq[i];
+          if (carry === 0) {
+            if (j !== 0) { carry = 1; iq[i] = 0x1000000 - j; }
+          } else iq[i] = 0xffffff - j;
+        }
+        if (q0 > 0) {
+          switch (q0) {
+            case 1: iq[jz - 1] &= 0x7fffff; break;
+            case 2: iq[jz - 1] &= 0x3fffff; break;
+          }
+        }
+        if (ih === 2) {
+          z = 1.0 - z;
+          if (carry !== 0) z -= scalbn2(1.0, q0);
+        }
+      }
+      if (z === 0) {
+        j = 0;
+        for (i = jz - 1; i >= jk; i--) j |= iq[i];
+        if (j === 0) {
+          for (k = 1; iq[jk - k] === 0; k++) { }
+          for (i = jz + 1; i <= jz + k; i++) {
+            f[jx + i] = twoOverPi[jv + i];
+            for (j = 0, fw = 0; j <= jx; j++) fw += x[j] * f[jx + i - j];
+            q[i] = fw;
+          }
+          jz += k;
+          recomputeNeeded = true;
+          continue;
+        }
+      }
+      if (z === 0) {
+        jz -= 1; q0 -= 24;
+        while (iq[jz] === 0) { jz--; q0 -= 24; }
+      } else {
+        z = scalbn2(z, -q0);
+        if (z >= two24) {
+          fw = Math.floor(twon24 * z);
+          iq[jz] = (z - two24 * fw) | 0;
+          jz += 1; q0 += 24;
+          iq[jz] = fw | 0;
+        } else iq[jz] = z | 0;
+      }
+      fw = scalbn2(1.0, q0);
+      for (i = jz; i >= 0; i--) { q[i] = fw * iq[i]; fw *= twon24; }
+      for (i = jz; i >= 0; i--) {
+        for (fw = 0, k = 0; k <= jp && k <= jz - i; k++) fw += PIo2[k] * q[i + k];
+        fw0[jz - i] = fw;
+      }
+      // compress fw0 into y[] (prec 2)
+      fw = 0;
+      for (i = jz; i >= 0; i--) fw += fw0[i];
+      y[0] = ih === 0 ? fw : -fw;
+      fw = fw0[0] - fw;
+      for (i = 1; i <= jz; i++) fw += fw0[i];
+      y[1] = ih === 0 ? fw : -fw;
+    }
+    return n & 7;
+  }
+
+  const invpio2 = 6.36619772367581382433e-01;
+  const pio2_1 = 1.57079632673412561417e+00, pio2_1t = 6.07710050650619224932e-11;
+  const pio2_2 = 6.07710050630396597660e-11, pio2_2t = 2.02226624879595063154e-21;
+  const pio2_3 = 2.02226624871116645580e-21, pio2_3t = 8.47842766036889956997e-32;
+  const npio2_hw = [
+    0x3FF921FB, 0x400921FB, 0x4012D97C, 0x401921FB, 0x401F6A7A, 0x4022D97C,
+    0x4025FDBB, 0x402921FB, 0x402C463A, 0x402F6A7A, 0x4031475C, 0x4032D97C,
+    0x40346B9C, 0x4035FDBB, 0x40378FDB, 0x403921FB, 0x403AB41B, 0x403C463A,
+    0x403DD85A, 0x403F6A7A, 0x40407E4C, 0x4041475C, 0x4042106C, 0x4042D97C,
+    0x4043A28C, 0x40446B9C, 0x404534AC, 0x4045FDBB, 0x4046C6CB, 0x40478FDB,
+    0x404858EB, 0x404921FB,
+  ];
+  function remPio2(x, y) {
+    const hx = HI(x);
+    const ix = hx & 0x7fffffff;
+    if (ix <= 0x3fe921fb) { y[0] = x; y[1] = 0; return 0; }
+    if (ix < 0x4002d97c) { // |x| < 3pi/4
+      if (hx > 0) {
+        let z = x - pio2_1;
+        if (ix !== 0x3ff921fb) { y[0] = z - pio2_1t; y[1] = (z - y[0]) - pio2_1t; }
+        else { z -= pio2_2; y[0] = z - pio2_2t; y[1] = (z - y[0]) - pio2_2t; }
+        return 1;
+      }
+      let z = x + pio2_1;
+      if (ix !== 0x3ff921fb) { y[0] = z + pio2_1t; y[1] = (z - y[0]) + pio2_1t; }
+      else { z += pio2_2; y[0] = z + pio2_2t; y[1] = (z - y[0]) + pio2_2t; }
+      return -1;
+    }
+    if (ix <= 0x413921fb) { // |x| <= 2^19 pi/2
+      const t = abs(x);
+      const n = (t * invpio2 + 0.5) | 0;
+      const fn = n;
+      let r = t - fn * pio2_1;
+      let w = fn * pio2_1t;
+      if (n < 32 && ix !== npio2_hw[n - 1]) {
+        y[0] = r - w;
+      } else {
+        const high = HI(x);
+        let j = ix >> 20;
+        y[0] = r - w;
+        let i = j - (((HI(y[0])) >> 20) & 0x7ff);
+        if (i > 16) {
+          let t2 = r;
+          w = fn * pio2_2;
+          r = t2 - w;
+          w = fn * pio2_2t - ((t2 - r) - w);
+          y[0] = r - w;
+          i = j - (((HI(y[0])) >> 20) & 0x7ff);
+          if (i > 49) {
+            let t3 = r;
+            w = fn * pio2_3;
+            r = t3 - w;
+            w = fn * pio2_3t - ((t3 - r) - w);
+            y[0] = r - w;
+          }
+        }
+      }
+      y[1] = (r - y[0]) - w;
+      if (hx < 0) { y[0] = -y[0]; y[1] = -y[1]; return -n; }
+      return n;
+    }
+    if (ix >= 0x7ff00000) { y[0] = y[1] = x - x; return 0; }
+    // Payne-Hanek
+    const lx = LO(x);
+    const e0 = (ix >> 20) - 1046;
+    let z = setHi(0, ix - (e0 << 20));
+    z = setLo(z, lx);
+    const tx = [0, 0, 0];
+    for (let i = 0; i < 2; i++) { tx[i] = z | 0; z = (z - tx[i]) * two24; }
+    tx[2] = z;
+    let nx = 3;
+    while (nx > 0 && tx[nx - 1] === 0) nx--;
+    const n = kernelRemPio2(tx, y, e0, nx);
+    if (hx < 0) { y[0] = -y[0]; y[1] = -y[1]; return -n; }
+    return n;
+  }
+
+  function detSin(x) {
+    const ix = HI(x) & 0x7fffffff;
+    if (ix <= 0x3fe921fb) {
+      if (ix < 0x3e400000) { if ((x | 0) === 0 && x === x) return x; }
+      return kernelSin(x, 0, 0);
+    }
+    if (ix >= 0x7ff00000) return x - x;
+    const y = [0, 0];
+    const n = remPio2(x, y);
+    switch (n & 3) {
+      case 0: return kernelSin(y[0], y[1], 1);
+      case 1: return kernelCos(y[0], y[1]);
+      case 2: return -kernelSin(y[0], y[1], 1);
+      default: return -kernelCos(y[0], y[1]);
+    }
+  }
+  function detCos(x) {
+    const ix = HI(x) & 0x7fffffff;
+    if (ix <= 0x3fe921fb) {
+      if (ix < 0x3e400000) return 1.0;
+      return kernelCos(x, 0);
+    }
+    if (ix >= 0x7ff00000) return x - x;
+    const y = [0, 0];
+    const n = remPio2(x, y);
+    switch (n & 3) {
+      case 0: return kernelCos(y[0], y[1]);
+      case 1: return -kernelSin(y[0], y[1], 1);
+      case 2: return -kernelCos(y[0], y[1]);
+      default: return kernelSin(y[0], y[1], 1);
+    }
+  }
+  function detTan(x) {
+    const ix = HI(x) & 0x7fffffff;
+    if (ix <= 0x3fe921fb) {
+      if (ix < 0x3e300000) { if ((x | 0) === 0 && x === x) return x; }
+      return kernelTan(x, 0, 1);
+    }
+    if (ix >= 0x7ff00000) return x - x;
+    const y = [0, 0];
+    const n = remPio2(x, y);
+    return kernelTan(y[0], y[1], 1 - ((n & 1) << 1));
+  }
+
+  // ---- log / log10 (fdlibm e_log) ------------------------------------------
+  const ln2_hi = 6.93147180369123816490e-01, ln2_lo = 1.90821492927058770002e-10;
+  const Lg1 = 6.666666666666735130e-01, Lg2 = 3.999999999940941908e-01,
+        Lg3 = 2.857142874366239149e-01, Lg4 = 2.222219843214978396e-01,
+        Lg5 = 1.818357216161805012e-01, Lg6 = 1.531383769920937332e-01,
+        Lg7 = 1.479819860511658591e-01;
+  const two54 = 1.80143985094819840000e+16;
+  function detLog(x) {
+    let hx = HI(x), lx = LO(x);
+    let k = 0;
+    if (hx < 0x00100000) {
+      if (((hx & 0x7fffffff) | lx) === 0) return -Infinity;
+      if (hx < 0) return (x - x) / 0;
+      k -= 54; x *= two54; hx = HI(x);
+    }
+    if (hx >= 0x7ff00000) return x + x;
+    k += (hx >> 20) - 1023;
+    hx &= 0x000fffff;
+    const i = (hx + 0x95f64) & 0x100000;
+    x = setHi(x, hx | (i ^ 0x3ff00000));
+    k += i >> 20;
+    const f = x - 1.0;
+    if ((0x000fffff & (2 + hx)) < 3) {
+      if (f === 0) { if (k === 0) return 0; return k * ln2_hi + k * ln2_lo; }
+      const R = f * f * (0.5 - 0.33333333333333333 * f);
+      if (k === 0) return f - R;
+      return k * ln2_hi - ((R - k * ln2_lo) - f);
+    }
+    const s = f / (2.0 + f);
+    const dk = k;
+    const z = s * s;
+    const ii = hx - 0x6147a;
+    const w = z * z;
+    const jj = 0x6b851 - hx;
+    const t1 = w * (Lg2 + w * (Lg4 + w * Lg6));
+    const t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));
+    const ij = ii | jj;
+    const R = t2 + t1;
+    if (ij > 0) {
+      const hfsq = 0.5 * f * f;
+      if (k === 0) return f - (hfsq - s * (hfsq + R));
+      return dk * ln2_hi - ((hfsq - (s * (hfsq + R) + dk * ln2_lo)) - f);
+    }
+    if (k === 0) return f - s * (f - R);
+    return dk * ln2_hi - ((s * (f - R) - dk * ln2_lo) - f);
+  }
+  const ivln10 = 4.34294481903251816668e-01;
+  const log10_2hi = 3.01029995663611771306e-01, log10_2lo = 3.69423907715893078616e-13;
+  function detLog10(x) {
+    let hx = HI(x), lx = LO(x);
+    let k = 0;
+    if (hx < 0x00100000) {
+      if (((hx & 0x7fffffff) | lx) === 0) return -Infinity;
+      if (hx < 0) return (x - x) / 0;
+      k -= 54; x *= two54; hx = HI(x);
+    }
+    if (hx >= 0x7ff00000) return x + x;
+    k += (hx >> 20) - 1023;
+    const i = (k & 0x80000000) >>> 31;
+    hx = (hx & 0x000fffff) | ((0x3ff - i) << 20);
+    const y = k + i;
+    x = setHi(x, hx);
+    const z = y * log10_2lo + ivln10 * detLog(x);
+    return z + y * log10_2hi;
+  }
+
+  // ---- asin / acos (fdlibm) -------------------------------------------------
+  const pio2_hi = 1.57079632679489655800e+00, pio2_lo = 6.12323399573676603587e-17;
+  const pio4_hi = 7.85398163397448278999e-01;
+  const pS0 = 1.66666666666666657415e-01, pS1 = -3.25565818622400915405e-01,
+        pS2 = 2.01212532134862925881e-01, pS3 = -4.00555345006794114027e-02,
+        pS4 = 7.91534994289814532176e-04, pS5 = 3.47933107596021167570e-05,
+        qS1 = -2.40339491173441421878e+00, qS2 = 2.02094576023350569471e+00,
+        qS3 = -6.88283971605453293030e-01, qS4 = 7.70381505559019352791e-02;
+  function detAsin(x) {
+    const hx = HI(x);
+    const ix = hx & 0x7fffffff;
+    if (ix >= 0x3ff00000) {
+      if (((ix - 0x3ff00000) | LO(x)) === 0) return x * pio2_hi + x * pio2_lo;
+      return (x - x) / (x - x);
+    }
+    if (ix < 0x3fe00000) {
+      if (ix < 0x3e400000) return x;
+      const t = x * x;
+      const p = t * (pS0 + t * (pS1 + t * (pS2 + t * (pS3 + t * (pS4 + t * pS5)))));
+      const q = 1.0 + t * (qS1 + t * (qS2 + t * (qS3 + t * qS4)));
+      const w = p / q;
+      return x + x * w;
+    }
+    let w = 1.0 - abs(x);
+    let t = w * 0.5;
+    let p = t * (pS0 + t * (pS1 + t * (pS2 + t * (pS3 + t * (pS4 + t * pS5)))));
+    let q = 1.0 + t * (qS1 + t * (qS2 + t * (qS3 + t * qS4)));
+    const s = sqrt(t);
+    if (ix >= 0x3FEF3333) {
+      w = p / q;
+      t = pio2_hi - (2.0 * (s + s * w) - pio2_lo);
+    } else {
+      w = s;
+      w = setLo(w, 0);
+      const c = (t - w * w) / (s + w);
+      const r = p / q;
+      p = 2.0 * s * r - (pio2_lo - 2.0 * c);
+      q = pio4_hi - 2.0 * w;
+      t = pio4_hi - (p - q);
+    }
+    return hx > 0 ? t : -t;
+  }
+  function detAcos(x) {
+    const hx = HI(x);
+    const ix = hx & 0x7fffffff;
+    if (ix >= 0x3ff00000) {
+      if (((ix - 0x3ff00000) | LO(x)) === 0) return hx > 0 ? 0.0 : Math.PI;
+      return (x - x) / (x - x);
+    }
+    if (ix < 0x3fe00000) {
+      if (ix <= 0x3c600000) return pio2_hi + pio2_lo;
+      const z = x * x;
+      const p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));
+      const q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));
+      const r = p / q;
+      return pio2_hi - (x - (pio2_lo - x * r));
+    }
+    if (hx < 0) {
+      const z = (1.0 + x) * 0.5;
+      const p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));
+      const q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));
+      const s = sqrt(z);
+      const r = p / q;
+      const w = r * s - pio2_lo;
+      return Math.PI - 2.0 * (s + w);
+    }
+    const z = (1.0 - x) * 0.5;
+    const s = sqrt(z);
+    let df = s;
+    df = setLo(df, 0);
+    const c = (z - df * df) / (s + df);
+    const p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));
+    const q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));
+    const r = p / q;
+    const w = r * s + c;
+    return 2.0 * (df + w);
+  }
+
+  // ---- expm1 (fdlibm s_expm1) ----------------------------------------------
+  const o_threshold = 7.09782712893383973096e+02;
+  const invln2 = 1.44269504088896338700e+00;
+  const Q1 = -3.33333333333331316428e-02, Q2 = 1.58730158725481460165e-03,
+        Q3 = -7.93650757867487942473e-05, Q4 = 4.00821782732936239552e-06,
+        Q5 = -2.01099218183624371326e-07;
+  function detExpm1(x) {
+    const hx = HI(x);
+    const xsb = hx & 0x80000000;
+    let y = xsb === 0 ? x : -x;
+    const ix = hx & 0x7fffffff;
+    if (ix >= 0x4043687A) {
+      if (ix >= 0x40862E42) {
+        if (ix >= 0x7ff00000) {
+          if (((ix & 0xfffff) | LO(x)) !== 0) return x + x;
+          return xsb === 0 ? x : -1.0;
+        }
+        if (x > o_threshold) return Infinity;
+      }
+      if (xsb !== 0) return -1.0 + 1e-300 * 1e-300 * 0; // x < -56*ln2: -1 (tiny inexact ignored)
+    }
+    let k, t, c = 0, hi, lo;
+    if (ix > 0x3fd62e42) {
+      if (ix < 0x3FF0A2B2) {
+        if (xsb === 0) { hi = x - 6.93147180369123816490e-01; lo = 1.90821492927058770002e-10; k = 1; }
+        else { hi = x + 6.93147180369123816490e-01; lo = -1.90821492927058770002e-10; k = -1; }
+      } else {
+        k = (invln2 * x + (xsb === 0 ? 0.5 : -0.5)) | 0;
+        t = k;
+        hi = x - t * 6.93147180369123816490e-01;
+        lo = t * 1.90821492927058770002e-10;
+      }
+      x = hi - lo;
+      c = (hi - x) - lo;
+    } else if (ix < 0x3c900000) {
+      return x;
+    } else k = 0;
+    const hfx = 0.5 * x;
+    const hxs = x * hfx;
+    const r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));
+    t = 3.0 - r1 * hfx;
+    let e = hxs * ((r1 - t) / (6.0 - x * t));
+    if (k === 0) return x - (x * e - hxs);
+    e = (x * (e - c) - c);
+    e -= hxs;
+    if (k === -1) return 0.5 * (x - e) - 0.5;
+    if (k === 1) {
+      if (x < -0.25) return -2.0 * (e - (x + 0.5));
+      return 1.0 + 2.0 * (x - e);
+    }
+    if (k <= -2 || k > 56) {
+      y = 1.0 - (e - x);
+      if (k === 1024) y = y * 2.0 * two1023;
+      else y = y * scalbn2(1.0, k);
+      return y - 1.0;
+    }
+    t = scalbn2(1.0, -k);
+    if (k < 20) {
+      y = (x - e + (1 - t)) * scalbn2(1.0, k);
+    } else {
+      y = (x - (e + t) + 1) * scalbn2(1.0, k);
+    }
+    return y;
+  }
+
+  // ---- exp (fdlibm e_exp — native exp diverges cross-engine on rare inputs)
+  const halF = [0.5, -0.5];
+  const u_threshold = -7.45133219101941108420e+02;
+  const ln2HI = [6.93147180369123816490e-01, -6.93147180369123816490e-01];
+  const ln2LO = [1.90821492927058770002e-10, -1.90821492927058770002e-10];
+  const P1 = 1.66666666666666019037e-01, P2 = -2.77777777770155933842e-03,
+        P3 = 6.61375632143793436117e-05, P4 = -1.65339022054652515390e-06,
+        P5 = 4.13813679705723846039e-08;
+  const twom1000 = 9.33263618503218878990e-302;
+  function detExp(x) {
+    let hx = HI(x);
+    const xsb = (hx >> 31) & 1;
+    hx &= 0x7fffffff;
+    if (hx >= 0x40862E42) {
+      if (hx >= 0x7ff00000) {
+        if (((hx & 0xfffff) | LO(x)) !== 0) return x + x;
+        return xsb === 0 ? x : 0.0;
+      }
+      if (x > o_threshold) return Infinity;
+      if (x < u_threshold) return 0;
+    }
+    let k = 0, hi = 0, lo = 0, t;
+    if (hx > 0x3fd62e42) {
+      if (hx < 0x3FF0A2B2) { hi = x - ln2HI[xsb]; lo = ln2LO[xsb]; k = 1 - xsb - xsb; }
+      else {
+        k = (invln2 * x + halF[xsb]) | 0;
+        t = k;
+        hi = x - t * ln2HI[0];
+        lo = t * ln2LO[0];
+      }
+      x = hi - lo;
+    } else if (hx < 0x3e300000) {
+      return 1.0 + x;
+    }
+    t = x * x;
+    const c = x - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));
+    if (k === 0) return 1.0 - ((x * c) / (c - 2.0) - x);
+    let y = 1.0 - ((lo - (x * c) / (2.0 - c)) - hi);
+    if (k >= -1021) return setHi(y, HI(y) + (k << 20));
+    y = setHi(y, HI(y) + ((k + 1000) << 20));
+    return y * twom1000;
+  }
+
+  // ---- sinh / cosh / tanh from expm1 + deterministic exp -------------------
+  const nativeExp = detExp;
+  function detSinh(x) {
+    const hx = HI(x);
+    const ix = hx & 0x7fffffff;
+    if (ix >= 0x7ff00000) return x + x;
+    const h = hx < 0 ? -0.5 : 0.5;
+    if (ix < 0x40360000) {
+      if (ix < 0x3e300000) return x;
+      const t = detExpm1(abs(x));
+      if (ix < 0x3ff00000) return h * (2.0 * t - t * t / (t + 1.0));
+      return h * (t + t / (t + 1.0));
+    }
+    if (ix < 0x40862E42) return h * nativeExp(abs(x));
+    const lx = LO(x);
+    if (ix < 0x408633CE || (ix === 0x408633CE && lx <= 0x8fb9f87d)) {
+      const w = nativeExp(0.5 * abs(x));
+      const t = h * w;
+      return t * w;
+    }
+    return x * 1e307 * 1e307;
+  }
+  function detCosh(x) {
+    const ix = HI(x) & 0x7fffffff;
+    if (ix >= 0x7ff00000) return x * x;
+    if (ix < 0x3fd62e43) {
+      const t = detExpm1(abs(x));
+      const w = 1.0 + t;
+      if (ix < 0x3c800000) return w;
+      return 1.0 + (t * t) / (w + w);
+    }
+    if (ix < 0x40360000) {
+      const t = nativeExp(abs(x));
+      return 0.5 * t + 0.5 / t;
+    }
+    if (ix < 0x40862E42) return 0.5 * nativeExp(abs(x));
+    const lx = LO(x);
+    if (ix < 0x408633CE || (ix === 0x408633CE && lx <= 0x8fb9f87d)) {
+      const w = nativeExp(0.5 * abs(x));
+      return (0.5 * w) * w;
+    }
+    return 1e307 * 1e307;
+  }
+  function detTanh(x) {
+    const hx = HI(x);
+    const ix = hx & 0x7fffffff;
+    if (ix >= 0x7ff00000) {
+      if (hx >= 0) return 1.0 / x + 1.0;
+      return 1.0 / x - 1.0;
+    }
+    let z;
+    if (ix < 0x40360000) {
+      if (ix < 0x3c800000) return x * (1.0 + x);
+      if (ix >= 0x3ff00000) {
+        const t = detExpm1(2.0 * abs(x));
+        z = 1.0 - 2.0 / (t + 2.0);
+      } else {
+        const t = detExpm1(-2.0 * abs(x));
+        z = -t / (t + 2.0);
+      }
+    } else z = 1.0 - 1e-300;
+    return hx >= 0 ? z : -z;
+  }
+
+  // ---- atan / atan2 (fdlibm s_atan / e_atan2) -------------------------------
+  const atanhi = [
+    4.63647609000806093515e-01, 7.85398163397448278999e-01,
+    9.82793723247329054082e-01, 1.57079632679489655800e+00,
+  ];
+  const atanlo = [
+    2.26987774529616870924e-17, 3.06161699786838301793e-17,
+    1.39033110312309984516e-17, 6.12323399573676603587e-17,
+  ];
+  const aT = [
+    3.33333333333329318027e-01, -1.99999999998764832476e-01, 1.42857142725034663711e-01,
+    -1.11111104054623557880e-01, 9.09088713343650656196e-02, -7.69187620504482999495e-02,
+    6.66107313738753120669e-02, -5.83357013379057348645e-02, 4.97687799461593236017e-02,
+    -3.65315727442169155270e-02, 1.62858201153657823623e-02,
+  ];
+  function detAtan(x) {
+    const hx = HI(x);
+    const ix = hx & 0x7fffffff;
+    if (ix >= 0x44100000) {
+      if (ix > 0x7ff00000 || (ix === 0x7ff00000 && LO(x) !== 0)) return x + x;
+      return hx > 0 ? atanhi[3] + atanlo[3] : -atanhi[3] - atanlo[3];
+    }
+    let id;
+    if (ix < 0x3fdc0000) {
+      if (ix < 0x3e200000) return x;
+      id = -1;
+    } else {
+      x = abs(x);
+      if (ix < 0x3ff30000) {
+        if (ix < 0x3fe60000) { id = 0; x = (2.0 * x - 1.0) / (2.0 + x); }
+        else { id = 1; x = (x - 1.0) / (x + 1.0); }
+      } else {
+        if (ix < 0x40038000) { id = 2; x = (x - 1.5) / (1.0 + 1.5 * x); }
+        else { id = 3; x = -1.0 / x; }
+      }
+    }
+    const z = x * x;
+    const w = z * z;
+    const s1 = z * (aT[0] + w * (aT[2] + w * (aT[4] + w * (aT[6] + w * (aT[8] + w * aT[10])))));
+    const s2 = w * (aT[1] + w * (aT[3] + w * (aT[5] + w * (aT[7] + w * aT[9]))));
+    if (id < 0) return x - x * (s1 + s2);
+    const zz = atanhi[id] - ((x * (s1 + s2) - atanlo[id]) - x);
+    return hx < 0 ? -zz : zz;
+  }
+  const tiny_atan2 = 1.0e-300;
+  const pi_o_4 = 7.8539816339744827900e-01, pi_o_2 = 1.5707963267948965580e+00;
+  const detPi = 3.1415926535897931160e+00, pi_lo = 1.2246467991473531772e-16;
+  function detAtan2(y, x) {
+    const hx = HI(x), lx = LO(x), hy = HI(y), ly = LO(y);
+    const ix = hx & 0x7fffffff, iy = hy & 0x7fffffff;
+    if ((ix | ((lx | -lx) >>> 31)) > 0x7ff00000 || (iy | ((ly | -ly) >>> 31)) > 0x7ff00000) return x + y;
+    if (hx === 0x3ff00000 && lx === 0) return detAtan(y);
+    const m = ((hy >> 31) & 1) | ((hx >> 30) & 2);
+    if ((iy | ly) === 0) {
+      switch (m) {
+        case 0: case 1: return y;
+        case 2: return detPi + tiny_atan2;
+        default: return -detPi - tiny_atan2;
+      }
+    }
+    if ((ix | lx) === 0) return hy < 0 ? -pi_o_2 - tiny_atan2 : pi_o_2 + tiny_atan2;
+    if (ix === 0x7ff00000) {
+      if (iy === 0x7ff00000) {
+        switch (m) {
+          case 0: return pi_o_4 + tiny_atan2;
+          case 1: return -pi_o_4 - tiny_atan2;
+          case 2: return 3.0 * pi_o_4 + tiny_atan2;
+          default: return -3.0 * pi_o_4 - tiny_atan2;
+        }
+      } else {
+        switch (m) {
+          case 0: return 0.0;
+          case 1: return -0.0;
+          case 2: return detPi + tiny_atan2;
+          default: return -detPi - tiny_atan2;
+        }
+      }
+    }
+    if (iy === 0x7ff00000) return hy < 0 ? -pi_o_2 - tiny_atan2 : pi_o_2 + tiny_atan2;
+    const k = (iy - ix) >> 20;
+    let z;
+    if (k > 60) z = pi_o_2 + 0.5 * pi_lo;
+    else if (hx < 0 && k < -60) z = 0.0;
+    else z = detAtan(abs(y / x));
+    switch (m) {
+      case 0: return z;
+      case 1: return -z;
+      case 2: return detPi - (z - pi_lo);
+      default: return (z - pi_lo) - detPi;
+    }
+  }
+
+  // ---- log1p (fdlibm s_log1p) -----------------------------------------------
+  function detLog1p(x) {
+    const hx = HI(x);
+    const ax = hx & 0x7fffffff;
+    let k = 1, f = 0, hu = 0, c = 0, u;
+    if (hx < 0x3FDA827A) {
+      if (ax >= 0x3ff00000) {
+        if (x === -1.0) return -Infinity;
+        return (x - x) / (x - x);
+      }
+      if (ax < 0x3e200000) {
+        if (ax < 0x3c900000) return x;
+        return x - x * x * 0.5;
+      }
+      if (hx > 0 || hx <= (0xbfd2bec3 | 0)) { k = 0; f = x; hu = 1; }
+    }
+    if (k !== 0) {
+      if (hx < 0x43400000) {
+        u = 1.0 + x;
+        hu = HI(u);
+        k = (hu >> 20) - 1023;
+        c = k > 0 ? 1.0 - (u - x) : x - (u - 1.0);
+        c /= u;
+      } else {
+        u = x;
+        hu = HI(u);
+        k = (hu >> 20) - 1023;
+        c = 0;
+      }
+      hu &= 0x000fffff;
+      if (hu < 0x6a09e) {
+        u = setHi(u, hu | 0x3ff00000);
+      } else {
+        k += 1;
+        u = setHi(u, hu | 0x3fe00000);
+        hu = (0x00100000 - hu) >> 2;
+      }
+      f = u - 1.0;
+    }
+    const hfsq = 0.5 * f * f;
+    let R, s, z;
+    if (hu === 0) {
+      if (f === 0) {
+        if (k === 0) return 0;
+        c += k * ln2_lo;
+        return k * ln2_hi + c;
+      }
+      R = hfsq * (1.0 - 0.66666666666666666 * f);
+      if (k === 0) return f - R;
+      return k * ln2_hi - ((R - (k * ln2_lo + c)) - f);
+    }
+    s = f / (2.0 + f);
+    z = s * s;
+    R = z * (Lg1 + z * (Lg2 + z * (Lg3 + z * (Lg4 + z * (Lg5 + z * (Lg6 + z * Lg7))))));
+    if (k === 0) return f - (hfsq - s * (hfsq + R));
+    return k * ln2_hi - ((hfsq - (s * (hfsq + R) + (k * ln2_lo + c))) - f);
+  }
+
+  // ---- asinh / acosh / atanh (fdlibm, via deterministic log/log1p/sqrt) ----
+  const det_ln2 = 6.93147180559945286227e-01;
+  function detAsinh(x) {
+    const hx = HI(x);
+    const ix = hx & 0x7fffffff;
+    if (ix >= 0x7ff00000) return x + x;
+    if (ix < 0x3e300000) return x;
+    let w;
+    const t = abs(x);
+    if (ix > 0x41b00000) w = detLog(t) + det_ln2;
+    else if (ix > 0x40000000) w = detLog(2.0 * t + 1.0 / (sqrt(t * t + 1.0) + t));
+    else { const xx = t * t; w = detLog1p(t + xx / (1.0 + sqrt(1.0 + xx))); }
+    return hx > 0 ? w : -w;
+  }
+  function detAcosh(x) {
+    const hx = HI(x);
+    if (hx < 0x3ff00000) return (x - x) / (x - x);
+    if (hx >= 0x41b00000) {
+      if (hx >= 0x7ff00000) return x + x;
+      return detLog(x) + det_ln2;
+    }
+    if (((hx - 0x3ff00000) | LO(x)) === 0) return 0;
+    if (hx > 0x40000000) {
+      const t = x * x;
+      return detLog(2.0 * x - 1.0 / (x + sqrt(t - 1.0)));
+    }
+    const t = x - 1.0;
+    return detLog1p(t + sqrt(2.0 * t + t * t));
+  }
+  function detAtanh(x) {
+    const hx = HI(x);
+    const ix = hx & 0x7fffffff;
+    if (ix > 0x3ff00000 || (ix === 0x3ff00000 && LO(x) !== 0)) return (x - x) / (x - x);
+    if (ix === 0x3ff00000 && LO(x) === 0) return x / 0;
+    if (ix < 0x3e300000) return x;
+    const t0 = abs(x);
+    let t;
+    if (ix < 0x3fe00000) {
+      const t2 = t0 + t0;
+      t = 0.5 * detLog1p(t2 + t2 * t0 / (1.0 - t0));
+    } else {
+      t = 0.5 * detLog1p((t0 + t0) / (1.0 - t0));
+    }
+    return hx >= 0 ? t : -t;
+  }
+
+  // ---- log2 (FreeBSD e_log2 + k_log1p kernel) -------------------------------
+  // Added 2026-07-09: JavaScriptCore disagrees bitwise with V8 on log2, cbrt
+  // and hypot (5k-input battery); V8 13.x vs 14.x had agreed, so these three
+  // stayed native until the JSC port measured them.
+  const ivln2hi = 1.44269504072144627571e+00, ivln2lo = 1.67517131648865118353e-10;
+  function kLog1p(f) {
+    const s = f / (2.0 + f);
+    const z = s * s;
+    const w = z * z;
+    const t1 = w * (Lg2 + w * (Lg4 + w * Lg6));
+    const t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));
+    const hfsq = 0.5 * f * f;
+    return s * (hfsq + (t2 + t1));
+  }
+
+  function detLog2(x) {
+    let hx = HI(x), lx = LO(x);
+    let k = 0;
+    if (hx < 0x00100000) {
+      if (((hx & 0x7fffffff) | lx) === 0) return -Infinity;
+      if (hx < 0) return (x - x) / 0;
+      k -= 54; x *= two54; hx = HI(x); lx = LO(x);
+    }
+    if (hx >= 0x7ff00000) return x + x;
+    if (hx === 0x3ff00000 && lx === 0) return 0.0;
+    k += (hx >> 20) - 1023;
+    hx &= 0x000fffff;
+    const i = (hx + 0x95f64) & 0x100000;
+    x = setHi(x, hx | (i ^ 0x3ff00000));
+    k += i >> 20;
+    const y = k;
+    const f = x - 1.0;
+    const hfsq = 0.5 * f * f;
+    const r = kLog1p(f);
+    let hi = f - hfsq;
+    hi = setLo(hi, 0);
+    const lo = (f - hi) - hfsq + r;
+    let valHi = hi * ivln2hi;
+    let valLo = (lo + hi) * ivln2lo + lo * ivln2hi;
+    const w = y + valHi;
+    valLo += (y - w) + valHi;
+    return valLo + w;
+  }
+
+  // ---- cbrt (FreeBSD s_cbrt) ------------------------------------------------
+  const cbrtB1 = 715094163, cbrtB2 = 696219795;
+  const cbrtP0 = 1.87595182427177009643, cbrtP1 = -1.88497979543377169875,
+        cbrtP2 = 1.621429720105354466140, cbrtP3 = -0.758397934778766047437,
+        cbrtP4 = 0.145996192886612446982;
+
+  function detCbrt(x) {
+    let hx = HI(x);
+    const sign = hx & 0x80000000;
+    hx &= 0x7fffffff;
+    if (hx >= 0x7ff00000) return x + x;
+    let t;
+    if (hx < 0x00100000) {
+      if ((hx | LO(x)) === 0) return x;
+      t = two54 * x;
+      t = setHi(t, (sign | ((((HI(t) & 0x7fffffff) / 3) | 0) + cbrtB2)) >>> 0);
+    } else {
+      t = fromWords((sign | (((hx / 3) | 0) + cbrtB1)) >>> 0, 0);
+    }
+    const r0 = (t * t) * (t / x);
+    t *= cbrtP0 + r0 * (cbrtP1 + r0 * (cbrtP2 + r0 * (cbrtP3 + r0 * cbrtP4)));
+    // round t to 23 bits, away from zero: bits = (bits + 0x80000000) & ~0x3fffffff
+    let tHi = HI(t), tLo = LO(t) >>> 0;
+    tHi = (tHi + (tLo >= 0x80000000 ? 1 : 0)) | 0;
+    tLo = (tLo + 0x80000000) >>> 0;
+    t = fromWords(tHi >>> 0, tLo & 0xc0000000);
+    const s = t * t;
+    let r = x / s;
+    const w = t + t;
+    r = (r - t) / (w + r);
+    return t + t * r;
+  }
+
+  // ---- hypot (FreeBSD e_hypot, folded left for arity > 2) -------------------
+  function detHypot2(x, y) {
+    let ha = HI(x) & 0x7fffffff;
+    let hb = HI(y) & 0x7fffffff;
+    let a, b;
+    if (hb > ha) { a = y; b = x; const j = ha; ha = hb; hb = j; } else { a = x; b = y; }
+    a = abs(a); b = abs(b);
+    if (ha - hb > 0x3c00000) return a + b;
+    let k = 0;
+    if (ha > 0x5f300000) {
+      if (ha >= 0x7ff00000) {
+        let w = abs(x + 0.0) - abs(y + 0.0);
+        if (((ha & 0xfffff) | LO(a)) === 0) w = a;
+        if ((((hb ^ 0x7ff00000) | 0) | LO(b)) === 0) w = b;
+        return w;
+      }
+      ha -= 0x25800000; hb -= 0x25800000; k += 600;
+      a = setHi(a, ha >>> 0);
+      b = setHi(b, hb >>> 0);
+    }
+    if (hb < 0x20b00000) {
+      if (hb <= 0x000fffff) {
+        if ((hb | LO(b)) === 0) return a;
+        const scale = fromWords(0x7fd00000, 0);
+        b *= scale;
+        a *= scale;
+        k -= 1022;
+        ha = HI(a); hb = HI(b);
+      } else {
+        ha += 0x25800000; hb += 0x25800000; k -= 600;
+        a = setHi(a, ha >>> 0);
+        b = setHi(b, hb >>> 0);
+      }
+    }
+    let w = a - b;
+    if (w > b) {
+      const t1 = fromWords(ha >>> 0, 0);
+      const t2 = a - t1;
+      w = sqrt(t1 * t1 - (b * (-b) - t2 * (a + t1)));
+    } else {
+      a = a + a;
+      const y1 = fromWords(hb >>> 0, 0);
+      const y2 = b - y1;
+      const t1 = fromWords((ha + 0x00100000) >>> 0, 0);
+      const t2 = a - t1;
+      w = sqrt(t1 * y1 - (w * (-w) - (t1 * y2 + t2 * b)));
+    }
+    if (k !== 0) {
+      const scale = setHi(1.0, (HI(1.0) + (k << 20)) >>> 0);
+      return scale * w;
+    }
+    return w;
+  }
+
+  function detHypot(...values) {
+    // Left fold of the pairwise kernel: deterministic on every engine; for
+    // arity > 2 this is NOT the same rounding as a simultaneous algorithm,
+    // which is exactly why it must be pinned here.
+    let w = 0.0;
+    for (let i = 0; i < values.length; i += 1) w = detHypot2(w, +values[i]);
+    return w;
+  }
+
+  Math.exp = detExp;
+  Math.atan = detAtan;
+  Math.atan2 = detAtan2;
+  Math.log1p = detLog1p;
+  Math.asinh = detAsinh;
+  Math.acosh = detAcosh;
+  Math.atanh = detAtanh;
+  Math.sin = detSin;
+  Math.cos = detCos;
+  Math.tan = detTan;
+  Math.log = detLog;
+  Math.log10 = detLog10;
+  Math.asin = detAsin;
+  Math.acos = detAcos;
+  Math.sinh = detSinh;
+  Math.cosh = detCosh;
+  Math.tanh = detTanh;
+  Math.expm1 = detExpm1;
+  Math.log2 = detLog2;
+  Math.cbrt = detCbrt;
+  Math.hypot = detHypot;
+})();`;
+
+export function installDeterministicMath() {
+  // eslint-disable-next-line no-new-func
+  new Function(DETERMINISTIC_MATH_SOURCE)();
+}