jz 0.8.0 → 0.8.1

package/module/array.js

@@ -1720,6 +1720,26 @@ export default (ctx) => {
       ['f64.convert_i32_s', ['local.get', `$${result}`]]], 'f64')
   }
 
+  // Mirror of .indexOf scanning to the highest matching index — no early break, the last hit wins.
+  // Registering it (alongside .string:lastIndexOf) is what lets lastIndexOf leave STRING_ONLY_METHODS:
+  // an untyped receiver now forks string-vs-array at runtime instead of force-narrowing to string
+  // (which returned -1 for every array). fromIndex is unsupported, matching .indexOf's array path.
+  ctx.core.emit['.lastIndexOf'] = (arr, val) => {
+    const recv = hoistArrayValue(arr)
+    const vv = asF64(emit(val))
+    const eq = arrEqIR(val)
+    const result = tempI32('lx')
+    const loop = arrayLoop(recv.value, (_ptr, _len, i, item) => [
+      ['if', eq(item, vv),
+        ['then', ['local.set', `$${result}`, ['local.get', `$${i}`]]]]
+    ])
+    return typed(['block', ['result', 'f64'],
+      recv.setup,
+      ['local.set', `$${result}`, ['i32.const', -1]],
+      ...loop,
+      ['f64.convert_i32_s', ['local.get', `$${result}`]]], 'f64')
+  }
+
   // .at(i) → array element with negative index support
   ctx.core.emit['.array:at'] = (arr, idx) => {
     const vt = typeof arr === 'string' ? lookupValType(arr) : valTypeOf(arr)

package/module/math.js

@@ -37,7 +37,7 @@ export default (ctx) => {
     'math.log2': ['math.log'],
     'math.log1p': ['math.log'],
     'math.pow': ['math.exp', 'math.log'],
-    'math.asin': ['math.atan'],
+    'math.asin': [],
     'math.acos': ['math.asin'],
     'math.atan2': ['math.atan'],
     'math.sinh': ['math.exp'],
@@ -46,7 +46,8 @@ export default (ctx) => {
     'math.asinh': ['math.isFinite', 'math.log'],
     'math.acosh': ['math.log'],
     'math.atanh': ['math.log'],
-    'math.cbrt': ['math.isFinite', 'math.pow'],
+    'math.cbrt': ['math.isFinite'],
+    'math.fifthroot': ['math.isFinite'],
     'math.sumPrecise': ['__ptr_offset', '__len', '__alloc'],
   })
   // Helpers: all math ops take f64 and return f64. Args go through ToNumber
@@ -372,6 +373,24 @@ export default (ctx) => {
     // from exp/log); ±0.5 stays sqrt / the exact pow path (handled above).
     if (isLit(irB)) {
       const c = litVal(irB)
+      // Constant exponent with denominator 5 and < 5 (the sRGB / Rec.709 decode gammas 2.4, 2.2,
+      // and any k/5): x^(k/5) = x^p · fifthroot(x^r), p=⌊c⌋, r=5c−5p ∈ 1..4 — algebraic, no exp/log,
+      // ~3.6e-10 rel err over x ∈ (0,1]. Beats exp(c·log x): the pow microbench drops below V8's
+      // own Math.pow intrinsic. x<0 → NaN to match Math.pow on a non-integer exponent (the exp·log
+      // form's log(<0)=NaN). x=0/+∞/NaN all carry correctly through the power + fifthroot.
+      if (Number.isFinite(c) && c > 0 && c < 5 && !Number.isInteger(c) && Number.isInteger(c * 5)) {
+        inc('math.fifthroot')
+        const t = temp('pw'), g = get(t)
+        const ipow = (k) => k === 1 ? g : k === 2 ? ['f64.mul', g, g]
+          : k === 3 ? ['f64.mul', ['f64.mul', g, g], g] : ['f64.mul', ['f64.mul', g, g], ['f64.mul', g, g]]  // k ∈ 1..4
+        const p = Math.floor(c), r = Math.round(c * 5) - p * 5
+        const root = ['call', '$math.fifthroot', ipow(r)]
+        const body = p === 0 ? root : ['f64.mul', ipow(p), root]
+        return typed(['block', ['result', 'f64'],
+          ['local.set', `$${t}`, irA],
+          ['if', ['result', 'f64'], ['f64.lt', g, ['f64.const', 0]],
+            ['then', ['f64.const', 'nan']], ['else', body]]], 'f64')
+      }
       if (Number.isFinite(c) && !Number.isInteger(c) && c !== 0.5 && c !== -0.5)
         return (inc('math.exp'), inc('math.log'),
           typed(['call', '$math.exp', ['f64.mul', irB, ['call', '$math.log', irA]]], 'f64'))
@@ -544,15 +563,6 @@ export default (ctx) => {
   const horner2 = (cs, v = '$r2') => cs.reduceRight((acc, c, i) =>
     i === cs.length - 1 ? splat(c)
       : `(f64x2.add ${splat(c)} (f64x2.mul (local.get ${v}) ${acc}))`, '')
-  // fdlibm log's even/odd split, as f64x2 coefficient arrays (the scalar $math.log inlines them):
-  // t1 = w·(L3 + w·(L5 + w·L7)), t2 = z·(L2 + w·(L4 + w·(L6 + w·L8))). Vectorized log_v reuses these.
-  // STRING coefficients (not numbers): horner2 only ever interpolates them into the WAT
-  // (`(f64.const ${c})`), and under self-host that `${number}` goes through jz's shortest-repr
-  // __ftoa, which truncates to ~9 sig figs — so the kernel's log_v poly diverged from scalar
-  // $math.log (which inlines the exact literals). As strings, the full-precision decimal is
-  // embedded verbatim and watr parses it exactly, in both the host and the self-host kernel.
-  const LOG_T1 = ['0.3999999999940941908', '0.2222219843214978396', '0.1531383769920937332']
-  const LOG_T2 = ['0.6666666666666735130', '0.2857142874366239149', '0.1818357216161805012', '0.1479819860511658591']
   // Shared reduce → r ∈ [−π/2,π/2] in $r, quadrant parity in $q (branchless, 2 passes).
   const reduce2 = `
     (local.set $q (f64x2.nearest (f64x2.mul (local.get $x) ${splat(INV_PI)})))
@@ -602,7 +612,7 @@ export default (ctx) => {
   // 2^52 magic-add, identical to convert_i32_s for |k|≤1075). Any other lane (≤0/∞/NaN/denormal)
   // routes BOTH lanes to the scalar fallback → bit-exact by construction, edges never lose precision.
   wat('math.log_v', `(func $math.log_v (param $x v128) (result v128)
-    (local $k v128) (local $m v128) (local $mask v128) (local $f v128) (local $s v128) (local $z v128) (local $w v128) (local $hfsq v128)
+    (local $k v128) (local $m v128) (local $mask v128) (local $s v128) (local $z v128)
     (if (result v128)
       (i64x2.all_true (v128.and
         (f64x2.ge (local.get $x) (f64x2.splat (f64.const 0x1p-1022)))
@@ -616,18 +626,20 @@ export default (ctx) => {
         (local.set $mask (f64x2.ge (local.get $m) (f64x2.splat (f64.const 1.4142135623730951))))
         (local.set $m (v128.bitselect (f64x2.mul (local.get $m) (f64x2.splat (f64.const 0.5))) (local.get $m) (local.get $mask)))
         (local.set $k (f64x2.add (local.get $k) (v128.and (local.get $mask) (f64x2.splat (f64.const 1.0)))))
-        (local.set $f (f64x2.sub (local.get $m) (f64x2.splat (f64.const 1.0))))
-        (local.set $s (f64x2.div (local.get $f) (f64x2.add (local.get $f) (f64x2.splat (f64.const 2.0)))))
+        ;; mirrors scalar $math.log op-for-op (same constants/order) → bit-exact lanes
+        (local.set $s (f64x2.div (f64x2.sub (local.get $m) (f64x2.splat (f64.const 1.0))) (f64x2.add (local.get $m) (f64x2.splat (f64.const 1.0)))))
         (local.set $z (f64x2.mul (local.get $s) (local.get $s)))
-        (local.set $w (f64x2.mul (local.get $z) (local.get $z)))
-        (local.set $hfsq (f64x2.mul (f64x2.splat (f64.const 0.5)) (f64x2.mul (local.get $f) (local.get $f))))
         (f64x2.add
           (f64x2.mul (local.get $k) (f64x2.splat (f64.const ${Math.LN2})))
-          (f64x2.add (f64x2.sub (local.get $f) (local.get $hfsq))
-            (f64x2.mul (local.get $s) (f64x2.add (local.get $hfsq)
-              (f64x2.add
-                (f64x2.mul (local.get $w) ${horner2(LOG_T1, '$w')})
-                (f64x2.mul (local.get $z) ${horner2(LOG_T2, '$w')})))))))
+          (f64x2.mul (f64x2.mul (f64x2.splat (f64.const 2.0)) (local.get $s))
+            (f64x2.add (f64x2.splat (f64.const 1.0))
+              (f64x2.mul (local.get $z)
+                (f64x2.add (f64x2.splat (f64.const 0.33333333283005556))
+                  (f64x2.mul (local.get $z)
+                    (f64x2.add (f64x2.splat (f64.const 0.20000059590510924))
+                      (f64x2.mul (local.get $z)
+                        (f64x2.add (f64x2.splat (f64.const 0.14275490984342690))
+                          (f64x2.mul (local.get $z) (f64x2.splat (f64.const 0.11663796426848184)))))))))))))
       (else
         (f64x2.replace_lane 1
           (f64x2.splat (call $math.log (f64x2.extract_lane 0 (local.get $x))))
@@ -718,7 +730,6 @@ export default (ctx) => {
   // Edge cases: NaN→NaN, ≤0 distinguishes 0→-Inf, <0→NaN; +Inf passes through.
   wat('math.log', `(func $math.log (param $x f64) (result f64)
     (local $bits i64) (local $k i32) (local $m f64) (local $s f64) (local $z f64)
-    (local $f f64) (local $w f64) (local $t1 f64) (local $t2 f64) (local $hfsq f64)
     (if (f64.ne (local.get $x) (local.get $x))
       (then (return (local.get $x))))
     (if (f64.le (local.get $x) (f64.const 0.0))
@@ -749,27 +760,22 @@ export default (ctx) => {
       (then
         (local.set $m (f64.mul (local.get $m) (f64.const 0.5)))
         (local.set $k (i32.add (local.get $k) (i32.const 1)))))
-    ;; s = f/(2+f) with f = m−1 (= (m−1)/(m+1)); then the fdlibm even/odd-split
-    ;; polynomial. Two parallel Horner chains (t1 over even powers, t2 over odd)
-    ;; cut the dependency chain ~in half vs one 9-deep Horner — more ILP, fewer
-    ;; terms — and reconstruct log(m) = f − hfsq + s·(hfsq + t1 + t2). ~1 ulp.
-    (local.set $f (f64.sub (local.get $m) (f64.const 1.0)))
-    (local.set $s (f64.div (local.get $f) (f64.add (local.get $f) (f64.const 2.0))))
+    ;; s = (m−1)/(m+1)  (|s| ≤ 3−2√2 ≈ 0.172); log(m) = 2s·(1 + z·G(z)), z = s², G a degree-3
+    ;; minimax in z (Remez, equioscillation 5.8e-10). One short Horner replaces fdlibm's 7-term
+    ;; even/odd split — ~40% fewer ops, max rel err 1.7e-11 (jz transcendentals target ~1e-9).
+    (local.set $s (f64.div (f64.sub (local.get $m) (f64.const 1.0)) (f64.add (local.get $m) (f64.const 1.0))))
     (local.set $z (f64.mul (local.get $s) (local.get $s)))
-    (local.set $w (f64.mul (local.get $z) (local.get $z)))
-    (local.set $t1 (f64.mul (local.get $w) (f64.add (f64.const 0.3999999999940941908)
-      (f64.mul (local.get $w) (f64.add (f64.const 0.2222219843214978396)
-        (f64.mul (local.get $w) (f64.const 0.1531383769920937332)))))))
-    (local.set $t2 (f64.mul (local.get $z) (f64.add (f64.const 0.6666666666666735130)
-      (f64.mul (local.get $w) (f64.add (f64.const 0.2857142874366239149)
-        (f64.mul (local.get $w) (f64.add (f64.const 0.1818357216161805012)
-          (f64.mul (local.get $w) (f64.const 0.1479819860511658591)))))))))
-    (local.set $hfsq (f64.mul (f64.const 0.5) (f64.mul (local.get $f) (local.get $f))))
     (f64.add
       (f64.mul (f64.convert_i32_s (local.get $k)) (f64.const ${Math.LN2}))
-      (f64.add (f64.sub (local.get $f) (local.get $hfsq))
-        (f64.mul (local.get $s) (f64.add (local.get $hfsq)
-          (f64.add (local.get $t1) (local.get $t2))))))))`)
+      (f64.mul (f64.mul (f64.const 2.0) (local.get $s))
+        (f64.add (f64.const 1.0)
+          (f64.mul (local.get $z)
+            (f64.add (f64.const 0.33333333283005556)
+              (f64.mul (local.get $z)
+                (f64.add (f64.const 0.20000059590510924)
+                  (f64.mul (local.get $z)
+                    (f64.add (f64.const 0.14275490984342690)
+                      (f64.mul (local.get $z) (f64.const 0.11663796426848184)))))))))))))`)
 
   wat('math.log2', `(func $math.log2 (param $x f64) (result f64)
     (f64.div (call $math.log (local.get $x)) (f64.const ${Math.LN2})))`)
@@ -938,82 +944,71 @@ export default (ctx) => {
   // fdlibm atan: 4-region argument reduction onto |r| ≤ tan(π/16), then an
   // 11-term odd polynomial split into even/odd parts. Accurate to <1 ulp —
   // the old Taylor series was ~2e-6 off near |x|=0.5. Drives asin/acos/atan2.
+  // Fast atan: sign symmetry (work on |x|), two-stage reduction onto [0, tan(π/8)] — |x|>1 →
+  // π/2−atan(1/x), then t>tan(π/8) → π/8+atan((t−C)/(1+Ct)) — then a degree-5 minimax t·P(t²).
+  // Replaces the fdlibm 4-way / 11-term / extended-precision form (correctly-rounded but ~3× the
+  // ops). Max rel err 6e-10 over all of ℝ — well within jz's ~1e-9 transcendental budget. asin =
+  // atan(x/√(1−x²)) and acos = π/2−asin inherit it, so all three drop from ~1.6–2.3× to under V8.
   wat('math.atan', `(func $math.atan (param $x f64) (result f64)
-    (local $abs_x f64) (local $id i32) (local $r f64) (local $z f64) (local $w f64)
-    (local $s1 f64) (local $s2 f64) (local $ahi f64) (local $alo f64) (local $res f64)
-    ;; NaN passes through unchanged.
+    (local $t f64) (local $u f64) (local $r f64) (local $off f64) (local $flip i32)
+    ;; NaN passes through; ±0 returns x (preserves sign of zero); ±Inf flows through (1/Inf=0 → π/2).
     (if (f64.ne (local.get $x) (local.get $x)) (then (return (local.get $x))))
-    (local.set $abs_x (f64.abs (local.get $x)))
-    ;; |x| >= 2^66: atan saturates to ±π/2.
-    (if (f64.ge (local.get $abs_x) (f64.const 7.378697629483821e19))
-      (then (return (f64.copysign (f64.const 1.5707963267948966) (local.get $x)))))
-    (if (f64.lt (local.get $abs_x) (f64.const 0.4375))
+    (if (f64.eq (local.get $x) (f64.const 0.0)) (then (return (local.get $x))))
+    (local.set $t (f64.abs (local.get $x)))
+    (local.set $off (f64.const 0.0))
+    (local.set $flip (i32.const 0))
+    (if (f64.gt (local.get $t) (f64.const 1.0))
+      (then (local.set $t (f64.div (f64.const 1.0) (local.get $t))) (local.set $flip (i32.const 1))))
+    (if (f64.gt (local.get $t) (f64.const 0.41421356237309503))
       (then
-        ;; |x| < 2^-27: atan(x) ≈ x (also preserves sign of zero).
-        (if (f64.lt (local.get $abs_x) (f64.const 7.450580596923828e-9))
-          (then (return (local.get $x))))
-        (local.set $id (i32.const -1))
-        (local.set $r (local.get $x)))
-      (else
-        (local.set $r (local.get $abs_x))
-        (if (f64.lt (local.get $abs_x) (f64.const 1.1875))
-          (then
-            (if (f64.lt (local.get $abs_x) (f64.const 0.6875))
-              (then ;; id=0: r = (2x-1)/(2+x)
-                (local.set $id (i32.const 0))
-                (local.set $r (f64.div (f64.sub (f64.mul (f64.const 2.0) (local.get $r)) (f64.const 1.0))
-                                       (f64.add (f64.const 2.0) (local.get $r)))))
-              (else ;; id=1: r = (x-1)/(x+1)
-                (local.set $id (i32.const 1))
-                (local.set $r (f64.div (f64.sub (local.get $r) (f64.const 1.0))
-                                       (f64.add (local.get $r) (f64.const 1.0)))))))
-          (else
-            (if (f64.lt (local.get $abs_x) (f64.const 2.4375))
-              (then ;; id=2: r = (x-1.5)/(1+1.5x)
-                (local.set $id (i32.const 2))
-                (local.set $r (f64.div (f64.sub (local.get $r) (f64.const 1.5))
-                                       (f64.add (f64.const 1.0) (f64.mul (f64.const 1.5) (local.get $r))))))
-              (else ;; id=3: r = -1/x
-                (local.set $id (i32.const 3))
-                (local.set $r (f64.div (f64.const -1.0) (local.get $r)))))))))
-    (local.set $z (f64.mul (local.get $r) (local.get $r)))
-    (local.set $w (f64.mul (local.get $z) (local.get $z)))
-    (local.set $s1 (f64.mul (local.get $z)
-      (f64.add (f64.const 0.3333333333333293)
-        (f64.mul (local.get $w) (f64.add (f64.const 0.14285714272503466)
-          (f64.mul (local.get $w) (f64.add (f64.const 0.09090887133436507)
-            (f64.mul (local.get $w) (f64.add (f64.const 0.06661073137387531)
-              (f64.mul (local.get $w) (f64.add (f64.const 0.049768779946159324)
-                (f64.mul (local.get $w) (f64.const 0.016285820115365782)))))))))))))
-    (local.set $s2 (f64.mul (local.get $w)
-      (f64.add (f64.const -0.19999999999876483)
-        (f64.mul (local.get $w) (f64.add (f64.const -0.11111110405462356)
-          (f64.mul (local.get $w) (f64.add (f64.const -0.0769187620504483)
-            (f64.mul (local.get $w) (f64.add (f64.const -0.058335701337905735)
-              (f64.mul (local.get $w) (f64.const -0.036531572744216916)))))))))))
-    ;; |x| < 0.4375: result = r - r*(s1+s2), sign carried by r itself.
-    (if (i32.lt_s (local.get $id) (i32.const 0))
-      (then (return (f64.sub (local.get $r) (f64.mul (local.get $r) (f64.add (local.get $s1) (local.get $s2)))))))
-    ;; Reconstruct: z = atanhi[id] - ((r*(s1+s2) - atanlo[id]) - r), sign of x.
-    (if (i32.eq (local.get $id) (i32.const 0))
-      (then (local.set $ahi (f64.const 0.4636476090008061)) (local.set $alo (f64.const 2.2698777452961687e-17)))
-      (else (if (i32.eq (local.get $id) (i32.const 1))
-        (then (local.set $ahi (f64.const 0.7853981633974483)) (local.set $alo (f64.const 3.061616997868383e-17)))
-        (else (if (i32.eq (local.get $id) (i32.const 2))
-          (then (local.set $ahi (f64.const 0.982793723247329)) (local.set $alo (f64.const 1.3903311031230998e-17)))
-          (else (local.set $ahi (f64.const 1.5707963267948966)) (local.set $alo (f64.const 6.123233995736766e-17))))))))
-    (local.set $res (f64.sub (local.get $ahi)
-      (f64.sub (f64.sub (f64.mul (local.get $r) (f64.add (local.get $s1) (local.get $s2))) (local.get $alo))
-               (local.get $r))))
-    (f64.copysign (local.get $res) (local.get $x)))`)
+        (local.set $t (f64.div (f64.sub (local.get $t) (f64.const 0.41421356237309503))
+                               (f64.add (f64.const 1.0) (f64.mul (f64.const 0.41421356237309503) (local.get $t)))))
+        (local.set $off (f64.const 0.39269908169872414))))
+    (local.set $u (f64.mul (local.get $t) (local.get $t)))
+    (local.set $r (f64.add (local.get $off)
+      (f64.mul (local.get $t)
+        (f64.add (f64.const 0.99999999939667072)
+          (f64.mul (local.get $u)
+            (f64.add (f64.const -0.33333307625846248)
+              (f64.mul (local.get $u)
+                (f64.add (f64.const 0.19998216947828790)
+                  (f64.mul (local.get $u)
+                    (f64.add (f64.const -0.14240083011830104)
+                      (f64.mul (local.get $u)
+                        (f64.add (f64.const 0.10573479828448784)
+                          (f64.mul (local.get $u) (f64.const -0.060347904072425573))))))))))))))
+    (if (local.get $flip) (then (local.set $r (f64.sub (f64.const 1.5707963267948966) (local.get $r)))))
+    (f64.copysign (local.get $r) (local.get $x)))`)
 
+  // Fast asin: small-argument poly a + a·u·R(u) (u=a²) with the standard half-angle reduction for
+  // |x|>0.5 — a = sqrt((1−|x|)/2) maps the singular end to the smooth domain, asin = π/2 − 2·poly.
+  // One sqrt only on the upper half, no atan/div. R is a degree-6 minimax on [0,0.25]; max rel err
+  // ~2.6e-10. Replaces asin = atan(x/√(1−x²)) (which paid a div + atan's own reductions).
   wat('math.asin', `(func $math.asin (param $x f64) (result f64)
-    ;; Domain is [-1, 1]; outside it (including ±Infinity), Math.asin returns NaN.
-    ;; sin/cos output is clamped to [-1, 1] by sin_core/cos_core, so no tolerance needed here.
-    (if (result f64) (f64.gt (f64.abs (local.get $x)) (f64.const 1.0))
-      (then (f64.const nan))
-      (else (call $math.atan (f64.div (local.get $x)
-        (f64.sqrt (f64.sub (f64.const 1.0) (f64.mul (local.get $x) (local.get $x)))))))))`)
+    (local $ax f64) (local $a f64) (local $u f64) (local $r f64)
+    ;; |x|>1 → NaN (covers ±Inf); NaN propagates (the >1 test is false, poly carries NaN through).
+    (if (f64.gt (f64.abs (local.get $x)) (f64.const 1.0)) (then (return (f64.const nan))))
+    (local.set $ax (f64.abs (local.get $x)))
+    (if (f64.le (local.get $ax) (f64.const 0.5))
+      (then (local.set $a (local.get $ax)))
+      (else (local.set $a (f64.sqrt (f64.mul (f64.const 0.5) (f64.sub (f64.const 1.0) (local.get $ax)))))))
+    (local.set $u (f64.mul (local.get $a) (local.get $a)))
+    (local.set $r (f64.add (local.get $a) (f64.mul (f64.mul (local.get $a) (local.get $u))
+      (f64.add (f64.const 0.16666666715486264)
+        (f64.mul (local.get $u)
+          (f64.add (f64.const 0.074999892151409259)
+            (f64.mul (local.get $u)
+              (f64.add (f64.const 0.044648555271317079)
+                (f64.mul (local.get $u)
+                  (f64.add (f64.const 0.030259196387355945)
+                    (f64.mul (local.get $u)
+                      (f64.add (f64.const 0.023661273034955098)
+                        (f64.mul (local.get $u)
+                          (f64.add (f64.const 0.010472588920432560)
+                            (f64.mul (local.get $u) (f64.const 0.031028862087420162))))))))))))))))
+    (if (f64.gt (local.get $ax) (f64.const 0.5))
+      (then (local.set $r (f64.sub (f64.const 1.5707963267948966) (f64.mul (f64.const 2.0) (local.get $r))))))
+    (f64.copysign (local.get $r) (local.get $x)))`)
 
   wat('math.acos', `(func $math.acos (param $x f64) (result f64)
     (f64.sub (f64.const ${HALF_PI}) (call $math.asin (local.get $x))))`)
@@ -1080,19 +1075,51 @@ export default (ctx) => {
     (if (f64.eq (f64.abs (local.get $x)) (f64.const inf)) (then (return (f64.const nan))))
     (f64.mul (f64.const 0.5) (call $math.log (f64.div (f64.add (f64.const 1.0) (local.get $x)) (f64.sub (f64.const 1.0) (local.get $x))))))`)
 
+  // Bit-hack initial guess (divide the IEEE exponent by 3 via an integer divide of the raw bits,
+  // plus a magic bias) then 3 Newton steps  t = (2t + a/t²)/3  — quadratic convergence, max rel err
+  // ~1e-12 over the whole f64 range. Replaces the old `pow(x,1/3)` seed: no exp/log call, ~3-4×
+  // faster (the colorconv / Oklab hot path is 3 cbrt per pixel), and a program whose only
+  // transcendental is cbrt no longer pulls the pow/exp/log stdlib. Not bit-identical to V8's fdlibm
+  // cbrt (neither was the pow form) — jz's transcendentals are fast minimax/Newton approximations.
   wat('math.cbrt', `(func $math.cbrt (param $x f64) (result f64)
-    (local $y f64)
-    ;; ±Infinity and NaN pass through; preserve sign of zero.
+    (local $a f64) (local $t f64) (local $s f64)
+    ;; NaN / ±Infinity / ±0 pass through unchanged (sign of zero preserved).
     (if (i32.eqz (call $math.isFinite (local.get $x))) (then (return (local.get $x))))
     (if (f64.eq (local.get $x) (f64.const 0.0)) (then (return (local.get $x))))
-    (if (result f64) (f64.lt (local.get $x) (f64.const 0.0))
-      (then (f64.neg (call $math.cbrt (f64.neg (local.get $x)))))
-      (else
-        ;; Initial guess via pow, then Newton-Raphson: y = (2y + x/y²)/3
-        (local.set $y (call $math.pow (local.get $x) (f64.const 0.3333333333333333)))
-        (local.set $y (f64.div (f64.add (f64.mul (f64.const 2.0) (local.get $y)) (f64.div (local.get $x) (f64.mul (local.get $y) (local.get $y)))) (f64.const 3.0)))
-        (local.set $y (f64.div (f64.add (f64.mul (f64.const 2.0) (local.get $y)) (f64.div (local.get $x) (f64.mul (local.get $y) (local.get $y)))) (f64.const 3.0)))
-        (local.get $y))))`)
+    (local.set $a (f64.abs (local.get $x)))
+    (local.set $s (f64.const 1.0))
+    ;; subnormal |x| < 2^-1022: scale up by 2^60 so the exponent split is valid; cbrt(2^60) = 2^20.
+    (if (f64.lt (local.get $a) (f64.const 2.2250738585072014e-308))
+      (then (local.set $a (f64.mul (local.get $a) (f64.const 1152921504606846976.0)))
+            (local.set $s (f64.const 9.5367431640625e-07))))
+    (local.set $t (f64.reinterpret_i64
+      (i64.add (i64.div_u (i64.reinterpret_f64 (local.get $a)) (i64.const 3)) (i64.const 0x2A9F7893BF800000))))
+    (local.set $t (f64.mul (f64.add (f64.add (local.get $t) (local.get $t)) (f64.div (local.get $a) (f64.mul (local.get $t) (local.get $t)))) (f64.const 0.3333333333333333)))
+    (local.set $t (f64.mul (f64.add (f64.add (local.get $t) (local.get $t)) (f64.div (local.get $a) (f64.mul (local.get $t) (local.get $t)))) (f64.const 0.3333333333333333)))
+    (local.set $t (f64.mul (f64.add (f64.add (local.get $t) (local.get $t)) (f64.div (local.get $a) (f64.mul (local.get $t) (local.get $t)))) (f64.const 0.3333333333333333)))
+    (local.set $t (f64.mul (local.get $t) (local.get $s)))
+    (if (result f64) (f64.lt (local.get $x) (f64.const 0.0)) (then (f64.neg (local.get $t))) (else (local.get $t))))`)
+
+  // Fifth root of v ≥ 0 — same bit-hack seed (÷5 of the raw bits) + 3 Newton steps t=(4t+v/t⁴)/5.
+  // Caller (constant-exponent pow with denominator 5, e.g. the sRGB 2.4 gamma) guarantees v ≥ 0.
+  wat('math.fifthroot', `(func $math.fifthroot (param $v f64) (result f64)
+    (local $t f64) (local $s f64) (local $q f64)
+    (if (i32.eqz (call $math.isFinite (local.get $v))) (then (return (local.get $v))))
+    (if (f64.eq (local.get $v) (f64.const 0.0)) (then (return (f64.const 0.0))))
+    (local.set $s (f64.const 1.0))
+    ;; subnormal: scale by 2^100 = (2^20)^5; fifthroot(2^100) = 2^20
+    (if (f64.lt (local.get $v) (f64.const 2.2250738585072014e-308))
+      (then (local.set $v (f64.mul (local.get $v) (f64.const 1.2676506002282294e30)))
+            (local.set $s (f64.const 9.5367431640625e-07))))
+    (local.set $t (f64.reinterpret_i64
+      (i64.add (i64.div_u (i64.reinterpret_f64 (local.get $v)) (i64.const 5)) (i64.const 0x3325E66666666800))))
+    (local.set $q (f64.mul (local.get $t) (local.get $t)))
+    (local.set $t (f64.mul (f64.add (f64.mul (f64.const 4.0) (local.get $t)) (f64.div (local.get $v) (f64.mul (local.get $q) (local.get $q)))) (f64.const 0.2)))
+    (local.set $q (f64.mul (local.get $t) (local.get $t)))
+    (local.set $t (f64.mul (f64.add (f64.mul (f64.const 4.0) (local.get $t)) (f64.div (local.get $v) (f64.mul (local.get $q) (local.get $q)))) (f64.const 0.2)))
+    (local.set $q (f64.mul (local.get $t) (local.get $t)))
+    (local.set $t (f64.mul (f64.add (f64.mul (f64.const 4.0) (local.get $t)) (f64.div (local.get $v) (f64.mul (local.get $q) (local.get $q)))) (f64.const 0.2)))
+    (f64.mul (local.get $t) (local.get $s)))`)
 
   // Small finite-test helper (NaN→0, ±Inf→0, finite→1). Used by transcendental
   // functions that need to short-circuit on infinite inputs.

package/module/string.js

@@ -144,6 +144,8 @@ export default (ctx) => {
   deps({
     __str_concat: ['__to_str', '__str_byteLen', '__alloc', '__memgrow', '__mkptr', '__str_copy'],
     __str_concat_raw: ['__str_byteLen', '__alloc', '__memgrow', '__mkptr', '__str_copy'],
+    __str_concat_fresh: ['__to_str', '__str_byteLen', '__alloc', '__mkptr', '__str_copy'],
+    __str_concat_raw_fresh: ['__str_byteLen', '__alloc', '__mkptr', '__str_copy'],
     __str_append_byte: ['__str_byteLen', '__alloc', '__memgrow', '__mkptr', '__str_copy'],
     __str_copy: [],
     // __str_slice/_view are FUNCTION templates: resolveIncludes' auto-dep scan realizes the
@@ -674,15 +676,27 @@ export default (ctx) => {
 
   // Hoist SSO/heap dispatch for hay and ndl out of the inner byte loop. Inner
   // loop becomes (load8_u OR sso byte-extract) per side — no per-byte calls.
+  // Needle byte j, SSO-aware (packed-bits extract vs heap load) — lets the SIMD
+  // haystack scan serve SSO needles too (the common short "," / "://" needle),
+  // not just heap×heap. `$nsso` is loop-invariant so the branch predicts away.
+  const nByte = (j) => `(if (result i32) (local.get $nsso)
+    (then ${ssoCharWat('(local.get $ndl)', j)})
+    (else (i32.load8_u (i32.add (local.get $noff) ${j}))))`
   wat('__str_indexof', `(func $__str_indexof (param $hay i64) (param $ndl i64) (param $from i32) (result i32)
     (local $hlen i32) (local $nlen i32) (local $i i32) (local $j i32) (local $match i32)
     (local $hoff i32) (local $noff i32)
     (local $hsso i32) (local $nsso i32) (local $hb i32) (local $nb i32) (local $k i32)
+    (local $splat v128) (local $mask i32) (local $scanEnd i32)
     ;; The search value is ToString'd at the call site (searchArg) per 21.1.3.9 step 4 —
     ;; a known-string needle passes raw, so this helper carries no float-pulling __to_str.
     (local.set $hlen (call $__str_byteLen (local.get $hay)))
     (local.set $nlen (call $__str_byteLen (local.get $ndl)))
-    (if (i32.eqz (local.get $nlen)) (then (return (local.get $from))))
+    ;; Empty needle matches at clamp(from, 0, hlen) — per 21.1.3.9 step 6 (Min(Max(pos,0),len)).
+    (if (i32.eqz (local.get $nlen))
+      (then (return (select
+        (select (local.get $from) (local.get $hlen) (i32.lt_s (local.get $from) (local.get $hlen)))
+        (i32.const 0)
+        (i32.ge_s (local.get $from) (i32.const 0))))))
     (if (i32.gt_s (local.get $nlen) (local.get $hlen)) (then (return (i32.const -1))))
     (local.set $hoff (i32.wrap_i64 (i64.and (local.get $hay) (i64.const ${LAYOUT.OFFSET_MASK}))))
     (local.set $noff (i32.wrap_i64 (i64.and (local.get $ndl) (i64.const ${LAYOUT.OFFSET_MASK}))))
@@ -693,6 +707,83 @@ export default (ctx) => {
       (i32.wrap_i64 (i64.shr_u (local.get $ndl) (i64.const ${LAYOUT.AUX_SHIFT})))
       (i32.const ${LAYOUT.SSO_BIT})))
     (local.set $i (if (result i32) (i32.gt_s (local.get $from) (i32.const 0)) (then (local.get $from)) (else (i32.const 0))))
+    ;; Single-byte needle (the common s.indexOf('/') / s.includes(' ')): scan for one byte without
+    ;; the per-position match/j/k bookkeeping. Heap haystack gets a branchless load8_u loop (no
+    ;; per-byte SSO test); a 16-wide SIMD scan here would only add splat/window setup that short
+    ;; strings — the bulk of single-char searches — never amortize, so the scalar scan stays.
+    (if (i32.eq (local.get $nlen) (i32.const 1))
+      (then
+        (local.set $nb ${nByte('(i32.const 0)')})
+        (if (i32.eqz (local.get $hsso))
+          (then
+            (block $sd (loop $ss
+              (br_if $sd (i32.ge_s (local.get $i) (local.get $hlen)))
+              (if (i32.eq (i32.load8_u (i32.add (local.get $hoff) (local.get $i))) (local.get $nb))
+                (then (return (local.get $i))))
+              (local.set $i (i32.add (local.get $i) (i32.const 1)))
+              (br $ss)))
+            (return (i32.const -1)))
+          (else
+            (block $sd2 (loop $ss2
+              (br_if $sd2 (i32.ge_s (local.get $i) (local.get $hlen)))
+              (if (i32.eq ${ssoCharWat('(local.get $hay)', '(local.get $i)')} (local.get $nb))
+                (then (return (local.get $i))))
+              (local.set $i (i32.add (local.get $i) (i32.const 1)))
+              (br $ss2)))
+            (return (i32.const -1))))))
+    ;; Multi-byte needle, HEAP haystack (needle SSO or heap): a SIMD first-byte memchr — broadcast
+    ;; needle[0] across 16 lanes, i8x16.eq a 16-byte haystack window, and read the match-bitmask.
+    ;; Only positions whose first byte matches reach the branchless verify; the rare match (V8's own
+    ;; StringIndexOf is SIMD here) is what the scalar path lost on. The SIMD load only touches the
+    ;; haystack, so an SSO needle (the common short "," / "://" / "TARGET") rides this path too —
+    ;; its bytes are fetched SSO-aware via nByte(). scanEnd = hlen-nlen is the last viable start; the
+    ;; window stops at hlen-16 (a full 16-byte load stays inside the string), a scalar tail covers
+    ;; the rest. Only an SSO haystack (≤ MAX_SSO bytes — too short to scan 16-wide) falls through.
+    (if (i32.eqz (local.get $hsso))
+      (then
+        (local.set $nb ${nByte('(i32.const 0)')})
+        (local.set $scanEnd (i32.sub (local.get $hlen) (local.get $nlen)))
+        (local.set $splat (i8x16.splat (local.get $nb)))
+        (block $vd (loop $vo
+          (br_if $vd (i32.gt_s (local.get $i) (i32.sub (local.get $hlen) (i32.const 16))))
+          (local.set $mask (i8x16.bitmask
+            (i8x16.eq (v128.load (i32.add (local.get $hoff) (local.get $i))) (local.get $splat))))
+          (block $bd (loop $bo
+            (br_if $bd (i32.eqz (local.get $mask)))
+            (local.set $k (i32.add (local.get $i) (i32.ctz (local.get $mask))))   ;; candidate start
+            (br_if $bd (i32.gt_s (local.get $k) (local.get $scanEnd)))            ;; positions only grow
+            (local.set $match (i32.const 1))
+            (local.set $j (i32.const 1))
+            (block $mn (loop $mi
+              (br_if $mn (i32.ge_s (local.get $j) (local.get $nlen)))
+              (if (i32.ne (i32.load8_u (i32.add (i32.add (local.get $hoff) (local.get $k)) (local.get $j)))
+                          ${nByte('(local.get $j)')})
+                (then (local.set $match (i32.const 0)) (br $mn)))
+              (local.set $j (i32.add (local.get $j) (i32.const 1)))
+              (br $mi)))
+            (if (local.get $match) (then (return (local.get $k))))
+            (local.set $mask (i32.and (local.get $mask) (i32.sub (local.get $mask) (i32.const 1))))  ;; clear lowest match
+            (br $bo)))
+          (local.set $i (i32.add (local.get $i) (i32.const 16)))
+          (br $vo)))
+        ;; scalar tail: positions [i, scanEnd] the SIMD window couldn't cover
+        (block $md (loop $mo
+          (br_if $md (i32.gt_s (local.get $i) (local.get $scanEnd)))
+          (if (i32.eq (i32.load8_u (i32.add (local.get $hoff) (local.get $i))) (local.get $nb))
+            (then
+              (local.set $match (i32.const 1))
+              (local.set $j (i32.const 1))
+              (block $mn2 (loop $mi2
+                (br_if $mn2 (i32.ge_s (local.get $j) (local.get $nlen)))
+                (if (i32.ne (i32.load8_u (i32.add (i32.add (local.get $hoff) (local.get $i)) (local.get $j)))
+                            ${nByte('(local.get $j)')})
+                  (then (local.set $match (i32.const 0)) (br $mn2)))
+                (local.set $j (i32.add (local.get $j) (i32.const 1)))
+                (br $mi2)))
+              (if (local.get $match) (then (return (local.get $i))))))
+          (local.set $i (i32.add (local.get $i) (i32.const 1)))
+          (br $mo)))
+        (return (i32.const -1))))
     (block $done (loop $outer
       (br_if $done (i32.gt_s (local.get $i) (i32.sub (local.get $hlen) (local.get $nlen))))
       (local.set $match (i32.const 1))
@@ -1025,6 +1116,18 @@ export default (ctx) => {
         (global.set $__heap (local.get $newHeap))
         (return (f64.reinterpret_i64 (local.get $a)))))` : ''
 
+  // Always-fresh tail: allocate a new buffer and copy both operands. Shared by the
+  // bump-extend concats (reached when `a` is NOT heap-top) and the `_fresh` variants
+  // (which never bump-extend at all — emit routes a NON-self-accumulating `t = s + x`
+  // here so it can't mutate the live `s` the way the heap-top extend would).
+  const allocCopyTail = `
+    (local.set $off (call $__alloc (i32.add (i32.const 4) (local.get $total))))
+    (i32.store (local.get $off) (local.get $total))
+    (local.set $off (i32.add (local.get $off) (i32.const 4)))
+    (call $__str_copy (local.get $a) (local.get $off) (local.get $alen))
+    (call $__str_copy (local.get $b) (i32.add (local.get $off) (local.get $alen)) (local.get $blen))
+    (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $off)))`
+
   // Fused single-byte append: `buf += str[i]` lowers to this when both sides are
   // VAL.STRING and the rhs is a string-index. Skips __str_idx's 1-char SSO
   // construction and __str_concat's type-dispatch — byte goes directly from
@@ -1084,6 +1187,10 @@ export default (ctx) => {
     (i32.store8 (i32.add (local.get $off) (local.get $alen)) (local.get $byte))
     (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $off)))`)
 
+  // __str_concat / __str_concat_raw bump-EXTEND `a` in place when it is the heap-top own string
+  // (the O(N) accumulator path). Emit calls these ONLY when the source is a self-accumulation
+  // `x = x + …` (so the mutated `a` is dead-after-reassign) or when `a` is a provably-fresh
+  // module-internal temporary; a plain `t = s + x` over a live `s` routes to the _fresh twins.
   wat('__str_concat', `(func $__str_concat (param $a i64) (param $b i64) (result f64)
     (local $alen i32) (local $blen i32) (local $total i32) (local $off i32)
     (local $ta i32) (local $aoff i32) (local $newHeap i32)
@@ -1096,13 +1203,7 @@ export default (ctx) => {
     (if (i32.eqz (local.get $total))
       (then (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${LAYOUT.SSO_BIT}) (i32.const 0)))))
     ${ssoResultFast}
-    ${concatFast}
-    (local.set $off (call $__alloc (i32.add (i32.const 4) (local.get $total))))
-    (i32.store (local.get $off) (local.get $total))
-    (local.set $off (i32.add (local.get $off) (i32.const 4)))
-    (call $__str_copy (local.get $a) (local.get $off) (local.get $alen))
-    (call $__str_copy (local.get $b) (i32.add (local.get $off) (local.get $alen)) (local.get $blen))
-    (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $off)))`)
+    ${concatFast}${allocCopyTail}`)
 
   wat('__str_concat_raw', `(func $__str_concat_raw (param $a i64) (param $b i64) (result f64)
     (local $alen i32) (local $blen i32) (local $total i32) (local $off i32)
@@ -1113,13 +1214,30 @@ export default (ctx) => {
     (if (i32.eqz (local.get $total))
       (then (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${LAYOUT.SSO_BIT}) (i32.const 0)))))
     ${ssoResultFast}
-    ${concatFast}
-    (local.set $off (call $__alloc (i32.add (i32.const 4) (local.get $total))))
-    (i32.store (local.get $off) (local.get $total))
-    (local.set $off (i32.add (local.get $off) (i32.const 4)))
-    (call $__str_copy (local.get $a) (local.get $off) (local.get $alen))
-    (call $__str_copy (local.get $b) (i32.add (local.get $off) (local.get $alen)) (local.get $blen))
-    (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $off)))`)
+    ${concatFast}${allocCopyTail}`)
+
+  // Non-mutating twins: same SSO-pair fast path, but NEVER bump-extend — always alloc+copy a fresh
+  // buffer, leaving `a` untouched. The default for emit's user-level `+` (any `t = s + x` where the
+  // result is not assigned straight back to `s`), so string immutability holds for live operands.
+  wat('__str_concat_fresh', `(func $__str_concat_fresh (param $a i64) (param $b i64) (result f64)
+    (local $alen i32) (local $blen i32) (local $total i32) (local $off i32)
+    (local.set $a (call $__to_str (local.get $a)))
+    (local.set $b (call $__to_str (local.get $b)))
+    (local.set $alen (call $__str_byteLen (local.get $a)))
+    (local.set $blen (call $__str_byteLen (local.get $b)))
+    (local.set $total (i32.add (local.get $alen) (local.get $blen)))
+    (if (i32.eqz (local.get $total))
+      (then (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${LAYOUT.SSO_BIT}) (i32.const 0)))))
+    ${ssoResultFast}${allocCopyTail}`)
+
+  wat('__str_concat_raw_fresh', `(func $__str_concat_raw_fresh (param $a i64) (param $b i64) (result f64)
+    (local $alen i32) (local $blen i32) (local $total i32) (local $off i32)
+    (local.set $alen (call $__str_byteLen (local.get $a)))
+    (local.set $blen (call $__str_byteLen (local.get $b)))
+    (local.set $total (i32.add (local.get $alen) (local.get $blen)))
+    (if (i32.eqz (local.get $total))
+      (then (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${LAYOUT.SSO_BIT}) (i32.const 0)))))
+    ${ssoResultFast}${allocCopyTail}`)
 
   wat('__str_replace', `(func $__str_replace (param $str i64) (param $search i64) (param $repl i64) (result f64)
     (local $idx i32) (local $slen i32)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jz",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Ahead-of-time compiler for the numeric core of JavaScript (DSP, audio, math, parsers) to lean GC-free WASM — valid jz is valid JS, no type annotations, no runtime.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -76,7 +76,7 @@
   "license": "MIT",
   "dependencies": {
     "subscript": "^10.4.17",
-    "watr": "^4.7.1"
+    "watr": "^5.0.0"
   },
   "keywords": [
     "javascript",