jz 0.4.0 → 0.5.0

package/module/number.js

@@ -9,19 +9,139 @@
  * @module number
  */
 
-import { typed, asF64, asI32, asI64, toNumF64, NULL_NAN, UNDEF_NAN, temp, tempI32, tempI64 } from '../src/ir.js'
-import { emit } from '../src/emit.js'
-import { isReassigned } from '../src/ast.js'
-import { valTypeOf, VAL } from '../src/analyze.js'
+import { typed, asF64, asI32, asI64, toI32, toNumF64, NULL_NAN, UNDEF_NAN, temp, tempI32, tempI64 } from '../src/ir.js'
+import { emit, emitBoolStr } from '../src/emit.js'
+import { isReassigned, valTypeOf, VAL } from '../src/analyze.js'
 import { inc, PTR } from '../src/ctx.js'
 
+// ─── Shared decimal-number parsing fragments ────────────────────────────────
+// `__to_num` (Number coercion) and `__parseFloat` both scan a StrDecimalLiteral
+// significand + ExponentPart, and that scan was verbatim-identical between them
+// — a "fix the same bug twice" hazard (commit 652ba5f patched both copies).
+// These named fragments are the common core, spliced into both bodies; the
+// produced WASM is unchanged, the source now has one place to fix.
+// Required locals (every consumer declares them):
+//   $v i64 · $i $len $c $dot $seen $sigDigits $decExp $dropped $round
+//   $exp $expNeg $expDigits $sbase i32 · $mant i64 · $result f64
+
+// In-bounds byte read for a confirmed string `$v`. `__char_at` is ~95 WASM
+// instructions — too large for V8 to inline — so a scan that calls it per
+// char pays a real call plus a redundant SSO/view/bounds dispatch every step.
+// A non-SSO string (the common case: source slices, heap strings) keeps its
+// bytes contiguous at `$v & 0xFFFFFFFF` (`$sbase`); the read collapses to one
+// `i32.load8_u`. The SSO test is loop-invariant — V8 hoists it — and the SSO
+// arm still routes through `__char_at` (its bytes are packed in the pointer).
+// Callers MUST declare `$sbase i32`, set it once after `$v` is final and a
+// confirmed string, and only pass indices proven `< $len` (`__char_at` would
+// otherwise return its OOB 0; the inline load has no such guard).
+const SBASE_INIT = '(local.set $sbase (i32.wrap_i64 (i64.and (local.get $v) (i64.const 4294967295))))'
+const chAt = idx => `(if (result i32)
+        (i64.eqz (i64.and (local.get $v) (i64.const 0x0000400000000000)))
+        (then (i32.load8_u (i32.add (local.get $sbase) ${idx})))
+        (else (call $__char_at (local.get $v) ${idx})))`
+
+// chAt for reads NOT dominated by a `$i < $len` guard. `i32.and` does not
+// short-circuit, so `(i32.and (lt_s $i $len) (… chAt …))` would still run the
+// unguarded inline load when `$i == $len`. chAtSafe restores `__char_at`'s
+// total contract (0 out of bounds), so such a site drops the now-redundant
+// outer guard and compares chAtSafe directly against the wanted byte.
+const chAtSafe = idx => `(if (result i32)
+        (i32.lt_s ${idx} (local.get $len))
+        (then ${chAt(idx)})
+        (else (i32.const 0)))`
+
+// 18-significant-digit significand → $mant; $decExp tracks the base-10 exponent
+// of dropped/fractional digits; $round defers a single round-up.
+const DEC_SIGNIFICAND = `
+    (block $numDone (loop $numLoop
+      (br_if $numDone (i32.ge_s (local.get $i) (local.get $len)))
+      (local.set $c ${chAt('(local.get $i)')})
+      (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 $seen (i32.const 1))
+      (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)))
+      ;; Accumulate the significand in an i64 (exact to 18 decimal digits,
+      ;; since 10^18 < 2^63) and convert to f64 once at the end — a single
+      ;; correctly-rounded i64->f64 step instead of lossy per-digit f64 math.
+      (if (i32.lt_s (local.get $sigDigits) (i32.const 18))
+        (then
+          (local.set $mant
+            (i64.add
+              (i64.mul (local.get $mant) (i64.const 10))
+              (i64.extend_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 significant digit seen → NaN; apply the deferred round; $mant → $result.
+const FINISH_SIGNIFICAND = `
+    (if (i32.eqz (local.get $seen)) (then (return (f64.const nan))))
+    (if (local.get $round) (then (local.set $mant (i64.add (local.get $mant) (i64.const 1)))))
+    (local.set $result (f64.convert_i64_u (local.get $mant)))`
+
+// ExponentPart scan: 'e'/'E' + optional sign + digits → $exp / $expDigits.
+// `tail` runs inside the e/E branch — Number rejects an empty exponent ("1e")
+// as NaN, parseFloat ignores it, so each caller passes its own resolution.
+const sciExponent = (tail) => `
+    (local.set $c ${chAtSafe('(local.get $i)')})
+    (if (i32.or
+        (i32.eq (local.get $c) (i32.const 101))
+        (i32.eq (local.get $c) (i32.const 69)))
+      (then
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (if (i32.eq ${chAtSafe('(local.get $i)')} (i32.const 45))
+          (then (local.set $expNeg (i32.const 1)) (local.set $i (i32.add (local.get $i) (i32.const 1)))))
+        (if (i32.eq ${chAtSafe('(local.get $i)')} (i32.const 43))
+          (then (local.set $i (i32.add (local.get $i) (i32.const 1)))))
+        (block $expDone (loop $expLoop
+          (br_if $expDone (i32.ge_s (local.get $i) (local.get $len)))
+          (local.set $c ${chAt('(local.get $i)')})
+          (br_if $expDone
+            (i32.or
+              (i32.lt_s (local.get $c) (i32.const 48))
+              (i32.gt_s (local.get $c) (i32.const 57))))
+          (local.set $exp
+            (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)))
+        ${tail}))`
+
+// Apply the accumulated base-10 exponent to $result via __pow10.
+const POW10_SCALE = `
+    (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)))))))`
+
 export default (ctx) => {
   Object.assign(ctx.core.stdlibDeps, {
     __mkstr: ['__alloc'],
     __ftoa: ['__itoa', '__pow10', '__mkstr', '__static_str', '__toExp'],
     __toExp: ['__itoa', '__pow10', '__mkstr', '__static_str'],
-    __to_num: ['__char_at', '__str_byteLen', '__pow10', '__to_str'],
-    __to_bigint: ['__char_at', '__str_byteLen'],
+    __to_num: ['__char_at', '__str_byteLen', '__pow10', '__to_str', '__skipws', '__ptr_aux'],
+    __skipws: ['__char_at', '__strws'],
+    __to_bigint: ['__char_at', '__str_byteLen', '__num_to_bigint'],
     __parseInt: ['__char_at', '__str_byteLen'],
     __parseFloat: ['__char_at', '__str_byteLen', '__pow10', '__to_str'],
   })
@@ -34,6 +154,9 @@ export default (ctx) => {
   // so accumulated error stays at O(log n) ULPs.
   ctx.core.stdlib['__pow10'] = `(func $__pow10 (param $n i32) (result f64)
     (local $r f64)
+    ;; 10^309 already overflows f64 (max ~1.8e308); short-circuit so callers
+    ;; get Infinity rather than the truncated product of a 9-bit decomposition.
+    (if (i32.ge_s (local.get $n) (i32.const 309)) (then (return (f64.const inf))))
     (local.set $r (f64.const 1))
     (if (i32.and (local.get $n) (i32.const 1))
       (then (local.set $r (f64.mul (local.get $r) (f64.const 10)))))
@@ -106,16 +229,16 @@ export default (ctx) => {
     (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.
+    ;; __toExp clamps the digit count so its scaled mantissa fits an unsigned i32.
+    ;; Fewer digits than ECMAScript shortest-repr ideal, but valid output.
     (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)))))
+          (then (return (call $__toExp (local.get $val) (i32.const 8) (i32.const 1)))))
         (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)))))))
+          (then (return (call $__toExp (local.get $val) (i32.const 8) (i32.const 1)))))))
     (local.set $buf (call $__alloc (i32.const 40)))
     ;; Sign
     (if (f64.lt (local.get $val) (f64.const 0))
@@ -204,15 +327,22 @@ export default (ctx) => {
           (then (local.set $pos (i32.sub (local.get $pos) (i32.const 1)))))))
     (call $__mkstr (local.get $buf) (local.get $pos)))`
 
-  // __toExp(val: f64, prec: i32) → f64 (NaN-boxed string)
-  // Format: [-]d.ddd...e[+/-]dd — integer-based digit extraction
-  ctx.core.stdlib['__toExp'] = `(func $__toExp (param $val f64) (param $prec i32) (result f64)
+  // __toExp(val: f64, prec: i32, strip: i32) → f64 (NaN-boxed string)
+  // Format: [-]d.ddd...e[+/-]dd — integer-based digit extraction.
+  // strip=1 drops trailing fractional zeros (default ToString); strip=0 keeps
+  // the exact prec digits (toExponential/toPrecision need a fixed digit count).
+  ctx.core.stdlib['__toExp'] = `(func $__toExp (param $val f64) (param $prec i32) (param $strip i32) (result f64)
     (local $buf i32) (local $pos i32) (local $neg i32) (local $exp i32)
     (local $len i32) (local $i i32) (local $j i32)
     (local $mantissa f64) (local $scale f64)
     (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)))))
+    ;; The scaled mantissa is (prec+1) digits; cap prec at 8 so it stays below
+    ;; 2^32 (10^9 < 2^32 < 10^10), otherwise i32.trunc_f64_u below traps with
+    ;; "float unrepresentable in integer range" — e.g. 7.5e-151 normalizes to
+    ;; 7.5 and 7.5*10^9 already overflows an unsigned i32.
+    (if (i32.gt_s (local.get $prec) (i32.const 8)) (then (local.set $prec (i32.const 8))))
     (local.set $buf (call $__alloc (i32.const 32)))
     ;; Sign
     (if (f64.lt (local.get $val) (f64.const 0))
@@ -258,6 +388,16 @@ export default (ctx) => {
         (i32.store8 (i32.add (local.get $buf) (i32.add (local.get $pos) (i32.const 1))) (i32.const 46))
         (local.set $pos (i32.add (local.get $pos) (i32.add (local.get $len) (i32.const 1)))))
       (else (local.set $pos (i32.add (local.get $pos) (local.get $len)))))
+    ;; Shortest form: drop trailing zeros (and a bare '.') from the mantissa.
+    ;; The leading digit is always 1-9, so the walk-back stops at the '.' at worst.
+    (if (i32.and (local.get $strip) (i32.gt_s (local.get $prec) (i32.const 0)))
+      (then
+        (block $sz (loop $szl
+          (br_if $sz (i32.ne (i32.load8_u (i32.sub (i32.add (local.get $buf) (local.get $pos)) (i32.const 1))) (i32.const 48)))
+          (local.set $pos (i32.sub (local.get $pos) (i32.const 1)))
+          (br $szl)))
+        (if (i32.eq (i32.load8_u (i32.sub (i32.add (local.get $buf) (local.get $pos)) (i32.const 1))) (i32.const 46))
+          (then (local.set $pos (i32.sub (local.get $pos) (i32.const 1)))))))
     ;; Write 'e', sign, exponent
     (i32.store8 (i32.add (local.get $buf) (local.get $pos)) (i32.const 101))
     (local.set $pos (i32.add (local.get $pos) (i32.const 1)))
@@ -348,6 +488,17 @@ export default (ctx) => {
       ['f64.eq', ['local.get', `$${t}`], ['f64.trunc', ['local.get', `$${t}`]]]], 'i32')
   }
 
+  // Number.isSafeInteger(x): integer AND |x| ≤ 2^53 − 1.
+  ctx.core.emit['Number.isSafeInteger'] = (x) => {
+    const v = asF64(emit(x))
+    const t = temp('t')
+    return typed(['i32.and',
+      ['i32.and',
+        ['f64.eq', ['local.tee', `$${t}`, v], ['local.get', `$${t}`]],
+        ['f64.eq', ['local.get', `$${t}`], ['f64.trunc', ['local.get', `$${t}`]]]],
+      ['f64.le', ['f64.abs', ['local.get', `$${t}`]], ['f64.const', 9007199254740991]]], 'i32')
+  }
+
   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 $f f64)
@@ -403,17 +554,72 @@ 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))))`
 
+  // __strws(c: i32) → i32 — ECMA StrWhiteSpace predicate. Covers TAB..CR, SP,
+  // NBSP, BOM, LS/PS, and every Unicode Space_Separator. U+180E is *not*
+  // whitespace (declassified in Unicode 6.3).
+  ctx.core.stdlib['__strws'] = `(func $__strws (param $c i32) (result i32)
+    (i32.or
+      (i32.or
+        (i32.and (i32.ge_s (local.get $c) (i32.const 9)) (i32.le_s (local.get $c) (i32.const 13)))
+        (i32.or (i32.eq (local.get $c) (i32.const 32)) (i32.eq (local.get $c) (i32.const 160))))
+      (i32.or
+        (i32.or
+          (i32.eq (local.get $c) (i32.const 0x1680))
+          (i32.and (i32.ge_s (local.get $c) (i32.const 0x2000)) (i32.le_s (local.get $c) (i32.const 0x200a))))
+        (i32.or
+          (i32.or (i32.eq (local.get $c) (i32.const 0x2028)) (i32.eq (local.get $c) (i32.const 0x2029)))
+          (i32.or
+            (i32.or (i32.eq (local.get $c) (i32.const 0x202f)) (i32.eq (local.get $c) (i32.const 0x205f)))
+            (i32.or (i32.eq (local.get $c) (i32.const 0x3000)) (i32.eq (local.get $c) (i32.const 0xfeff))))))))`
+
+  // __skipws(v, i, len) → i32 — advance the byte index i past any run of
+  // StrWhiteSpace. Strings are UTF-8, so each step decodes one scalar: every
+  // whitespace code point is ≤ U+FEFF (≤ 3 bytes), and a 4-byte lead is never
+  // whitespace, so it (and any non-space scalar) ends the run.
+  ctx.core.stdlib['__skipws'] = `(func $__skipws (param $v i64) (param $i i32) (param $len i32) (result i32)
+    (local $b i32) (local $cp i32) (local $n i32) (local $sbase i32)
+    ${SBASE_INIT}
+    (block $done (loop $l
+      (br_if $done (i32.ge_s (local.get $i) (local.get $len)))
+      (local.set $b ${chAt('(local.get $i)')})
+      (if (i32.lt_u (local.get $b) (i32.const 0x80))
+        (then (local.set $cp (local.get $b)) (local.set $n (i32.const 1)))
+        (else (if (i32.lt_u (local.get $b) (i32.const 0xe0))
+          (then
+            (local.set $n (i32.const 2))
+            (local.set $cp (i32.or
+              (i32.shl (i32.and (local.get $b) (i32.const 0x1f)) (i32.const 6))
+              (i32.and (call $__char_at (local.get $v) (i32.add (local.get $i) (i32.const 1))) (i32.const 0x3f)))))
+          (else (if (i32.lt_u (local.get $b) (i32.const 0xf0))
+            (then
+              (local.set $n (i32.const 3))
+              (local.set $cp (i32.or (i32.or
+                (i32.shl (i32.and (local.get $b) (i32.const 0x0f)) (i32.const 12))
+                (i32.shl (i32.and (call $__char_at (local.get $v) (i32.add (local.get $i) (i32.const 1))) (i32.const 0x3f)) (i32.const 6)))
+                (i32.and (call $__char_at (local.get $v) (i32.add (local.get $i) (i32.const 2))) (i32.const 0x3f)))))
+            (else (return (local.get $i))))))))
+      (br_if $done (i32.eqz (call $__strws (local.get $cp))))
+      (local.set $i (i32.add (local.get $i) (local.get $n)))
+      (br $l)))
+    (local.get $i))`
+
   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 $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 $radix i32) (local $digit i32) (local $sbase i32)
+    (local $result f64) (local $f f64) (local $mant i64)
     (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)))
+    ;; ToNumber(Symbol) is a TypeError. A Symbol is an ATOM (type 0) with a user
+    ;; atom-id (>= 16); null/undefined returned above, and a bare NaN carries
+    ;; aux 0, so type==0 && aux>=16 uniquely identifies a Symbol.
+    (if (i32.and (i32.eqz (local.get $t))
+                 (i32.ge_u (call $__ptr_aux (local.get $v)) (i32.const 16)))
+      (then (throw $__jz_err (f64.const 0))))
     ;; 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}))
@@ -423,154 +629,160 @@ export default (ctx) => {
         (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
-      (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)))
-    (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)))
-      (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)))))
-    ;; 0x prefix → hex parse and early return
+    ${SBASE_INIT}
+    ;; Trim leading whitespace. An empty / all-whitespace string is +0.
+    (local.set $i (call $__skipws (local.get $v) (i32.const 0) (local.get $len)))
+    (if (i32.ge_s (local.get $i) (local.get $len)) (then (return (f64.const 0))))
+    ;; NonDecimalIntegerLiteral (0x / 0o / 0b). Per the grammar no sign may
+    ;; precede the prefix, so it is matched before sign consumption.
     (if (i32.and
-      (i32.le_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)))))
+      (i32.lt_s (i32.add (local.get $i) (i32.const 1)) (local.get $len))
+      (i32.eq ${chAt('(local.get $i)')} (i32.const 48)))
+      (then
+        (local.set $c ${chAt('(i32.add (local.get $i) (i32.const 1))')})
+        (if (i32.or (i32.eq (local.get $c) (i32.const 120)) (i32.eq (local.get $c) (i32.const 88)))
+          (then (local.set $radix (i32.const 16))))
+        (if (i32.or (i32.eq (local.get $c) (i32.const 111)) (i32.eq (local.get $c) (i32.const 79)))
+          (then (local.set $radix (i32.const 8))))
+        (if (i32.or (i32.eq (local.get $c) (i32.const 98)) (i32.eq (local.get $c) (i32.const 66)))
+          (then (local.set $radix (i32.const 2))))))
+    (if (local.get $radix)
       (then
         (local.set $i (i32.add (local.get $i) (i32.const 2)))
-        (block $hexDone (loop $hexLoop
-          (br_if $hexDone (i32.ge_s (local.get $i) (local.get $len)))
-          (local.set $c (call $__char_at (local.get $v) (local.get $i)))
-          (if (i32.and (i32.ge_s (local.get $c) (i32.const 48)) (i32.le_s (local.get $c) (i32.const 57)))
-            (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 48)))))
-              (local.set $seen (i32.const 1)) (local.set $i (i32.add (local.get $i) (i32.const 1))) (br $hexLoop)))
-          (if (i32.and (i32.ge_s (local.get $c) (i32.const 97)) (i32.le_s (local.get $c) (i32.const 102)))
-            (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 87)))))
-              (local.set $seen (i32.const 1)) (local.set $i (i32.add (local.get $i) (i32.const 1))) (br $hexLoop)))
-          (if (i32.and (i32.ge_s (local.get $c) (i32.const 65)) (i32.le_s (local.get $c) (i32.const 70)))
-            (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))))))
-    ;; 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)))
-      (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 $seen (i32.const 1))
-      (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)))))
+        (block $ndDone (loop $ndLoop
+          (br_if $ndDone (i32.ge_s (local.get $i) (local.get $len)))
+          (local.set $c ${chAt('(local.get $i)')})
+          ;; Decode digit; 99 sentinel for any non-[0-9a-fA-F] char so the
+          ;; unsigned ">= radix" test rejects it and any out-of-base digit.
+          (local.set $digit
+            (if (result i32) (i32.and (i32.ge_s (local.get $c) (i32.const 48)) (i32.le_s (local.get $c) (i32.const 57)))
+              (then (i32.sub (local.get $c) (i32.const 48)))
+              (else (if (result i32) (i32.and (i32.ge_s (local.get $c) (i32.const 97)) (i32.le_s (local.get $c) (i32.const 102)))
+                (then (i32.sub (local.get $c) (i32.const 87)))
+                (else (if (result i32) (i32.and (i32.ge_s (local.get $c) (i32.const 65)) (i32.le_s (local.get $c) (i32.const 70)))
+                  (then (i32.sub (local.get $c) (i32.const 55)))
+                  (else (i32.const 99))))))))
+          (br_if $ndDone (i32.ge_u (local.get $digit) (local.get $radix)))
+          (local.set $result (f64.add (f64.mul (local.get $result) (f64.convert_i32_s (local.get $radix))) (f64.convert_i32_s (local.get $digit))))
+          (local.set $seen (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
-              (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))
+          (br $ndLoop)))
+        ;; No digits, or trailing non-whitespace ("0b1.0", "0xg") → NaN.
+        (if (i32.eqz (local.get $seen)) (then (return (f64.const nan))))
+        (local.set $i (call $__skipws (local.get $v) (local.get $i) (local.get $len)))
+        (if (i32.lt_s (local.get $i) (local.get $len)) (then (return (f64.const nan))))
+        (return (local.get $result))))
+    ;; Sign (StrDecimalLiteral only).
+    (if (i32.eq ${chAt('(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.eq ${chAtSafe('(local.get $i)')} (i32.const 43))
+      (then (local.set $i (i32.add (local.get $i) (i32.const 1)))))
+    ;; "Infinity" — the only non-numeric token ToNumber accepts. The 8 letters
+    ;; are packed little-endian in one i64; any mismatch, short input, or
+    ;; trailing non-whitespace makes the whole string NaN.
+    (if (i32.eq ${chAtSafe('(local.get $i)')} (i32.const 73))
       (then
-        (if (i32.ge_s (local.get $wsEnd) (local.get $len))
-          (then (return (f64.const 0))))
+        (block $infBad
+          (local.set $digit (i32.const 0))
+          (loop $infl
+            (if (i32.lt_s (local.get $digit) (i32.const 8))
+              (then
+                (br_if $infBad (i32.ge_s (i32.add (local.get $i) (local.get $digit)) (local.get $len)))
+                (br_if $infBad (i32.ne
+                  ${chAt('(i32.add (local.get $i) (local.get $digit))')}
+                  (i32.and (i32.wrap_i64 (i64.shr_u (i64.const 0x7974696e69666e49)
+                    (i64.extend_i32_u (i32.shl (local.get $digit) (i32.const 3))))) (i32.const 255))))
+                (local.set $digit (i32.add (local.get $digit) (i32.const 1)))
+                (br $infl))))
+          (local.set $i (call $__skipws (local.get $v) (i32.add (local.get $i) (i32.const 8)) (local.get $len)))
+          (br_if $infBad (i32.lt_s (local.get $i) (local.get $len)))
+          (return (if (result f64) (local.get $neg) (then (f64.const -inf)) (else (f64.const inf)))))
         (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
-        (i32.eq (call $__char_at (local.get $v) (local.get $i)) (i32.const 101))
-        (i32.eq (call $__char_at (local.get $v) (local.get $i)) (i32.const 69))))
-      (then
-        (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 45)))
-          (then (local.set $expNeg (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)))))
-        (block $expDone (loop $expLoop
-          (br_if $expDone (i32.ge_s (local.get $i) (local.get $len)))
-          (local.set $c (call $__char_at (local.get $v) (local.get $i)))
-          (br_if $expDone
-            (i32.or
-              (i32.lt_s (local.get $c) (i32.const 48))
-              (i32.gt_s (local.get $c) (i32.const 57))))
-          (local.set $exp
-            (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 $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)))))))
+    ;; Decimal significand. Keep 18 significant decimal digits, track the
+    ;; base-10 exponent for skipped digits, and round once before pow10 scaling.
+    ${DEC_SIGNIFICAND}
+    ;; No digits — the literal was a bare sign or stray text ("abc", "+") → NaN.
+    ;; (Empty / all-whitespace strings already returned +0 above.)
+    ${FINISH_SIGNIFICAND}
+    ;; Scientific notation. 'e'/'E' commits to an ExponentPart — at least one
+    ;; digit must follow ("1e", "5e+" are NaN).
+    ${sciExponent(`(if (i32.eqz (local.get $expDigits)) (then (return (f64.const nan))))
+        (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)))))`)}
+    ;; Reject trailing non-whitespace ("5px", numeric separators "1_0", …).
+    (local.set $i (call $__skipws (local.get $v) (local.get $i) (local.get $len)))
+    (if (i32.lt_s (local.get $i) (local.get $len)) (then (return (f64.const nan))))
+    ${POW10_SCALE}
     (if (result f64) (local.get $neg) (then (f64.neg (local.get $result))) (else (local.get $result))))`
 
+  // NumberToBigInt: a RangeError unless n is an integral Number — finite and
+  // equal to its own truncation. NaN fails the f64.eq integrality test;
+  // ±Infinity fails the finite test. Non-integers (1.1, .5, …) fail integrality.
+  // The throw rides $__jz_err so `assert.throws`/try-catch observe it.
+  ctx.core.stdlib['__num_to_bigint'] = `(func $__num_to_bigint (param $n f64) (result f64)
+    (if (i32.eqz (i32.and
+          (f64.eq (local.get $n) (f64.trunc (local.get $n)))
+          (f64.lt (f64.abs (local.get $n)) (f64.const inf))))
+      (then (throw $__jz_err (f64.const 0))))
+    (f64.reinterpret_i64 (i64.trunc_sat_f64_s (local.get $n))))`
+
+  // StringToBigInt: strict — the whole trimmed string must be a single integer
+  // literal, else a SyntaxError ($__jz_err). Unlike parseInt this does NOT stop
+  // at the first bad char: `BigInt("10n")` and `BigInt("000 12")` throw. Empty
+  // or all-whitespace strings parse to 0n. Radix prefixes 0b/0o/0x (case-
+  // insensitive) are recognised only when no sign precedes them, so `-0x1`
+  // surfaces its `x` as an invalid decimal digit and throws, as the spec wants.
+  // (jz's BigInt is i64-backed, so values past 2^63 wrap — out of these tests'
+  // range.)
   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 $t i32) (local $len i32) (local $i i32) (local $end i32) (local $c i32)
+    (local $neg i32) (local $sign 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))))))
+      (then (return (call $__num_to_bigint (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)))
+    (local.set $end (local.get $len))
+    ;; Trim leading whitespace (any byte <= 32).
     (block $ws (loop $wsl
-      (br_if $ws (i32.ge_s (local.get $i) (local.get $len)))
+      (br_if $ws (i32.ge_s (local.get $i) (local.get $end)))
       (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)))))
+    ;; Trim trailing whitespace.
+    (block $te (loop $tel
+      (br_if $te (i32.le_s (local.get $end) (local.get $i)))
+      (br_if $te (i32.gt_s (call $__char_at (local.get $v) (i32.sub (local.get $end) (i32.const 1))) (i32.const 32)))
+      (local.set $end (i32.sub (local.get $end) (i32.const 1)))
+      (br $tel)))
+    ;; Empty / all-whitespace string → 0n.
+    (if (i32.ge_s (local.get $i) (local.get $end))
+      (then (return (f64.reinterpret_i64 (i64.const 0)))))
+    ;; Optional single leading sign — decimal literals only.
+    (local.set $c (call $__char_at (local.get $v) (local.get $i)))
+    (if (i32.eq (local.get $c) (i32.const 45))
+      (then (local.set $neg (i32.const 1)) (local.set $sign (i32.const 1)) (local.set $i (i32.add (local.get $i) (i32.const 1))))
+      (else (if (i32.eq (local.get $c) (i32.const 43))
+        (then (local.set $sign (i32.const 1)) (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)))))
+    ;; Radix prefix 0b/0o/0x (case-insensitive) — not allowed after a sign.
+    (if (i32.and (i32.eqz (local.get $sign))
+          (i32.and (i32.lt_s (i32.add (local.get $i) (i32.const 1)) (local.get $end))
+                   (i32.eq (call $__char_at (local.get $v) (local.get $i)) (i32.const 48))))
+      (then
+        (local.set $c (i32.or (call $__char_at (local.get $v) (i32.add (local.get $i) (i32.const 1))) (i32.const 0x20)))
+        (if (i32.eq (local.get $c) (i32.const 98)) (then (local.set $radix (i32.const 2))))
+        (if (i32.eq (local.get $c) (i32.const 111)) (then (local.set $radix (i32.const 8))))
+        (if (i32.eq (local.get $c) (i32.const 120)) (then (local.set $radix (i32.const 16))))
+        (if (i32.ne (local.get $radix) (i32.const 10))
+          (then (local.set $i (i32.add (local.get $i) (i32.const 2)))))))
+    ;; Strict scan — every remaining char must be a valid radix digit.
     (block $done (loop $lp
-      (br_if $done (i32.ge_s (local.get $i) (local.get $len)))
+      (br_if $done (i32.ge_s (local.get $i) (local.get $end)))
       (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)))
@@ -579,7 +791,8 @@ export default (ctx) => {
         (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))))
+      (if (i32.or (i32.lt_s (local.get $digit) (i32.const 0)) (i32.ge_s (local.get $digit) (local.get $radix)))
+        (then (throw $__jz_err (f64.const 0))))
       (local.set $seen (i32.const 1))
       (local.set $result
         (i64.add
@@ -587,7 +800,8 @@ export default (ctx) => {
           (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)))))
+    ;; A sign or radix prefix with no digits ("-", "0x", "0b") is a SyntaxError.
+    (if (i32.eqz (local.get $seen)) (then (throw $__jz_err (f64.const 0))))
     (f64.reinterpret_i64
       (if (result i64) (local.get $neg)
         (then (i64.sub (i64.const 0) (local.get $result)))
@@ -597,7 +811,7 @@ export default (ctx) => {
     (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 $expDigits i32)
     (local $dot i32) (local $sigDigits i32) (local $decExp i32) (local $dropped i32) (local $round i32)
-    (local $result f64) (local $f f64)
+    (local $result f64) (local $f f64) (local $mant i64) (local $sbase i32)
     (local.set $f (f64.reinterpret_i64 (local.get $v)))
     (if (f64.eq (local.get $f) (local.get $f)) (then (return (local.get $f))))
     (local.set $t (call $__ptr_type (local.get $v)))
@@ -611,99 +825,43 @@ export default (ctx) => {
         (if (i32.ne (local.get $t) (i32.const ${PTR.STRING}))
           (then (return (f64.const nan))))))
     (local.set $len (call $__str_byteLen (local.get $v)))
+    ${SBASE_INIT}
     ;; Skip leading whitespace.
     (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)))
+      (br_if $ws (i32.gt_s ${chAt('(local.get $i)')} (i32.const 32)))
       (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (br $wsl)))
     ;; 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)))
+    (if (i32.eq ${chAtSafe('(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)))
+    (if (i32.eq ${chAtSafe('(local.get $i)')} (i32.const 43))
       (then (local.set $i (i32.add (local.get $i) (i32.const 1)))))
-    ;; Decimal significand. Keep 17 significant decimal digits, track the
+    ;; Decimal significand. Keep 18 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)))
-      (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 $seen (i32.const 1))
-      (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
-              (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)))
-    (if (i32.eqz (local.get $seen)) (then (return (f64.const nan))))
-    (if (local.get $round) (then (local.set $result (f64.add (local.get $result) (f64.const 1)))))
+    ${DEC_SIGNIFICAND}
+    ${FINISH_SIGNIFICAND}
     ;; Scientific notation.
-    (if (i32.and (i32.lt_s (local.get $i) (local.get $len))
-      (i32.or
-        (i32.eq (call $__char_at (local.get $v) (local.get $i)) (i32.const 101))
-        (i32.eq (call $__char_at (local.get $v) (local.get $i)) (i32.const 69))))
-      (then
-        (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 45)))
-          (then (local.set $expNeg (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)))))
-        (block $expDone (loop $expLoop
-          (br_if $expDone (i32.ge_s (local.get $i) (local.get $len)))
-          (local.set $c (call $__char_at (local.get $v) (local.get $i)))
-          (br_if $expDone
-            (i32.or
-              (i32.lt_s (local.get $c) (i32.const 48))
-              (i32.gt_s (local.get $c) (i32.const 57))))
-          (local.set $exp
-            (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 $expDigits)
+    ${sciExponent(`(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)))))))
+              (else (local.set $decExp (i32.add (local.get $decExp) (local.get $exp)))))))`)}
+    ${POW10_SCALE}
     (if (result f64) (local.get $neg) (then (f64.neg (local.get $result))) (else (local.get $result))))`
 
+  // ToString(arg) for the string-input builtins. A statically-known boolean must
+  // render as "true"/"false" (spec step 1: ToString) before parsing — otherwise
+  // its 0/1 carrier bits are fed to the parser as if a string pointer. Other types
+  // (string already, number/object ToPrimitive) stay out of scope per the runner.
+  const strInputI64 = (x) => valTypeOf(x) === VAL.BOOL ? asI64(emitBoolStr(x)) : asI64(emit(x))
+
   ctx.core.emit['Number.parseInt'] = (x, radix) => {
     needParseInt()
-    return typed(['call', '$__parseInt', asI64(emit(x)), radix ? asI32(emit(radix)) : ['i32.const', 0]], 'f64')
+    // Radix is coerced ToNumber then ToInt32 (modular wrap; NaN/±∞→0) per spec —
+    // a raw trunc would turn a string radix into garbage and Infinity into maxint.
+    const radixIR = radix == null ? ['i32.const', 0] : toI32(toNumF64(radix, emit(radix)))
+    return typed(['call', '$__parseInt', strInputI64(x), radixIR], 'f64')
   }
   ctx.core.emit['parseInt'] = ctx.core.emit['Number.parseInt']
   const addImportOnce = (ctx, mod, name, fn) => {
@@ -718,10 +876,10 @@ export default (ctx) => {
   ctx.core.emit['Number.parseFloat'] = (x) => {
     if (ctx.transform.host === 'wasi') {
       inc('__parseFloat')
-      return typed(['call', '$__parseFloat', asI64(emit(x))], 'f64')
+      return typed(['call', '$__parseFloat', strInputI64(x)], 'f64')
     }
     needParseFloat()
-    return typed(['call', '$__parseFloat', asI64(emit(x))], 'f64')
+    return typed(['call', '$__parseFloat', strInputI64(x)], 'f64')
   }
   ctx.core.emit['parseFloat'] = ctx.core.emit['Number.parseFloat']
 
@@ -747,7 +905,7 @@ export default (ctx) => {
 
   ctx.core.emit['.number:toExponential'] = (n, d) => {
     inc('__toExp')
-    return typed(['call', '$__toExp', asF64(emit(n)), asI32(emit(d || [, 0]))], 'f64')
+    return typed(['call', '$__toExp', asF64(emit(n)), asI32(emit(d || [, 0])), ['i32.const', 0]], 'f64')
   }
 
   ctx.core.emit['.number:toPrecision'] = (n, p) => {
@@ -774,7 +932,7 @@ export default (ctx) => {
         ['i32.or',
           ['i32.lt_s', ['local.get', `$${exp}`], ['i32.const', -6]],
           ['i32.ge_s', ['local.get', `$${exp}`], ['local.get', `$${pr}`]]],
-        ['then', ['call', '$__toExp', ['local.get', `$${val}`], ['i32.sub', ['local.get', `$${pr}`], ['i32.const', 1]]]],
+        ['then', ['call', '$__toExp', ['local.get', `$${val}`], ['i32.sub', ['local.get', `$${pr}`], ['i32.const', 1]], ['i32.const', 0]]],
         ['else', ['call', '$__ftoa', ['local.get', `$${val}`],
           ['i32.sub', ['i32.sub', ['local.get', `$${pr}`], ['i32.const', 1]], ['local.get', `$${exp}`]],
           ['i32.const', 1]]]]], 'f64')
@@ -792,6 +950,9 @@ export default (ctx) => {
   // For number input: truncate directly. For string / unknown: first coerce via __to_num
   // (handles both decimal and hex string parse), then truncate.
   ctx.core.emit['BigInt'] = (x) => {
+    // Every BigInt() path can fault: a non-integral Number is a RangeError and
+    // a malformed String is a SyntaxError, both raised via $__jz_err.
+    ctx.runtime.throws = true
     const vt = valTypeOf(x)
     if (vt === VAL.BIGINT) {
       if (typeof x === 'bigint' || (typeof x === 'string' && !isReassigned(ctx.func.body, x))) return emit(x)
@@ -806,8 +967,10 @@ export default (ctx) => {
             ['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')
+    if (vt === VAL.NUMBER) {
+      inc('__num_to_bigint')
+      return typed(['call', '$__num_to_bigint', asF64(emit(x))], 'f64')
+    }
     inc('__to_bigint')
     return typed(['call', '$__to_bigint', asI64(emit(x))], 'f64')
   }