jz 0.1.0 → 0.2.0

package/module/math.js

@@ -13,7 +13,8 @@
  * @module math
  */
 
-import { emit, typed, asF64, asI32, temp, arrayLoop } from '../src/compile.js'
+import { typed, asF64, asI32, temp, arrayLoop } from '../src/ir.js'
+import { emit } from '../src/emit.js'
 import { inc } from '../src/ctx.js'
 import { repOf } from '../src/analyze.js'
 
@@ -59,13 +60,21 @@ export default (ctx) => {
   ctx.core.emit['math.ceil'] = a => fInt('f64.ceil', a)
   ctx.core.emit['math.trunc'] = a => fInt('f64.trunc', a)
   ctx.core.emit['math.min'] = (a, b, ...rest) => {
+    if (a === undefined) return typed(['f64.const', Infinity], 'f64')
     // Spread: Math.min(...arr) — iterate array to find min
     if (!b && Array.isArray(a) && a[0] === '...') return emitArrayReduce('f64.min', a[1], Infinity)
-    return f2('f64.min', a, b)
+    if (b === undefined) return typed(['f64.min', asF64(emit(a)), ['f64.const', Infinity]], 'f64')
+    let r = f2('f64.min', a, b)
+    for (const x of rest) r = typed(['f64.min', r, asF64(emit(x))], 'f64')
+    return r
   }
   ctx.core.emit['math.max'] = (a, b, ...rest) => {
+    if (a === undefined) return typed(['f64.const', -Infinity], 'f64')
     if (!b && Array.isArray(a) && a[0] === '...') return emitArrayReduce('f64.max', a[1], -Infinity)
-    return f2('f64.max', a, b)
+    if (b === undefined) return typed(['f64.max', asF64(emit(a)), ['f64.const', -Infinity]], 'f64')
+    let r = f2('f64.max', a, b)
+    for (const x of rest) r = typed(['f64.max', r, asF64(emit(x))], 'f64')
+    return r
   }
   ctx.core.emit['math.round'] = a => fInt('f64.nearest', a)
   ctx.core.emit['math.fround'] = a => typed(['f64.promote_f32', ['f32.demote_f64', asF64(emit(a))]], 'f64')
@@ -106,7 +115,16 @@ export default (ctx) => {
   ctx.core.emit['math.pow'] = (a, b) => callDeps(['math.exp', 'math.log', 'math.pow'], 'math.pow', a, b)
   ctx.core.emit['**'] = ctx.core.emit['math.pow']
   ctx.core.emit['math.cbrt'] = a => callDeps(['math.exp', 'math.log', 'math.pow', 'math.cbrt'], 'math.cbrt', a)
-  ctx.core.emit['math.hypot'] = (a, b) => call('math.hypot', a, b)
+  ctx.core.emit['math.hypot'] = (a, b, ...rest) => {
+    if (a === undefined) return typed(['f64.const', 0], 'f64')
+    if (b === undefined) return f('f64.abs', a)
+    let r = call('math.hypot', a, b)
+    for (const x of rest) {
+      inc('math.hypot')
+      r = typed(['call', '$math.hypot', r, asF64(emit(x))], 'f64')
+    }
+    return r
+  }
 
   // Integer/bit operations: return i32 directly. Consumers `asF64`-rebox at
   // store/return boundaries; consumers staying in i32 (bit chains, i32 locals)
@@ -169,6 +187,7 @@ export default (ctx) => {
 
   ctx.core.stdlib['math.exp'] = `(func $math.exp (param $x f64) (result f64)
     (local $k i32) (local $t f64) (local $t2 f64) (local $result f64) (local $pow2 f64)
+    (if (f64.ne (local.get $x) (local.get $x)) (then (return (local.get $x))))
     (if (result f64) (f64.gt (local.get $x) (f64.const 709.0)) (then (f64.const 1.7976931348623157e+308)) (else
       (if (result f64) (f64.lt (local.get $x) (f64.const -745.0)) (then (f64.const 0.0)) (else
         (local.set $k (i32.trunc_f64_s (f64.div (local.get $x) (f64.const ${Math.LN2}))))
@@ -246,42 +265,64 @@ export default (ctx) => {
 
   ctx.core.stdlib['math.pow'] = `(func $math.pow (param $x f64) (param $y f64) (result f64)
     (local $result f64) (local $n i32) (local $neg_base i32) (local $abs_x f64)
-    (if (result f64) (f64.eq (local.get $y) (f64.const 0.0))
-      (then (f64.const 1.0))
-      (else (if (result f64) (f64.eq (local.get $x) (f64.const 0.0))
-        (then (f64.const 0.0))
-        (else (if (result f64) (f64.eq (local.get $x) (f64.const 1.0))
-          (then (f64.const 1.0))
-          (else (if (result f64) (f64.eq (local.get $y) (f64.const 1.0))
-            (then (local.get $x))
-            (else
-              (if (result f64)
-                (i32.and
-                  (f64.eq (f64.nearest (local.get $y)) (local.get $y))
-                  (f64.le (f64.abs (local.get $y)) (f64.const 100.0)))
-                (then
-                  (local.set $abs_x (f64.abs (local.get $x)))
-                  (local.set $neg_base (i32.and (f64.lt (local.get $x) (f64.const 0.0))
-                                                (i32.and (i32.trunc_f64_s (local.get $y)) (i32.const 1))))
-                  (local.set $n (i32.trunc_f64_s (f64.abs (local.get $y))))
-                  (local.set $result (f64.const 1.0))
-                  (block $done
-                    (loop $loop
-                      (br_if $done (i32.le_s (local.get $n) (i32.const 0)))
-                      (if (i32.and (local.get $n) (i32.const 1))
-                        (then (local.set $result (f64.mul (local.get $result) (local.get $abs_x)))))
-                      (local.set $abs_x (f64.mul (local.get $abs_x) (local.get $abs_x)))
-                      (local.set $n (i32.shr_s (local.get $n) (i32.const 1)))
-                      (br $loop)))
-                  (if (f64.lt (local.get $y) (f64.const 0.0))
-                    (then (local.set $result (f64.div (f64.const 1.0) (local.get $result)))))
-                  (if (local.get $neg_base)
-                    (then (local.set $result (f64.neg (local.get $result)))))
-                  (local.get $result))
-                (else
-                  (if (result f64) (f64.lt (local.get $x) (f64.const 0.0))
-                    (then (f64.const 0.0))
-                    (else (call $math.exp (f64.mul (local.get $y) (call $math.log (local.get $x)))))))))))))))))`
+    ;; y == 0 -> 1 (covers pow(NaN,0), pow(±0,0), pow(±Inf,0))
+    (if (f64.eq (local.get $y) (f64.const 0.0)) (then (return (f64.const 1.0))))
+    ;; y is NaN -> NaN
+    (if (f64.ne (local.get $y) (local.get $y)) (then (return (local.get $y))))
+    ;; x is NaN -> NaN
+    (if (f64.ne (local.get $x) (local.get $x)) (then (return (local.get $x))))
+    ;; y is ±Infinity
+    (if (f64.eq (f64.abs (local.get $y)) (f64.const inf))
+      (then
+        (local.set $abs_x (f64.abs (local.get $x)))
+        (if (f64.eq (local.get $abs_x) (f64.const 1.0))
+          (then (return (f64.div (f64.const 0.0) (f64.const 0.0)))))
+        (if (i32.eq (f64.gt (local.get $abs_x) (f64.const 1.0))
+                    (f64.gt (local.get $y) (f64.const 0.0)))
+          (then (return (f64.const inf)))
+          (else (return (f64.const 0.0))))))
+    ;; x == 1 -> 1 (after y=±Inf check, so 1**Inf already returned NaN)
+    (if (f64.eq (local.get $x) (f64.const 1.0)) (then (return (f64.const 1.0))))
+    ;; y == 1 -> x (preserves -0 for (-0)**1)
+    (if (f64.eq (local.get $y) (f64.const 1.0)) (then (return (local.get $x))))
+    ;; integer fast path: y integer in i32 range. Binary exponentiation is
+    ;; O(log |n|) so the bound only matters for i32.trunc_f64_s safety.
+    ;; Also covers ±Infinity x: abs_x stays Inf through the loop, 1/Inf=0,
+    ;; with neg_base (x<0 && odd y) producing -0 — required for (-Inf)**-odd.
+    ;; Runs before the x==0 fallback so (-0)**oddInt correctly returns ∓0/∓Inf.
+    (if (i32.and
+          (f64.eq (f64.nearest (local.get $y)) (local.get $y))
+          (f64.lt (f64.abs (local.get $y)) (f64.const 2147483648.0)))
+      (then
+        (local.set $abs_x (f64.abs (local.get $x)))
+        ;; copysign(1, x) gives -1 for any x with sign bit set (incl. -0); f64.lt picks that up.
+        (local.set $neg_base (i32.and (f64.lt (f64.copysign (f64.const 1.0) (local.get $x)) (f64.const 0.0))
+                                      (i32.and (i32.trunc_f64_s (local.get $y)) (i32.const 1))))
+        (local.set $n (i32.trunc_f64_s (f64.abs (local.get $y))))
+        (local.set $result (f64.const 1.0))
+        (block $done
+          (loop $loop
+            (br_if $done (i32.le_s (local.get $n) (i32.const 0)))
+            (if (i32.and (local.get $n) (i32.const 1))
+              (then (local.set $result (f64.mul (local.get $result) (local.get $abs_x)))))
+            (local.set $abs_x (f64.mul (local.get $abs_x) (local.get $abs_x)))
+            (local.set $n (i32.shr_s (local.get $n) (i32.const 1)))
+            (br $loop)))
+        (if (f64.lt (local.get $y) (f64.const 0.0))
+          (then (local.set $result (f64.div (f64.const 1.0) (local.get $result)))))
+        (if (local.get $neg_base)
+          (then (local.set $result (f64.neg (local.get $result)))))
+        (return (local.get $result))))
+    ;; x == 0 with non-integer y -> y<0 ? Infinity : 0 (sign-of-zero only matters for integer y, handled above)
+    (if (f64.eq (local.get $x) (f64.const 0.0))
+      (then
+        (if (f64.lt (local.get $y) (f64.const 0.0))
+          (then (return (f64.const inf)))
+          (else (return (f64.const 0.0))))))
+    ;; x < 0, non-integer finite y -> NaN
+    (if (f64.lt (local.get $x) (f64.const 0.0))
+      (then (return (f64.div (f64.const 0.0) (f64.const 0.0)))))
+    (call $math.exp (f64.mul (local.get $y) (call $math.log (local.get $x)))))`
 
   ctx.core.stdlib['math.atan'] = `(func $math.atan (param $x f64) (result f64)
     (local $x2 f64) (local $abs_x f64) (local $reduced f64)

package/module/number.js

@@ -9,28 +9,48 @@
  * @module number
  */
 
-import { emit, typed, asF64, asI32, asI64, NULL_NAN, UNDEF_NAN, valTypeOf, VAL, temp, tempI32, tempI64 } from '../src/compile.js'
+import { typed, asF64, asI32, asI64, toNumF64, NULL_NAN, UNDEF_NAN, temp, tempI32, tempI64 } from '../src/ir.js'
+import { emit, isReassigned } from '../src/emit.js'
+import { valTypeOf, VAL } from '../src/analyze.js'
 import { inc, PTR } from '../src/ctx.js'
 
 export default (ctx) => {
   Object.assign(ctx.core.stdlibDeps, {
     __mkstr: ['__alloc'],
-    __ftoa: ['__itoa', '__pow10', '__mkstr', '__static_str'],
+    __ftoa: ['__itoa', '__pow10', '__mkstr', '__static_str', '__toExp'],
     __toExp: ['__itoa', '__pow10', '__mkstr', '__static_str'],
-    __to_num: ['__char_at', '__str_byteLen', '__pow10'],
+    __to_num: ['__char_at', '__str_byteLen', '__pow10', '__to_str'],
+    __to_bigint: ['__char_at', '__str_byteLen'],
     __parseInt: ['__char_at', '__str_byteLen'],
   })
 
 
-  // __pow10(n: i32) → f64 — compute 10^n via loop
+  // __pow10(n: i32) → f64 — compute 10^n via binary decomposition.
+  // Naive iterative `r *= 10` accumulates O(n) ULPs of rounding drift —
+  // 1e308 came out 1 ULP low, breaking parseFloat round-trip at the f64 edge.
+  // Bit-decomposition multiplies at most 9 precomputed powers (10^1 .. 10^256),
+  // so accumulated error stays at O(log n) ULPs.
   ctx.core.stdlib['__pow10'] = `(func $__pow10 (param $n i32) (result f64)
     (local $r f64)
     (local.set $r (f64.const 1))
-    (block $d (loop $l
-      (br_if $d (i32.le_s (local.get $n) (i32.const 0)))
-      (local.set $r (f64.mul (local.get $r) (f64.const 10)))
-      (local.set $n (i32.sub (local.get $n) (i32.const 1)))
-      (br $l)))
+    (if (i32.and (local.get $n) (i32.const 1))
+      (then (local.set $r (f64.mul (local.get $r) (f64.const 10)))))
+    (if (i32.and (local.get $n) (i32.const 2))
+      (then (local.set $r (f64.mul (local.get $r) (f64.const 100)))))
+    (if (i32.and (local.get $n) (i32.const 4))
+      (then (local.set $r (f64.mul (local.get $r) (f64.const 10000)))))
+    (if (i32.and (local.get $n) (i32.const 8))
+      (then (local.set $r (f64.mul (local.get $r) (f64.const 1e8)))))
+    (if (i32.and (local.get $n) (i32.const 16))
+      (then (local.set $r (f64.mul (local.get $r) (f64.const 1e16)))))
+    (if (i32.and (local.get $n) (i32.const 32))
+      (then (local.set $r (f64.mul (local.get $r) (f64.const 1e32)))))
+    (if (i32.and (local.get $n) (i32.const 64))
+      (then (local.set $r (f64.mul (local.get $r) (f64.const 1e64)))))
+    (if (i32.and (local.get $n) (i32.const 128))
+      (then (local.set $r (f64.mul (local.get $r) (f64.const 1e128)))))
+    (if (i32.and (local.get $n) (i32.const 256))
+      (then (local.set $r (f64.mul (local.get $r) (f64.const 1e256)))))
     (local.get $r))`
 
   // __itoa(val: i32, buf: i32) → i32 (digit count). Writes decimal digits to buf.
@@ -83,6 +103,17 @@ export default (ctx) => {
     (if (f64.ne (local.get $val) (local.get $val)) (then (return (call $__static_str (i32.const 0)))))
     (if (f64.eq (local.get $val) (f64.const inf)) (then (return (call $__static_str (i32.const 1)))))
     (if (f64.eq (local.get $val) (f64.const -inf)) (then (return (call $__static_str (i32.const 2)))))
+    ;; ES spec: |x| >= 1e21 or 0 < |x| < 1e-6 → exponential notation (default mode only).
+    ;; Cap prec at 9: mantissa fits i32, avoiding trunc_f64_u trap. Fewer digits than
+    ;; ECMAScript shortest-repr ideal, but valid output for very large/small numbers.
+    (if (i32.eqz (local.get $mode))
+      (then
+        (if (f64.ge (f64.abs (local.get $val)) (f64.const 1e21))
+          (then (return (call $__toExp (local.get $val) (i32.const 9)))))
+        (if (i32.and
+              (f64.gt (f64.abs (local.get $val)) (f64.const 0))
+              (f64.lt (f64.abs (local.get $val)) (f64.const 1e-6)))
+          (then (return (call $__toExp (local.get $val) (i32.const 9)))))))
     (local.set $buf (call $__alloc (i32.const 40)))
     ;; Sign
     (if (f64.lt (local.get $val) (f64.const 0))
@@ -291,19 +322,17 @@ export default (ctx) => {
 
   // Global isNaN/isFinite — coerce string→number first (unlike Number.isNaN/isFinite)
   ctx.core.emit['isNaN'] = (x) => {
-    inc('__to_num')
-    const v = asF64(emit(x))
+    const v = toNumF64(x, emit(x))
     const t = temp('t')
     return typed(['f64.ne',
-      ['local.tee', `$${t}`, ['call', '$__to_num', v]],
+      ['local.tee', `$${t}`, v],
       ['local.get', `$${t}`]], 'i32')
   }
   ctx.core.emit['isFinite'] = (x) => {
-    inc('__to_num')
-    const v = asF64(emit(x))
+    const v = toNumF64(x, emit(x))
     const t = temp('t')
     return typed(['i32.and',
-      ['f64.eq', ['local.tee', `$${t}`, ['call', '$__to_num', v]], ['local.get', `$${t}`]],
+      ['f64.eq', ['local.tee', `$${t}`, v], ['local.get', `$${t}`]],
       ['f64.lt', ['f64.abs', ['local.get', `$${t}`]], ['f64.const', Infinity]]], 'i32')
   }
 
@@ -318,15 +347,14 @@ export default (ctx) => {
   }
 
   // parseInt(str, radix) — parse string to integer
-  ctx.core.stdlib['__parseInt'] = `(func $__parseInt (param $str f64) (param $radix i32) (result f64)
+  ctx.core.stdlib['__parseInt'] = `(func $__parseInt (param $str i64) (param $radix i32) (result f64)
     (local $off i32) (local $len i32) (local $i i32) (local $c i32) (local $neg i32)
-    (local $result f64) (local $digit i32) (local $seen i32)
+    (local $result f64) (local $digit i32) (local $seen i32) (local $f f64)
+    (local.set $f (f64.reinterpret_i64 (local.get $str)))
     ;; If input is a number, just truncate
-    (if (f64.eq (local.get $str) (local.get $str)) (then (return (f64.trunc (local.get $str)))))
-    ;; If NaN-boxed but not a string type (4=heap,5=SSO) → return NaN
-    (if (i32.and
-          (i32.ne (call $__ptr_type (local.get $str)) (i32.const 4))
-          (i32.ne (call $__ptr_type (local.get $str)) (i32.const 5)))
+    (if (f64.eq (local.get $f) (local.get $f)) (then (return (f64.trunc (local.get $f)))))
+    ;; If NaN-boxed but not a string → return NaN
+    (if (i32.ne (call $__ptr_type (local.get $str)) (i32.const 4))
       (then (return (f64.const nan))))
     (local.set $off (call $__ptr_offset (local.get $str)))
     (local.set $len (call $__str_byteLen (local.get $str)))
@@ -374,19 +402,25 @@ export default (ctx) => {
     (if (i32.eqz (local.get $seen)) (then (return (f64.const nan))))
     (if (result f64) (local.get $neg) (then (f64.neg (local.get $result))) (else (local.get $result))))`
 
-  ctx.core.stdlib['__to_num'] = `(func $__to_num (param $v f64) (result f64)
+  ctx.core.stdlib['__to_num'] = `(func $__to_num (param $v i64) (result f64)
     (local $t i32) (local $len i32) (local $i i32) (local $c i32) (local $neg i32)
-    (local $seen i32) (local $exp i32) (local $expNeg i32)
-    (local $result f64) (local $scale f64)
-    (if (f64.eq (local.get $v) (local.get $v)) (then (return (local.get $v))))
-    (if (i64.eq (i64.reinterpret_f64 (local.get $v)) (i64.const ${NULL_NAN})) (then (return (f64.const 0))))
-    (if (i64.eq (i64.reinterpret_f64 (local.get $v)) (i64.const ${UNDEF_NAN})) (then (return (f64.const nan))))
+    (local $seen i32) (local $exp i32) (local $expNeg i32) (local $expDigits i32)
+    (local $dot i32) (local $sigDigits i32) (local $decExp i32) (local $dropped i32) (local $round i32)
+    (local $wsEnd i32)
+    (local $result f64) (local $f f64)
+    (local.set $f (f64.reinterpret_i64 (local.get $v)))
+    (if (f64.eq (local.get $f) (local.get $f)) (then (return (local.get $f))))
+    (if (i64.eq (local.get $v) (i64.const ${NULL_NAN})) (then (return (f64.const 0))))
+    (if (i64.eq (local.get $v) (i64.const ${UNDEF_NAN})) (then (return (f64.const nan))))
     (local.set $t (call $__ptr_type (local.get $v)))
-    (if (i32.eqz
-          (i32.or
-            (i32.eq (local.get $t) (i32.const ${PTR.STRING}))
-            (i32.eq (local.get $t) (i32.const ${PTR.SSO}))))
-      (then (return (f64.const nan))))
+    ;; Non-string values go through ToString per JS spec, then re-check the
+    ;; type in case ToString itself returned a non-string sentinel.
+    (if (i32.ne (local.get $t) (i32.const ${PTR.STRING}))
+      (then
+        (local.set $v (call $__to_str (local.get $v)))
+        (local.set $t (call $__ptr_type (local.get $v)))
+        (if (i32.ne (local.get $t) (i32.const ${PTR.STRING}))
+          (then (return (f64.const nan))))))
     (local.set $len (call $__str_byteLen (local.get $v)))
     ;; Skip leading whitespace.
     (block $ws (loop $wsl
@@ -394,6 +428,7 @@ export default (ctx) => {
       (br_if $ws (i32.gt_s (call $__char_at (local.get $v) (local.get $i)) (i32.const 32)))
       (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (br $wsl)))
+    (local.set $wsEnd (local.get $i))
     ;; Sign.
     (if (i32.and (i32.lt_s (local.get $i) (local.get $len))
       (i32.eq (call $__char_at (local.get $v) (local.get $i)) (i32.const 45)))
@@ -422,45 +457,51 @@ export default (ctx) => {
             (then (local.set $result (f64.add (f64.mul (local.get $result) (f64.const 16)) (f64.convert_i32_s (i32.sub (local.get $c) (i32.const 55)))))
               (local.set $seen (i32.const 1)) (local.set $i (i32.add (local.get $i) (i32.const 1))) (br $hexLoop)))))
         (return (if (result f64) (local.get $neg) (then (f64.neg (local.get $result))) (else (local.get $result))))))
-    ;; Integer part.
-    (block $intDone (loop $intLoop
-      (br_if $intDone (i32.ge_s (local.get $i) (local.get $len)))
+    ;; Decimal significand. Keep 17 significant decimal digits, track the
+    ;; base-10 exponent for skipped digits, and round once before pow10 scaling.
+    (block $numDone (loop $numLoop
+      (br_if $numDone (i32.ge_s (local.get $i) (local.get $len)))
       (local.set $c (call $__char_at (local.get $v) (local.get $i)))
-      (br_if $intDone
+      (if (i32.and (i32.eq (local.get $c) (i32.const 46)) (i32.eqz (local.get $dot)))
+        (then
+          (local.set $dot (i32.const 1))
+          (local.set $i (i32.add (local.get $i) (i32.const 1)))
+          (br $numLoop)))
+      (br_if $numDone
         (i32.or
           (i32.lt_s (local.get $c) (i32.const 48))
           (i32.gt_s (local.get $c) (i32.const 57))))
-      (local.set $result
-        (f64.add
-          (f64.mul (local.get $result) (f64.const 10))
-          (f64.convert_i32_s (i32.sub (local.get $c) (i32.const 48)))))
       (local.set $seen (i32.const 1))
-      (local.set $i (i32.add (local.get $i) (i32.const 1)))
-      (br $intLoop)))
-    ;; Fractional part.
-    (if (i32.and (i32.lt_s (local.get $i) (local.get $len))
-      (i32.eq (call $__char_at (local.get $v) (local.get $i)) (i32.const 46)))
-      (then
-        (local.set $i (i32.add (local.get $i) (i32.const 1)))
-        (local.set $scale (f64.const 0.1))
-        (block $fracDone (loop $fracLoop
-          (br_if $fracDone (i32.ge_s (local.get $i) (local.get $len)))
-          (local.set $c (call $__char_at (local.get $v) (local.get $i)))
-          (br_if $fracDone
-            (i32.or
-              (i32.lt_s (local.get $c) (i32.const 48))
-              (i32.gt_s (local.get $c) (i32.const 57))))
+      (local.set $c (i32.sub (local.get $c) (i32.const 48)))
+      (if (i32.and (i32.eqz (local.get $sigDigits)) (i32.eqz (local.get $c)))
+        (then
+          (if (local.get $dot) (then (local.set $decExp (i32.sub (local.get $decExp) (i32.const 1)))))
+          (local.set $i (i32.add (local.get $i) (i32.const 1)))
+          (br $numLoop)))
+      (if (i32.lt_s (local.get $sigDigits)
+        (if (result i32) (local.get $dot) (then (i32.const 16)) (else (i32.const 17))))
+        (then
           (local.set $result
             (f64.add
-              (local.get $result)
-              (f64.mul
-                (f64.convert_i32_s (i32.sub (local.get $c) (i32.const 48)))
-                (local.get $scale))))
-          (local.set $scale (f64.mul (local.get $scale) (f64.const 0.1)))
-          (local.set $seen (i32.const 1))
-          (local.set $i (i32.add (local.get $i) (i32.const 1)))
-          (br $fracLoop)))))
-    (if (i32.eqz (local.get $seen)) (then (return (f64.const nan))))
+              (f64.mul (local.get $result) (f64.const 10))
+              (f64.convert_i32_s (local.get $c))))
+          (local.set $sigDigits (i32.add (local.get $sigDigits) (i32.const 1)))
+          (if (local.get $dot) (then (local.set $decExp (i32.sub (local.get $decExp) (i32.const 1))))))
+        (else
+          (if (i32.eqz (local.get $dropped))
+            (then (if (i32.ge_s (local.get $c) (i32.const 5)) (then (local.set $round (i32.const 1))))))
+          (local.set $dropped (i32.const 1))
+          (if (i32.eqz (local.get $dot)) (then (local.set $decExp (i32.add (local.get $decExp) (i32.const 1)))))))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (br $numLoop)))
+    ;; No digits seen: empty/whitespace-only string coerces to 0; non-numeric
+    ;; content (sign-only, "abc", etc.) coerces to NaN.
+    (if (i32.eqz (local.get $seen))
+      (then
+        (if (i32.ge_s (local.get $wsEnd) (local.get $len))
+          (then (return (f64.const 0))))
+        (return (f64.const nan))))
+    (if (local.get $round) (then (local.set $result (f64.add (local.get $result) (f64.const 1)))))
     ;; Scientific notation.
     (if (i32.and (i32.lt_s (local.get $i) (local.get $len))
       (i32.or
@@ -485,28 +526,88 @@ export default (ctx) => {
             (i32.add
               (i32.mul (local.get $exp) (i32.const 10))
               (i32.sub (local.get $c) (i32.const 48))))
+          (local.set $expDigits (i32.add (local.get $expDigits) (i32.const 1)))
           (local.set $i (i32.add (local.get $i) (i32.const 1)))
           (br $expLoop)))
-        (if (local.get $expNeg)
-          (then (local.set $result (f64.div (local.get $result) (call $__pow10 (local.get $exp)))))
-          (else (local.set $result (f64.mul (local.get $result) (call $__pow10 (local.get $exp))))))))
+        (if (local.get $expDigits)
+          (then
+            (if (local.get $expNeg)
+              (then (local.set $decExp (i32.sub (local.get $decExp) (local.get $exp))))
+              (else (local.set $decExp (i32.add (local.get $decExp) (local.get $exp)))))))))
+    (if (i32.gt_s (local.get $decExp) (i32.const 0))
+      (then (local.set $result (f64.mul (local.get $result) (call $__pow10 (local.get $decExp))))))
+    (if (i32.lt_s (local.get $decExp) (i32.const 0))
+      (then (local.set $result (f64.div (local.get $result) (call $__pow10 (i32.sub (i32.const 0) (local.get $decExp)))))))
     (if (result f64) (local.get $neg) (then (f64.neg (local.get $result))) (else (local.get $result))))`
 
+  ctx.core.stdlib['__to_bigint'] = `(func $__to_bigint (param $v i64) (result f64)
+    (local $t i32) (local $len i32) (local $i i32) (local $c i32) (local $neg i32)
+    (local $radix i32) (local $digit i32) (local $seen i32) (local $result i64) (local $f f64)
+    (local.set $f (f64.reinterpret_i64 (local.get $v)))
+    (if (f64.eq (local.get $f) (local.get $f))
+      (then (return (f64.reinterpret_i64 (i64.trunc_sat_f64_s (local.get $f))))))
+    (local.set $t (call $__ptr_type (local.get $v)))
+    (if (i32.ne (local.get $t) (i32.const ${PTR.STRING}))
+      (then (return (f64.reinterpret_i64 (i64.const 0)))))
+    (local.set $len (call $__str_byteLen (local.get $v)))
+    (block $ws (loop $wsl
+      (br_if $ws (i32.ge_s (local.get $i) (local.get $len)))
+      (br_if $ws (i32.gt_s (call $__char_at (local.get $v) (local.get $i)) (i32.const 32)))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (br $wsl)))
+    (if (i32.and (i32.lt_s (local.get $i) (local.get $len))
+      (i32.eq (call $__char_at (local.get $v) (local.get $i)) (i32.const 45)))
+      (then (local.set $neg (i32.const 1)) (local.set $i (i32.add (local.get $i) (i32.const 1)))))
+    (if (i32.and (i32.lt_s (local.get $i) (local.get $len))
+      (i32.eq (call $__char_at (local.get $v) (local.get $i)) (i32.const 43)))
+      (then (local.set $i (i32.add (local.get $i) (i32.const 1)))))
+    (local.set $radix (i32.const 10))
+    (if (i32.and
+      (i32.lt_s (i32.add (local.get $i) (i32.const 1)) (local.get $len))
+      (i32.and (i32.eq (call $__char_at (local.get $v) (local.get $i)) (i32.const 48))
+        (i32.or (i32.eq (call $__char_at (local.get $v) (i32.add (local.get $i) (i32.const 1))) (i32.const 120))
+          (i32.eq (call $__char_at (local.get $v) (i32.add (local.get $i) (i32.const 1))) (i32.const 88)))))
+      (then (local.set $radix (i32.const 16)) (local.set $i (i32.add (local.get $i) (i32.const 2)))))
+    (block $done (loop $lp
+      (br_if $done (i32.ge_s (local.get $i) (local.get $len)))
+      (local.set $c (call $__char_at (local.get $v) (local.get $i)))
+      (local.set $digit (i32.const -1))
+      (if (i32.and (i32.ge_s (local.get $c) (i32.const 48)) (i32.le_s (local.get $c) (i32.const 57)))
+        (then (local.set $digit (i32.sub (local.get $c) (i32.const 48)))))
+      (if (i32.and (i32.ge_s (local.get $c) (i32.const 97)) (i32.le_s (local.get $c) (i32.const 122)))
+        (then (local.set $digit (i32.sub (local.get $c) (i32.const 87)))))
+      (if (i32.and (i32.ge_s (local.get $c) (i32.const 65)) (i32.le_s (local.get $c) (i32.const 90)))
+        (then (local.set $digit (i32.sub (local.get $c) (i32.const 55)))))
+      (br_if $done (i32.or (i32.lt_s (local.get $digit) (i32.const 0)) (i32.ge_s (local.get $digit) (local.get $radix))))
+      (local.set $seen (i32.const 1))
+      (local.set $result
+        (i64.add
+          (i64.mul (local.get $result) (i64.extend_i32_s (local.get $radix)))
+          (i64.extend_i32_s (local.get $digit))))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (br $lp)))
+    (if (i32.eqz (local.get $seen)) (then (return (f64.reinterpret_i64 (i64.const 0)))))
+    (f64.reinterpret_i64
+      (if (result i64) (local.get $neg)
+        (then (i64.sub (i64.const 0) (local.get $result)))
+        (else (local.get $result)))))`
+
   ctx.core.emit['Number.parseInt'] = (x, radix) => {
     inc('__parseInt')
-    return typed(['call', '$__parseInt', asF64(emit(x)), radix ? asI32(emit(radix)) : ['i32.const', 0]], 'f64')
+    return typed(['call', '$__parseInt', asI64(emit(x)), radix ? asI32(emit(radix)) : ['i32.const', 0]], 'f64')
   }
   ctx.core.emit['parseInt'] = ctx.core.emit['Number.parseInt']
   ctx.core.emit['Number.parseFloat'] = (x) => {
     inc('__to_num')
-    return typed(['call', '$__to_num', asF64(emit(x))], 'f64')
+    return typed(['call', '$__to_num', asI64(emit(x))], 'f64')
   }
   ctx.core.emit['parseFloat'] = ctx.core.emit['Number.parseFloat']
 
   // Boolean(x) → truthiness (non-zero → 1, zero → 0)
   ctx.core.emit['Boolean'] = (x) => {
+    if (x === undefined) return typed(['f64.const', 0], 'f64')
     inc('__is_truthy')
-    const v = asF64(emit(x))
+    const v = asI64(emit(x))
     return typed(['if', ['result', 'f64'], ['call', '$__is_truthy', v], ['then', ['f64.const', 1]], ['else', ['f64.const', 0]]], 'f64')
   }
 
@@ -557,18 +658,12 @@ export default (ctx) => {
           ['i32.const', 1]]]]], 'f64')
   }
 
-  ctx.core.emit['String'] = (x) => {
-    inc('__ftoa')
-    if (Array.isArray(x) && x[0] === 'str') return emit(x)
-    return typed(['call', '$__ftoa', asF64(emit(x)), ['i32.const', 0], ['i32.const', 0]], 'f64')
-  }
-
   // Number(x) — identity for numbers, i64→f64 conversion for BigInt
   ctx.core.emit['Number'] = (x) => {
+    if (x === undefined) return typed(['f64.const', 0], 'f64')
     if (valTypeOf(x) === VAL.BIGINT)
       return typed(['f64.convert_i64_s', asI64(emit(x))], 'f64')
-    inc('__to_num')
-    return typed(['call', '$__to_num', asF64(emit(x))], 'f64')
+    return toNumF64(x, emit(x))
   }
 
   // BigInt(x) — f64→i64 conversion (reinterpret as BigInt-as-f64).
@@ -576,12 +671,23 @@ export default (ctx) => {
   // (handles both decimal and hex string parse), then truncate.
   ctx.core.emit['BigInt'] = (x) => {
     const vt = valTypeOf(x)
-    if (vt === VAL.BIGINT) return emit(x)
+    if (vt === VAL.BIGINT) {
+      if (typeof x === 'bigint' || (typeof x === 'string' && !isReassigned(ctx.func.body, x))) return emit(x)
+      inc('__to_bigint', '__ptr_type')
+      const t = temp('bi')
+      return typed(['block', ['result', 'f64'],
+        ['local.set', `$${t}`, asF64(emit(x))],
+        ['if', ['result', 'f64'], ['f64.eq', ['local.get', `$${t}`], ['local.get', `$${t}`]],
+          ['then', ['f64.reinterpret_i64', ['i64.trunc_sat_f64_s', ['local.get', `$${t}`]]]],
+          ['else', ['if', ['result', 'f64'],
+            ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${t}`]]], ['i32.const', PTR.STRING]],
+            ['then', ['call', '$__to_bigint', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+            ['else', ['local.get', `$${t}`]]]]]], 'f64')
+    }
     if (vt === VAL.NUMBER)
       return typed(['f64.reinterpret_i64', ['i64.trunc_sat_f64_s', asF64(emit(x))]], 'f64')
-    inc('__to_num')
-    return typed(['f64.reinterpret_i64',
-      ['i64.trunc_sat_f64_s', ['call', '$__to_num', asF64(emit(x))]]], 'f64')
+    inc('__to_bigint')
+    return typed(['call', '$__to_bigint', asI64(emit(x))], 'f64')
   }
 
   // BigInt.asIntN(bits, bigint) — truncate to signed N-bit