jz 0.5.1 → 0.7.0

package/module/number.js

@@ -9,10 +9,13 @@
  * @module number
  */
 
-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'
+import { typed, asF64, asI32, asI64, toI32, toNumF64, NULL_NAN, UNDEF_NAN, FALSE_NAN, TRUE_NAN, temp, tempI32, tempI64, ptrTypeEq, truthyIR } from '../src/ir.js'
+import { ssoBitI64Hex } from '../layout.js'
+import { emit, bool, deps, reg, hostImport } from '../src/bridge.js'
+import { isReassigned } from '../src/ast.js'
+import { valTypeOf } from '../src/kind.js'
+import { VAL } from '../src/reps.js'
+import { inc, PTR, LAYOUT } from '../src/ctx.js'
 
 // ─── Shared decimal-number parsing fragments ────────────────────────────────
 // `__to_num` (Number coercion) and `__parseFloat` both scan a StrDecimalLiteral
@@ -34,9 +37,23 @@ import { inc, PTR } from '../src/ctx.js'
 // 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 SSO_BIT_I64 = ssoBitI64Hex()
 const SBASE_INIT = '(local.set $sbase (i32.wrap_i64 (i64.and (local.get $v) (i64.const 4294967295))))'
+
+/** In-place byte reversal of buf[i..j] (WAT fragment). __itoa/__radix_str emit the
+ *  least-significant digit first, then flip the run. Caller pre-sets `j` to the last
+ *  index and leaves `i` at 0; `tmp` is scratch. Labels $rev/$revl are block-local. */
+const reverseBytesWat = (buf = '$buf', i = '$i', j = '$j', tmp = '$tmp') =>
+  `(block $rev (loop $revl
+      (br_if $rev (i32.ge_s (local.get ${i}) (local.get ${j})))
+      (local.set ${tmp} (i32.load8_u (i32.add (local.get ${buf}) (local.get ${i}))))
+      (i32.store8 (i32.add (local.get ${buf}) (local.get ${i})) (i32.load8_u (i32.add (local.get ${buf}) (local.get ${j}))))
+      (i32.store8 (i32.add (local.get ${buf}) (local.get ${j})) (local.get ${tmp}))
+      (local.set ${i} (i32.add (local.get ${i}) (i32.const 1)))
+      (local.set ${j} (i32.sub (local.get ${j}) (i32.const 1)))
+      (br $revl)))`
 const chAt = idx => `(if (result i32)
-        (i64.eqz (i64.and (local.get $v) (i64.const 0x0000400000000000)))
+        (i64.eqz (i64.and (local.get $v) (i64.const ${SSO_BIT_I64})))
         (then (i32.load8_u (i32.add (local.get $sbase) ${idx})))
         (else (call $__char_at (local.get $v) ${idx})))`
 
@@ -135,10 +152,13 @@ const POW10_SCALE = `
       (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, {
+  deps({
     __mkstr: ['__alloc'],
     __ftoa: ['__itoa', '__pow10', '__mkstr', '__static_str', '__toExp'],
+    __i32_to_str: ['__itoa', '__mkstr'],
     __toExp: ['__itoa', '__pow10', '__mkstr', '__static_str'],
+    __radix_str: ['__mkstr'],
+    __num_radix: ['__ftoa', '__mkstr'],
     __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'],
@@ -193,22 +213,151 @@ export default (ctx) => {
       (br $l)))
     ;; Reverse
     (local.set $j (i32.sub (local.get $len) (i32.const 1)))
-    (block $rd (loop $rl
-      (br_if $rd (i32.ge_s (local.get $i) (local.get $j)))
+    ${reverseBytesWat()}
+    (local.get $len))`
+
+  // __i32_to_str(val: i32) → f64 (NaN-boxed string) — ToString for a value the
+  // compiler proved is a signed i32. The whole point is to bypass __ftoa's float
+  // machinery (shortest-repr search, __toExp, __pow10): a known integer renders with
+  // just __itoa over its magnitude plus a sign byte. Lets `"id " + (n|0)` and integer
+  // templates skip the ~2 KB float formatter the generic ToString hard-pulls.
+  ctx.core.stdlib['__i32_to_str'] = `(func $__i32_to_str (param $val i32) (result f64)
+    (local $buf i32) (local $len i32) (local $u i32)
+    (local.set $buf (call $__alloc (i32.const 12)))
+    (if (i32.lt_s (local.get $val) (i32.const 0))
+      (then
+        (i32.store8 (local.get $buf) (i32.const 45))   ;; '-'
+        ;; magnitude as unsigned: negate via 0 - val (INT_MIN maps to itself, read u below)
+        (local.set $u (i32.sub (i32.const 0) (local.get $val)))
+        (local.set $len (call $__itoa (local.get $u) (i32.add (local.get $buf) (i32.const 1))))
+        (return (call $__mkstr (local.get $buf) (i32.add (local.get $len) (i32.const 1)))))
+      (else
+        (local.set $len (call $__itoa (local.get $val) (local.get $buf)))
+        (return (call $__mkstr (local.get $buf) (local.get $len)))))
+    (f64.const 0))`
+
+  // __radix_str(val: i64, radix: i32) → f64 (NaN-boxed string)
+  // Signed integer → radix string for BigInt.prototype.toString(radix). Digits go
+  // 0-9 then a-z (lowercase, per spec); magnitude is taken unsigned so i64.MIN
+  // (whose two's-complement negation is itself) formats correctly via div_u/rem_u.
+  ctx.core.stdlib['__radix_str'] = `(func $__radix_str (param $val i64) (param $radix i32) (result f64)
+    (local $buf i32) (local $pos i32) (local $neg i32) (local $mag i64) (local $r i64)
+    (local $dg i32) (local $i i32) (local $j i32) (local $tmp i32)
+    (local.set $buf (call $__alloc (i32.const 72)))
+    (local.set $r (i64.extend_i32_s (local.get $radix)))
+    (if (i64.eqz (local.get $val))
+      (then (i32.store8 (local.get $buf) (i32.const 48)) (return (call $__mkstr (local.get $buf) (i32.const 1)))))
+    (local.set $mag (local.get $val))
+    (if (i64.lt_s (local.get $val) (i64.const 0))
+      (then (local.set $neg (i32.const 1)) (local.set $mag (i64.sub (i64.const 0) (local.get $val)))))
+    (block $mb (loop $ml
+      (br_if $mb (i64.eqz (local.get $mag)))
+      (local.set $dg (i32.wrap_i64 (i64.rem_u (local.get $mag) (local.get $r))))
+      (i32.store8 (i32.add (local.get $buf) (local.get $pos))
+        (select (i32.add (local.get $dg) (i32.const 48)) (i32.add (local.get $dg) (i32.const 87)) (i32.lt_s (local.get $dg) (i32.const 10))))
+      (local.set $mag (i64.div_u (local.get $mag) (local.get $r)))
+      (local.set $pos (i32.add (local.get $pos) (i32.const 1)))
+      (br $ml)))
+    (if (local.get $neg)
+      (then (i32.store8 (i32.add (local.get $buf) (local.get $pos)) (i32.const 45))
+        (local.set $pos (i32.add (local.get $pos) (i32.const 1)))))
+    (local.set $j (i32.sub (local.get $pos) (i32.const 1)))
+    ${reverseBytesWat()}
+    (call $__mkstr (local.get $buf) (local.get $pos)))`
+
+  // __num_radix(val: f64, radix: i32) → f64 (NaN-boxed string)
+  // Number.prototype.toString(radix) for radix != 10. Non-finite values defer to
+  // __ftoa ("NaN"/"Infinity"/"-Infinity"). Integer part uses exact i64 division
+  // (magnitude bounded by jz's i64 BigInt domain); the fraction multiplies out in
+  // f64, capped at 100 digits (radix fractions are implementation-defined precision).
+  //
+  // Per 21.1.3.6: radix must be an integer in [2, 36] — otherwise RangeError.
+  // The check sits at the canonical entry point so the const-radix fold path
+  // (which still calls here for any non-10 constant) and the dynamic-radix
+  // branch are validated uniformly. `(throw $__jz_err …)` is picked up by
+  // ensureThrowRuntime via stdlib scan, so callers do not need to flag throws.
+  ctx.core.stdlib['__num_radix'] = `(func $__num_radix (param $val f64) (param $radix i32) (result f64)
+    (local $buf i32) (local $pos i32) (local $neg i32) (local $iv i64) (local $r i64) (local $rf f64)
+    (local $int f64) (local $frac f64) (local $dg i32) (local $i i32) (local $j i32) (local $tmp i32) (local $fn i32) (local $rv f64)
+    (if (i32.or (i32.lt_s (local.get $radix) (i32.const 2)) (i32.gt_s (local.get $radix) (i32.const 36)))
+      (then (throw $__jz_err (f64.const 0))))
+    (if (i32.or (f64.ne (local.get $val) (local.get $val)) (f64.eq (f64.abs (local.get $val)) (f64.const inf)))
+      (then (return (call $__ftoa (local.get $val) (i32.const 0) (i32.const 0)))))
+    (local.set $buf (call $__alloc (i32.const 180)))
+    (local.set $r (i64.extend_i32_s (local.get $radix)))
+    (local.set $rf (f64.convert_i32_s (local.get $radix)))
+    (if (f64.lt (local.get $val) (f64.const 0))
+      (then (local.set $neg (i32.const 1)) (local.set $val (f64.neg (local.get $val)))))
+    (local.set $int (f64.floor (local.get $val)))
+    (local.set $frac (f64.sub (local.get $val) (local.get $int)))
+    (local.set $iv (i64.trunc_sat_f64_u (local.get $int)))
+    (if (i64.eqz (local.get $iv))
+      (then (i32.store8 (local.get $buf) (i32.const 48)) (local.set $pos (i32.const 1)))
+      (else
+        (block $ib (loop $il
+          (br_if $ib (i64.eqz (local.get $iv)))
+          (local.set $dg (i32.wrap_i64 (i64.rem_u (local.get $iv) (local.get $r))))
+          (i32.store8 (i32.add (local.get $buf) (local.get $pos))
+            (select (i32.add (local.get $dg) (i32.const 48)) (i32.add (local.get $dg) (i32.const 87)) (i32.lt_s (local.get $dg) (i32.const 10))))
+          (local.set $iv (i64.div_u (local.get $iv) (local.get $r)))
+          (local.set $pos (i32.add (local.get $pos) (i32.const 1)))
+          (br $il)))))
+    (if (local.get $neg)
+      (then (i32.store8 (i32.add (local.get $buf) (local.get $pos)) (i32.const 45))
+        (local.set $pos (i32.add (local.get $pos) (i32.const 1)))))
+    (local.set $j (i32.sub (local.get $pos) (i32.const 1)))
+    (block $rb (loop $rl
+      (br_if $rb (i32.ge_s (local.get $i) (local.get $j)))
       (local.set $tmp (i32.load8_u (i32.add (local.get $buf) (local.get $i))))
-      (i32.store8 (i32.add (local.get $buf) (local.get $i))
-        (i32.load8_u (i32.add (local.get $buf) (local.get $j))))
+      (i32.store8 (i32.add (local.get $buf) (local.get $i)) (i32.load8_u (i32.add (local.get $buf) (local.get $j))))
       (i32.store8 (i32.add (local.get $buf) (local.get $j)) (local.get $tmp))
       (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (local.set $j (i32.sub (local.get $j) (i32.const 1)))
       (br $rl)))
-    (local.get $len))`
+    (if (f64.gt (local.get $frac) (f64.const 0))
+      (then
+        (i32.store8 (i32.add (local.get $buf) (local.get $pos)) (i32.const 46))
+        (local.set $pos (i32.add (local.get $pos) (i32.const 1)))
+        (block $fb (loop $fl
+          (br_if $fb (f64.le (local.get $frac) (f64.const 0)))
+          (br_if $fb (i32.ge_s (local.get $fn) (i32.const 100)))
+          (local.set $frac (f64.mul (local.get $frac) (local.get $rf)))
+          (local.set $dg (i32.trunc_f64_s (f64.floor (local.get $frac))))
+          (i32.store8 (i32.add (local.get $buf) (local.get $pos))
+            (select (i32.add (local.get $dg) (i32.const 48)) (i32.add (local.get $dg) (i32.const 87)) (i32.lt_s (local.get $dg) (i32.const 10))))
+          (local.set $frac (f64.sub (local.get $frac) (f64.floor (local.get $frac))))
+          (local.set $pos (i32.add (local.get $pos) (i32.const 1)))
+          (local.set $fn (i32.add (local.get $fn) (i32.const 1)))
+          (br $fl)))))
+    ${!ctx.memory.shared ? `
+    ;; When __mkstr packed an SSO result it allocated nothing, so the digit scratch
+    ;; ($buf, at heap top) is dead — reclaim it so a heap-top accumulator stays on
+    ;; top and \`s += n.toString(r)\` bump-extends instead of reallocating (O(n)).
+    (local.set $rv (call $__mkstr (local.get $buf) (local.get $pos)))
+    (if (i32.and (i32.wrap_i64 (i64.shr_u (i64.reinterpret_f64 (local.get $rv)) (i64.const ${LAYOUT.AUX_SHIFT}))) (i32.const ${LAYOUT.SSO_BIT}))
+      (then (global.set $__heap (local.get $buf))))
+    (local.get $rv)` : `(call $__mkstr (local.get $buf) (local.get $pos))`})`
 
   // __mkstr(buf: i32, len: i32) → f64 — copy scratch buffer to heap string.
   // Hot (~60M calls in watr self-host via __ftoa). bulk memory.copy is ~10× faster than
   // a hand-rolled byte loop (wasm2c lowers it to memcpy under PGO+LTO).
   ctx.core.stdlib['__mkstr'] = `(func $__mkstr (param $buf i32) (param $len i32) (result f64)
-    (local $off i32)
+    (local $off i32) (local $i i32) (local $packed i32) (local $b i32)
+    ;; SSO fast path: ≤4 ASCII bytes pack into the pointer with no allocation, so a
+    ;; number-format result doesn't displace a heap-top accumulator — keeping the
+    ;; canonical \`s += n.toString(r)\` builder O(n) via the bump-extend path.
+    (if (i32.le_u (local.get $len) (i32.const 4))
+      (then
+        (block $heap
+          (loop $pk
+            (if (i32.lt_u (local.get $i) (local.get $len))
+              (then
+                (local.set $b (i32.load8_u (i32.add (local.get $buf) (local.get $i))))
+                (br_if $heap (i32.ge_u (local.get $b) (i32.const 0x80)))
+                (local.set $packed (i32.or (local.get $packed) (i32.shl (local.get $b) (i32.shl (local.get $i) (i32.const 3)))))
+                (local.set $i (i32.add (local.get $i) (i32.const 1)))
+                (br $pk))))
+          (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.or (i32.const ${LAYOUT.SSO_BIT}) (local.get $len)) (local.get $packed))))))
     (local.set $off (call $__alloc (i32.add (i32.const 4) (local.get $len))))
     (i32.store (local.get $off) (local.get $len))
     (local.set $off (i32.add (local.get $off) (i32.const 4)))
@@ -251,7 +400,12 @@ export default (ctx) => {
     ;; Default mode: auto-select precision (up to 9 digits, must fit i32 when scaled)
     (if (i32.eqz (local.get $mode))
       (then (local.set $prec (i32.const 9))))
-    ;; Round and scale to integer: scaled = nearest(val * 10^prec)
+    ;; Round and scale to integer: scaled = nearest(val * 10^prec).
+    ;; NOTE: toFixed/toPrecision round ties-to-even here (f64.nearest), which differs from
+    ;; JS's round-half-away-from-zero on exact halves like (2.5).toFixed(0) → '2' vs '3'.
+    ;; A naive floor(x+0.5) "fixes" those but breaks values like 1.45 (whose ×10 rounds up
+    ;; to 14.5 in f64, giving '1.5' vs JS '1.4'); bit-exact toFixed needs the exact-decimal
+    ;; algorithm. Documented as a known difference rather than trading one error for another.
     (local.set $scale (call $__pow10 (local.get $prec)))
     (local.set $scaled (f64.nearest (f64.mul (local.get $val) (local.get $scale))))
     ;; If scaled doesn't fit i32, reduce precision until it does (min prec=0)
@@ -267,19 +421,40 @@ export default (ctx) => {
       (then
         (local.set $int (i32.trunc_f64_u (f64.div (local.get $scaled) (local.get $scale))))
         (local.set $frac (i32.trunc_f64_u (f64.sub (local.get $scaled)
-          (f64.mul (f64.convert_i32_u (local.get $int)) (local.get $scale))))))
+          (f64.mul (f64.convert_i32_u (local.get $int)) (local.get $scale)))))
+        ;; Default mode, fit loop reduced prec to 0: the rounded integer is ready, but the
+        ;; original val may still have a fractional part that was discarded.  Recover it:
+        ;; frac_f = val - trunc(val); since frac_f ∈ [0,1), frac_f*10^9 < 10^9 < 2^31 — safe.
+        (if (i32.and (i32.eqz (local.get $mode)) (i32.eqz (local.get $prec)))
+          (then
+            (local.set $abs (f64.sub (local.get $val) (f64.trunc (local.get $val))))
+            (if (f64.gt (local.get $abs) (f64.const 0))
+              (then
+                ;; $int was taken from f64.nearest(val), which rounds .5+ UP (999999999.9 → 1e9),
+                ;; but $abs/$frac below derive from f64.trunc(val). Re-derive $int from the same
+                ;; trunc so integer and fraction agree — else String(999999999.9) → "1000000000.9".
+                (local.set $int (i32.trunc_f64_u (f64.trunc (local.get $val))))
+                (local.set $prec (i32.const 9))
+                (local.set $scale (call $__pow10 (i32.const 9)))
+                ;; round: trunc_u(x+0.5) == floor(x+0.5) for the positive frac scale
+                (local.set $frac (i32.trunc_f64_u (f64.add
+                  (f64.mul (local.get $abs) (f64.const 1000000000))
+                  (f64.const 0.5)))))))))
       (else
         (local.set $int (i32.const 0))
         (local.set $frac (i32.const 0))
         (local.set $prec (i32.const 0))
         (local.set $abs (f64.trunc (local.get $val)))
-        ;; Write large integer digits reversed
+        ;; Write large integer digits reversed.
+        ;; Clamp digit to [0,9]: f64 precision loss for large values can make the naive
+        ;; subtraction (abs - trunc(abs/10)*10) go slightly negative → i32.trunc_f64_u trap.
         (local.set $ilen (local.get $pos))
         (block $ld (loop $ll
           (br_if $ld (f64.lt (local.get $abs) (f64.const 1)))
           (i32.store8 (i32.add (local.get $buf) (local.get $pos))
-            (i32.add (i32.const 48) (i32.trunc_f64_u (f64.sub (local.get $abs)
-              (f64.mul (f64.trunc (f64.div (local.get $abs) (f64.const 10))) (f64.const 10))))))
+            (i32.add (i32.const 48) (i32.trunc_f64_u (f64.max (f64.const 0) (f64.min (f64.const 9)
+              (f64.nearest (f64.sub (local.get $abs)
+                (f64.mul (f64.trunc (f64.div (local.get $abs) (f64.const 10))) (f64.const 10)))))))))
           (local.set $abs (f64.trunc (f64.div (local.get $abs) (f64.const 10))))
           (local.set $pos (i32.add (local.get $pos) (i32.const 1)))
           (br $ll)))
@@ -294,6 +469,43 @@ export default (ctx) => {
           (local.set $i (i32.add (local.get $i) (i32.const 1)))
           (local.set $j (i32.sub (local.get $j) (i32.const 1)))
           (br $rl)))
+        ;; Default mode: emit fractional part if val has one (large-int path skipped it before).
+        ;; frac_f = val - trunc(val); since frac_f ∈ [0,1), frac_f*10^9 < 10^9 < 2^31 — safe.
+        (if (i32.eqz (local.get $mode))
+          (then
+            (local.set $abs (f64.sub (local.get $val) (f64.trunc (local.get $val))))
+            (if (f64.gt (local.get $abs) (f64.const 0))
+              (then
+                ;; round: trunc_u(x+0.5) == floor(x+0.5) for the positive frac scale
+                (local.set $frac (i32.trunc_f64_u (f64.add
+                  (f64.mul (local.get $abs) (f64.const 1000000000))
+                  (f64.const 0.5))))
+                (i32.store8 (i32.add (local.get $buf) (local.get $pos)) (i32.const 46))
+                (local.set $pos (i32.add (local.get $pos) (i32.const 1)))
+                ;; 9 fractional digits from $frac, high-to-low
+                (local.set $i (i32.const 8))
+                (block $fd2 (loop $fl2
+                  (br_if $fd2 (i32.lt_s (local.get $i) (i32.const 0)))
+                  (local.set $j (i32.div_u (local.get $frac) (i32.trunc_f64_u (call $__pow10 (local.get $i)))))
+                  (i32.store8 (i32.add (local.get $buf) (local.get $pos))
+                    (i32.add (i32.const 48) (i32.rem_u (local.get $j) (i32.const 10))))
+                  (local.set $pos (i32.add (local.get $pos) (i32.const 1)))
+                  (local.set $i (i32.sub (local.get $i) (i32.const 1)))
+                  (br $fl2)))
+                ;; Strip trailing zeros
+                (block $sz2 (loop $sl2
+                  (br_if $sz2 (i32.le_s (local.get $pos) (i32.const 0)))
+                  (br_if $sz2 (i32.ne
+                    (i32.load8_u (i32.add (local.get $buf) (i32.sub (local.get $pos) (i32.const 1))))
+                    (i32.const 48)))
+                  (local.set $pos (i32.sub (local.get $pos) (i32.const 1)))
+                  (br $sl2)))
+                ;; Strip trailing dot
+                (if (i32.and (i32.gt_s (local.get $pos) (i32.const 0))
+                      (i32.eq
+                        (i32.load8_u (i32.add (local.get $buf) (i32.sub (local.get $pos) (i32.const 1))))
+                        (i32.const 46)))
+                  (then (local.set $pos (i32.sub (local.get $pos) (i32.const 1)))))))))
         (return (call $__mkstr (local.get $buf) (local.get $pos)))))
     ;; Write integer part
     (local.set $ilen (call $__itoa (local.get $int) (i32.add (local.get $buf) (local.get $pos))))
@@ -365,7 +577,7 @@ export default (ctx) => {
           (local.set $val (f64.mul (local.get $val) (f64.const 10)))
           (local.set $exp (i32.sub (local.get $exp) (i32.const 1)))
           (br $l2)))))
-    ;; Scale to integer mantissa: nearest(val * 10^prec)
+    ;; Scale to integer mantissa: nearest(val * 10^prec). Ties-to-even (see __ftoa note).
     (local.set $scale (call $__pow10 (local.get $prec)))
     (local.set $mantissa (f64.nearest (f64.mul (local.get $val) (local.get $scale))))
     ;; Rounding overflow (e.g. 9.95 → 1000 when prec=1, scale=10)
@@ -441,7 +653,7 @@ export default (ctx) => {
   ctx.core.emit['Number.MIN_VALUE'] = () => typed(['f64.const', 5e-324], 'f64')
   ctx.core.emit['Number.POSITIVE_INFINITY'] = () => typed(['f64.const', Infinity], 'f64')
   ctx.core.emit['Number.NEGATIVE_INFINITY'] = () => typed(['f64.const', -Infinity], 'f64')
-  ctx.core.emit['Number.NaN'] = () => typed(['f64.const', NaN], 'f64')
+  ctx.core.emit['Number.NaN'] = () => typed(['f64.const', 'nan'], 'f64')  // `nan` token, not raw NaN (survives self-host IR marshalling — see emitNum)
 
   // === Number static methods ===
 
@@ -501,7 +713,8 @@ export default (ctx) => {
 
   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)
+    (local $digit i32) (local $seen i32) (local $f f64)
+    (local $acc i64) (local $rad i64) (local $ovf i32) (local $exp i32) (local $sticky i32) (local $k i32) (local $e i32)
     (local.set $f (f64.reinterpret_i64 (local.get $str)))
     ;; If input is a number, just truncate
     (if (f64.eq (local.get $f) (local.get $f)) (then (return (f64.trunc (local.get $f)))))
@@ -524,16 +737,21 @@ export default (ctx) => {
     (if (i32.and (i32.lt_s (local.get $i) (local.get $len))
       (i32.eq (call $__char_at (local.get $str) (local.get $i)) (i32.const 43)))
       (then (local.set $i (i32.add (local.get $i) (i32.const 1)))))
-    ;; 0x prefix → radix 16
-    (if (i32.and (i32.eqz (local.get $radix))
+    ;; 0x prefix → radix 16 (stripped when radix is unspecified OR explicitly 16, per JS)
+    (if (i32.and (i32.or (i32.eqz (local.get $radix)) (i32.eq (local.get $radix) (i32.const 16)))
       (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 $str) (local.get $i)) (i32.const 48))
           (i32.or (i32.eq (call $__char_at (local.get $str) (i32.add (local.get $i) (i32.const 1))) (i32.const 120))
             (i32.eq (call $__char_at (local.get $str) (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)))))
     (if (i32.eqz (local.get $radix)) (then (local.set $radix (i32.const 10))))
-    ;; Parse digits
-    (local.set $result (f64.const 0))
+    ;; Power-of-two radix → exact bit width per digit (lets the >2^64 path round once).
+    (if (i32.eqz (i32.and (local.get $radix) (i32.sub (local.get $radix) (i32.const 1))))
+      (then (local.set $k (i32.ctz (local.get $radix)))))
+    (local.set $rad (i64.extend_i32_u (local.get $radix)))
+    ;; Parse digits — accumulate EXACTLY in u64 (round-once via convert at the end, matching JS for
+    ;; any value < 2^64). On u64 overflow, freeze the high bits and track the dropped magnitude
+    ;; (exp) + a sticky bit so the final round-to-f64 still matches round-once for power-of-two radix.
     (block $done (loop $lp
       (br_if $done (i32.ge_s (local.get $i) (local.get $len)))
       (local.set $c (call $__char_at (local.get $str) (local.get $i)))
@@ -547,12 +765,41 @@ export default (ctx) => {
         (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 (f64.add (f64.mul (local.get $result) (f64.convert_i32_s (local.get $radix))) (f64.convert_i32_s (local.get $digit))))
+      (if (i32.eqz (local.get $ovf))
+        (then
+          ;; acc*radix + digit, exact while it stays within unsigned 64-bit
+          (if (i64.le_u (local.get $acc) (i64.div_u (i64.sub (i64.const -1) (i64.extend_i32_u (local.get $digit))) (local.get $rad)))
+            (then (local.set $acc (i64.add (i64.mul (local.get $acc) (local.get $rad)) (i64.extend_i32_u (local.get $digit)))))
+            (else
+              (local.set $ovf (i32.const 1))
+              ;; non-power-of-two radix: continue round-each in f64 from the exact seed (keeps magnitude)
+              (if (i32.eqz (local.get $k)) (then (local.set $f (f64.convert_i64_u (local.get $acc)))))))))
+      (if (local.get $ovf)
+        (then
+          (if (local.get $k)
+            (then  ;; power-of-two: this digit and all later ones sit below the frozen high bits
+              (local.set $exp (i32.add (local.get $exp) (local.get $k)))
+              (if (local.get $digit) (then (local.set $sticky (i32.const 1)))))
+            (else  ;; other radix: round-each f64 — ≤1 ULP past 2^53, but only for >2^64 values
+              (local.set $f (f64.add (f64.mul (local.get $f) (f64.convert_i32_u (local.get $radix))) (f64.convert_i32_u (local.get $digit))))))))
       (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (br $lp)))
     ;; No digits consumed → NaN
     (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))))`
+    ;; Produce the f64. No overflow → exact round-once convert. Overflow+power-of-two → round the
+    ;; frozen high bits (sticky-injected to break ties correctly) and scale by 2^exp. Overflow on
+    ;; another radix → $f already holds the round-each result.
+    (if (i32.eqz (local.get $ovf))
+      (then (local.set $f (f64.convert_i64_u (local.get $acc))))
+      (else (if (local.get $k)
+        (then
+          (if (local.get $sticky) (then (local.set $acc (i64.or (local.get $acc) (i64.const 1)))))
+          (local.set $f (f64.convert_i64_u (local.get $acc)))
+          (local.set $e (i32.add (local.get $exp) (i32.const 1023)))
+          (if (i32.ge_s (local.get $e) (i32.const 2047))
+            (then (local.set $f (f64.const inf)))
+            (else (local.set $f (f64.mul (local.get $f) (f64.reinterpret_i64 (i64.shl (i64.extend_i32_u (local.get $e)) (i64.const 52)))))))))))
+    (if (result f64) (local.get $neg) (then (f64.neg (local.get $f))) (else (local.get $f))))`
 
   // __strws(c: i32) → i32 — ECMA StrWhiteSpace predicate. Covers TAB..CR, SP,
   // NBSP, BOM, LS/PS, and every Unicode Space_Separator. U+180E is *not*
@@ -613,6 +860,8 @@ export default (ctx) => {
     (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))))
+    (if (i64.eq (local.get $v) (i64.const ${FALSE_NAN})) (then (return (f64.const 0))))
+    (if (i64.eq (local.get $v) (i64.const ${TRUE_NAN})) (then (return (f64.const 1))))
     (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
@@ -854,23 +1103,22 @@ export default (ctx) => {
   // 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))
+  const strInputI64 = (x) => valTypeOf(x) === VAL.BOOL ? asI64(bool(x)) : asI64(emit(x))
 
   ctx.core.emit['Number.parseInt'] = (x, radix) => {
+    if (ctx.transform.host === 'wasi') {
+      inc('__parseInt')
+      const radixIR = radix == null ? ['i32.const', 0] : toI32(toNumF64(radix, emit(radix)))
+      return typed(['call', '$__parseInt', strInputI64(x), radixIR], 'f64')
+    }
     needParseInt()
-    // 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) => {
-    if (ctx.module.imports.some(i => i[1] === `"${mod}"` && i[2] === `"${name}"`)) return
-    ctx.module.imports.push(['import', `"${mod}"`, `"${name}"`, fn])
-  }
-  const needParseFloat = () => addImportOnce(ctx, 'env', 'parseFloat',
+  const needParseFloat = () => hostImport('env', 'parseFloat',
     ['func', '$__parseFloat', ['param', 'i64'], ['result', 'f64']])
-  const needParseInt = () => addImportOnce(ctx, 'env', 'parseInt',
+  const needParseInt = () => hostImport('env', 'parseInt',
     ['func', '$__parseInt', ['param', 'i64'], ['param', 'i32'], ['result', 'f64']])
 
   ctx.core.emit['Number.parseFloat'] = (x) => {
@@ -884,32 +1132,44 @@ export default (ctx) => {
   ctx.core.emit['parseFloat'] = ctx.core.emit['Number.parseFloat']
 
   // Boolean(x) → truthiness (non-zero → 1, zero → 0)
-  ctx.core.emit['Boolean'] = (x) => {
+  reg('Boolean', ['__is_truthy'], (x) => {
     if (x === undefined) return typed(['f64.const', 0], 'f64')
-    inc('__is_truthy')
-    const v = asI64(emit(x))
-    return typed(['if', ['result', 'f64'], ['call', '$__is_truthy', v], ['then', ['f64.const', 1]], ['else', ['f64.const', 0]]], 'f64')
-  }
+    // Via truthyIR so a NUMBER arg gets the NaN-safe f64 test (Boolean(0/0) === false
+    // on every platform); other types fall to __is_truthy inside truthyIR.
+    return typed(['f64.convert_i32_s', truthyIR(emit(x))], 'f64')
+  })
 
   // === Instance method emitters ===
 
-  ctx.core.emit['.number:toString'] = (n) => {
-    inc('__ftoa')
-    return typed(['call', '$__ftoa', asF64(emit(n)), ['i32.const', 0], ['i32.const', 0]], 'f64')
-  }
+  const ftoaDefault = (v) => typed(['call', '$__ftoa', v, ['i32.const', 0], ['i32.const', 0]], 'f64')
+  reg('.number:toString', ['__ftoa', '__num_radix'], (n, radix) => {
+    const v = asF64(emit(n))
+    if (radix == null) return ftoaDefault(v)
+    const rv = emit(radix)
+    // Constant radix folds the 10-vs-other choice at compile time; radix 10 keeps
+    // __ftoa's shortest-repr (the radix loop would emit float-noise tail digits).
+    if (Array.isArray(rv) && rv[0] === 'f64.const' && typeof rv[1] === 'number')
+      return rv[1] === 10 ? ftoaDefault(v) : typed(['call', '$__num_radix', v, ['i32.const', rv[1] | 0]], 'f64')
+    const vt = temp('rv'), rt = tempI32('rr')
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${vt}`, v],
+      ['local.set', `$${rt}`, asI32(rv)],
+      ['if', ['result', 'f64'], ['i32.eq', ['local.get', `$${rt}`], ['i32.const', 10]],
+        ['then', ftoaDefault(['local.get', `$${vt}`])],
+        ['else', ['call', '$__num_radix', ['local.get', `$${vt}`], ['local.get', `$${rt}`]]]]], 'f64')
+  })
 
-  ctx.core.emit['.number:toFixed'] = (n, d) => {
-    inc('__ftoa')
-    return typed(['call', '$__ftoa', asF64(emit(n)), asI32(emit(d || [, 0])), ['i32.const', 1]], 'f64')
-  }
+  // BigInt.prototype.toString(radix) — i64-exact, default radix 10.
+  reg('.bigint:toString', ['__radix_str'], (n, radix) =>
+    typed(['call', '$__radix_str', asI64(emit(n)), radix == null ? ['i32.const', 10] : asI32(emit(radix))], 'f64'))
 
-  ctx.core.emit['.number:toExponential'] = (n, d) => {
-    inc('__toExp')
-    return typed(['call', '$__toExp', asF64(emit(n)), asI32(emit(d || [, 0])), ['i32.const', 0]], 'f64')
-  }
+  reg('.number:toFixed', ['__ftoa'], (n, d) =>
+    typed(['call', '$__ftoa', asF64(emit(n)), asI32(emit(d || [, 0])), ['i32.const', 1]], 'f64'))
 
-  ctx.core.emit['.number:toPrecision'] = (n, p) => {
-    inc('__ftoa', '__toExp')
+  reg('.number:toExponential', ['__toExp'], (n, d) =>
+    typed(['call', '$__toExp', asF64(emit(n)), asI32(emit(d || [, 0])), ['i32.const', 0]], 'f64'))
+
+  reg('.number:toPrecision', ['__ftoa', '__toExp'], (n, p) => {
     const val = temp('pv'), t = temp('tp'), exp = tempI32('te'), pr = tempI32('pp')
     return typed(['block', ['result', 'f64'],
       ['local.set', `$${val}`, asF64(emit(n))],
@@ -936,7 +1196,7 @@ export default (ctx) => {
         ['else', ['call', '$__ftoa', ['local.get', `$${val}`],
           ['i32.sub', ['i32.sub', ['local.get', `$${pr}`], ['i32.const', 1]], ['local.get', `$${exp}`]],
           ['i32.const', 1]]]]], 'f64')
-  }
+  })
 
   // Number(x) — identity for numbers, i64→f64 conversion for BigInt
   ctx.core.emit['Number'] = (x) => {
@@ -963,7 +1223,7 @@ export default (ctx) => {
         ['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]],
+            ptrTypeEq(['local.get', `$${t}`], PTR.STRING),
             ['then', ['call', '$__to_bigint', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
             ['else', ['local.get', `$${t}`]]]]]], 'f64')
     }
@@ -986,11 +1246,18 @@ export default (ctx) => {
       ['i64.shr_s', ['i64.shl', vval, ['local.get', `$${t}`]], ['local.get', `$${t}`]]]], 'f64')
   }
 
-  // BigInt.asUintN(bits, bigint) — truncate to unsigned N-bit
+  // BigInt.asUintN(bits, bigint) — truncate to unsigned N-bit.
+  // (val << (64 - bits)) >>> (64 - bits) — logical shift zero-extends the low `bits`.
+  // The naive `val & ((1 << bits) - 1)` mask is wrong at bits=64: i64.shl shifts mod 64,
+  // so `1 << 64` is `1 << 0 = 1`, making the mask `0` and asUintN(64,·) collapse to 0 —
+  // which also zeroed every bigint *literal* (emit reinterprets `Nn` via
+  // BigInt.asUintN(64,·).toString() through this very handler in the self-host).
   ctx.core.emit['BigInt.asUintN'] = (bits, val) => {
     const vbits = asI32(emit(bits)), vval = asI64(emit(val))
-    // val & ((1 << bits) - 1)
-    return typed(['f64.reinterpret_i64',
-      ['i64.and', vval, ['i64.sub', ['i64.shl', ['i64.const', 1], ['i64.extend_i32_s', vbits]], ['i64.const', 1]]]], 'f64')
+    const shift = typed(['i64.sub', ['i64.const', 64], ['i64.extend_i32_s', vbits]], 'i64')
+    const t = tempI64('bu')
+    return typed(['f64.reinterpret_i64', ['block', ['result', 'i64'],
+      ['local.set', `$${t}`, shift],
+      ['i64.shr_u', ['i64.shl', vval, ['local.get', `$${t}`]], ['local.get', `$${t}`]]]], 'f64')
   }
 }