jz 0.2.0 → 0.3.0

package/module/core.js

@@ -173,16 +173,25 @@ export default (ctx) => {
   } else {
     // Own memory: heap offset in a global, auto-grow when needed
     ctx.scope.globals.set('__heap', '(global $__heap (mut i32) (i32.const 1024))')
+    // Bump allocator with geometric growth. Growing one page at a time turns a
+    // long-running embedding (e.g. watr called thousands of times) into O(n²) —
+    // each memory.grow may relocate and copy the whole heap. So when we must
+    // grow, request at least the current size (≥2× total) in one shot; only on
+    // hitting the declared maximum do we fall back to the bare minimum.
     ctx.core.stdlib['__alloc'] = `(func $__alloc (param $bytes i32) (result i32)
-      (local $ptr i32) (local $next i32)
+      (local $ptr i32) (local $next i32) (local $cur i32) (local $need i32)
       (local.set $ptr (global.get $__heap))
       ;; Align next allocation to 8 bytes
       (local.set $next (i32.and (i32.add (i32.add (local.get $ptr) (local.get $bytes)) (i32.const 7)) (i32.const -8)))
-      ;; Grow memory if needed (each page = 65536 bytes)
-      (if (i32.gt_u (local.get $next) (i32.mul (memory.size) (i32.const 65536)))
-        (then (if (i32.eq (memory.grow
-          (i32.shr_u (i32.add (i32.sub (local.get $next) (i32.mul (memory.size) (i32.const 65536))) (i32.const 65535)) (i32.const 16)))
-          (i32.const -1)) (then (unreachable)))))
+      (local.set $cur (i32.shl (memory.size) (i32.const 16)))
+      (if (i32.gt_u (local.get $next) (local.get $cur))
+        (then
+          (local.set $need (i32.shr_u (i32.add (i32.sub (local.get $next) (local.get $cur)) (i32.const 65535)) (i32.const 16)))
+          (if (i32.lt_u (local.get $need) (memory.size)) (then (local.set $need (memory.size))))
+          (if (i32.eq (memory.grow (local.get $need)) (i32.const -1))
+            (then (if (i32.eq (memory.grow
+              (i32.shr_u (i32.add (i32.sub (local.get $next) (local.get $cur)) (i32.const 65535)) (i32.const 16)))
+              (i32.const -1)) (then (unreachable)))))))
       (global.set $__heap (local.get $next))
       (local.get $ptr))`
     ctx.core.stdlib['__clear'] = `(func $__clear
@@ -404,9 +413,15 @@ export default (ctx) => {
     return ['call', '$__ptr_type', receiver]
   }
 
-  function emitDynGetExprTyped(base, key, vt) {
-    inc('__dyn_get_expr_t')
+  function emitDynGetExprTyped(base, key, vt, prop) {
     const receiver = asI64(base?.type ? base : typed(base, 'f64'))
+    // Constant string key: fold the FNV hash at compile time and call the
+    // prehashed body — no __str_hash on every access.
+    if (typeof prop === 'string') {
+      inc('__dyn_get_expr_t_h')
+      return typed(['f64.reinterpret_i64', ['call', '$__dyn_get_expr_t_h', receiver, key, emitTypeTag(receiver, vt), ['i32.const', strHashLiteral(prop)]]], 'f64')
+    }
+    inc('__dyn_get_expr_t')
     return typed(['f64.reinterpret_i64', ['call', '$__dyn_get_expr_t', receiver, key, emitTypeTag(receiver, vt)]], 'f64')
   }
 
@@ -486,7 +501,7 @@ export default (ctx) => {
     if (typeof obj === 'string') {
       const vt = lookupValType(obj)
       if (usesDynProps(vt)) {
-        return emitDynGetExprTyped(va, key, vt)
+        return emitDynGetExprTyped(va, key, vt, prop)
       }
       if (vt === VAL.HASH) {
         return emitHashGetLocalConst(va, key, prop)
@@ -495,12 +510,12 @@ export default (ctx) => {
       // at off-16 (set by __dyn_set). __hash_get assumes HASH bucket layout
       // and would mis-read OBJECT memory.
       if (vt === VAL.OBJECT) {
-        return emitDynGetExprTyped(va, key, vt)
+        return emitDynGetExprTyped(va, key, vt, prop)
       }
       if (vt == null) {
         // In WASI mode, values are always JSON-derived (never PTR.EXTERNAL host objects).
         // Skip the external branch and dispatch through the typed HASH/OBJECT path.
-        if (ctx.transform.host === 'wasi') return emitDynGetExprTyped(va, key, vt)
+        if (ctx.transform.host === 'wasi') return emitDynGetExprTyped(va, key, vt, prop)
         ctx.features.external = true
         return emitDynGetAnyTyped(va, key, vt)
       }
@@ -598,7 +613,8 @@ export default (ctx) => {
 
     // Module-registered property emitter (.size, etc.)
     const propKey = `.${prop}`
-    if (ctx.core.emit[propKey]) return ctx.core.emit[propKey](obj)
+    const propEmitter = ctx.core.emit[propKey]
+    if (propEmitter && propEmitter.length <= 1) return propEmitter(obj)
 
     return emitPropAccess(emit(obj), obj, prop)
   }
@@ -618,7 +634,7 @@ export default (ctx) => {
         if (typeof obj === 'string') {
           const objType = lookupValType(obj)
           if (usesDynProps(objType)) {
-            access = emitDynGetExprTyped(['local.get', `$${t}`], asI64(emit(['str', prop])), objType)
+            access = emitDynGetExprTyped(['local.get', `$${t}`], asI64(emit(['str', prop])), objType, prop)
           } else if (objType === VAL.HASH) {
             access = emitHashGetLocalConst(['local.get', `$${t}`], asI64(emit(['str', prop])), prop)
           } else if (objType == null) {
@@ -626,7 +642,7 @@ export default (ctx) => {
             // In JS host mode use __dyn_get_any_t but don't force features.external here
             // since ?.prop short-circuits on nullish (EXTERNAL arm is dead unless already on).
             access = ctx.transform.host === 'wasi'
-              ? emitDynGetExprTyped(['local.get', `$${t}`], asI64(emit(['str', prop])), objType)
+              ? emitDynGetExprTyped(['local.get', `$${t}`], asI64(emit(['str', prop])), objType, prop)
               : emitDynGetAnyTyped(['local.get', `$${t}`], asI64(emit(['str', prop])), objType)
           } else {
             inc('__hash_get', '__str_hash', '__str_eq')
@@ -636,12 +652,20 @@ export default (ctx) => {
           if (valTypeOf(obj) === VAL.HASH) {
             access = emitHashGetLocalConst(['local.get', `$${t}`], asI64(emit(['str', prop])), prop)
           } else {
-            access = emitDynGetExprTyped(['local.get', `$${t}`], asI64(emit(['str', prop])), valTypeOf(obj))
+            access = emitDynGetExprTyped(['local.get', `$${t}`], asI64(emit(['str', prop])), valTypeOf(obj), prop)
           }
         }
       }
     }
-    return emitNullishGuarded(['local.tee', `$${t}`, va], access)
+    // Use local.set + local.get (not local.tee inside guard) because isNullish
+    // inlines the null/undefined check as (i32.or (i64.eq X NULL) (i64.eq X UNDEF)),
+    // which duplicates X — a local.tee(block(call $sideEffect)) would run twice.
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${t}`, va],
+      ['if', ['result', 'f64'],
+        notNullish(typed(['local.get', `$${t}`], 'f64')),
+        ['then', access],
+        ['else', ['f64.const', `nan:${UNDEF_NAN}`]]]], 'f64')
   }
 
   // Optional index: arr?.[i] → null if arr is null, else arr[i]
@@ -656,7 +680,15 @@ export default (ctx) => {
       if (!ctx.types.typedElem) ctx.types.typedElem = new Map()
       ctx.types.typedElem.set(t, ctx.types.typedElem.get(arr))
     }
-    return emitNullishGuarded(['local.tee', `$${t}`, va], asF64(ctx.core.emit['[]'](t, idx)))
+    // Use local.set + local.get (not local.tee inside guard) because isNullish
+    // inlines the null/undefined check as (i32.or (i64.eq X NULL) (i64.eq X UNDEF)),
+    // which duplicates X — a local.tee(block(call $sideEffect)) would run twice.
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${t}`, va],
+      ['if', ['result', 'f64'],
+        notNullish(typed(['local.get', `$${t}`], 'f64')),
+        ['then', asF64(ctx.core.emit['[]'](t, idx))],
+        ['else', ['f64.const', `nan:${UNDEF_NAN}`]]]], 'f64')
   }
 
   // Optional call: fn?.(...args) → null if fn is null, else call fn
@@ -674,7 +706,14 @@ export default (ctx) => {
         const vt = typeof recv === 'string' ? repOf(recv)?.val : valTypeOf(recv)
         if (vt) updateRep(t, { val: vt })
         const callResult = methodEmit(t, ...args)
-        return emitNullishGuarded(['local.tee', `$${t}`, va], asF64(callResult))
+        // Use local.set + local.get (not local.tee inside guard) because isNullish
+        // inlines the null/undefined check which duplicates the expression.
+        return typed(['block', ['result', 'f64'],
+          ['local.set', `$${t}`, va],
+          ['if', ['result', 'f64'],
+            notNullish(typed(['local.get', `$${t}`], 'f64')),
+            ['then', asF64(callResult)],
+            ['else', ['f64.const', `nan:${UNDEF_NAN}`]]]], 'f64')
       }
     }
     const t = temp()
@@ -682,7 +721,14 @@ export default (ctx) => {
     // If nullish → return NULL_NAN, else call via fn.call
     if (!ctx.closure.call) err('Optional call requires fn module')
     const callResult = ctx.closure.call(typed(['local.get', `$${t}`], 'f64'), args)
-    return emitNullishGuarded(['local.tee', `$${t}`, va], asF64(callResult))
+    // Use local.set + local.get (not local.tee inside guard) because isNullish
+    // inlines the null/undefined check which duplicates the expression.
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${t}`, va],
+      ['if', ['result', 'f64'],
+        notNullish(typed(['local.get', `$${t}`], 'f64')),
+        ['then', asF64(callResult)],
+        ['else', ['f64.const', `nan:${UNDEF_NAN}`]]]], 'f64')
   }
 
   // typeof: returns JS-style string. Reachable results are number/undefined/string/function/symbol/object

package/module/date.js

@@ -1,9 +1,10 @@
 /**
  * Date module — deterministic UTC algorithms first.
  *
- * Current scope: Date.UTC(...), Date object construction, UTC getters/setters,
- * toISOString, toUTCString. Local-time methods, parsing, and locale-sensitive
- * formatting are deliberately staged later.
+ * Current scope: Date.UTC(...), Date object construction, timestamp/string
+ * construction, UTC getters/setters, UTC-backed local getters, toISOString,
+ * toUTCString. Timezone-aware local-time methods and locale-sensitive formatting
+ * are deliberately staged later.
  *
  * @module date
  */
@@ -23,6 +24,9 @@ export default (ctx) => {
     __date_make_time: [],
     __date_time_clip: [],
     __date_utc: ['__date_make_day', '__date_make_time', '__date_time_clip'],
+    __date_digit: ['__char_at'],
+    __date_parse_iso_date: ['__str_byteLen', '__char_at', '__date_digit', '__date_make_day', '__date_time_clip'],
+    __date_from_value: ['__ptr_type', '__to_num', '__date_parse_iso_date'],
     __date_day: [],
     __date_time_within_day: ['__date_day'],
     __date_weekday: ['__date_day'],
@@ -72,6 +76,11 @@ export default (ctx) => {
     ], 'f64')
   }
 
+  ctx.core.emit['Date.parse'] = (value) => {
+    inc('__date_from_value')
+    return typed(['call', '$__date_from_value', ['i64.reinterpret_f64', asF64(emit(value))]], 'f64')
+  }
+
   // ── Core algorithms ───────────────────────────────────────────────────────
 
   ctx.core.stdlib['__date_days_from_year'] = `(func $__date_days_from_year (param $y f64) (result f64)
@@ -149,6 +158,66 @@ export default (ctx) => {
           (f64.const ${MS_PER_DAY}))
         (call $__date_make_time (local.get $hours) (local.get $minutes) (local.get $seconds) (local.get $ms)))))`
 
+  ctx.core.stdlib['__date_digit'] = `(func $__date_digit (param $str i64) (param $i i32) (result i32)
+    (local $c i32)
+    (local.set $c (call $__char_at (local.get $str) (local.get $i)))
+    (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 (i32.const -1))))`
+
+  ctx.core.stdlib['__date_parse_iso_date'] = `(func $__date_parse_iso_date (param $str i64) (result f64)
+    (local $y f64) (local $m f64) (local $d f64)
+    (local $d0 i32) (local $d1 i32) (local $d2 i32) (local $d3 i32)
+    (if (i32.lt_s (call $__str_byteLen (local.get $str)) (i32.const 10))
+      (then (return (f64.const nan))))
+    (if (i32.ne (call $__char_at (local.get $str) (i32.const 4)) (i32.const 45))
+      (then (return (f64.const nan))))
+    (if (i32.ne (call $__char_at (local.get $str) (i32.const 7)) (i32.const 45))
+      (then (return (f64.const nan))))
+
+    (local.set $d0 (call $__date_digit (local.get $str) (i32.const 0)))
+    (local.set $d1 (call $__date_digit (local.get $str) (i32.const 1)))
+    (local.set $d2 (call $__date_digit (local.get $str) (i32.const 2)))
+    (local.set $d3 (call $__date_digit (local.get $str) (i32.const 3)))
+    (if (i32.or (i32.or (i32.lt_s (local.get $d0) (i32.const 0)) (i32.lt_s (local.get $d1) (i32.const 0)))
+        (i32.or (i32.lt_s (local.get $d2) (i32.const 0)) (i32.lt_s (local.get $d3) (i32.const 0))))
+      (then (return (f64.const nan))))
+    (local.set $y (f64.convert_i32_s
+      (i32.add
+        (i32.add (i32.mul (local.get $d0) (i32.const 1000)) (i32.mul (local.get $d1) (i32.const 100)))
+        (i32.add (i32.mul (local.get $d2) (i32.const 10)) (local.get $d3)))))
+
+    (local.set $d0 (call $__date_digit (local.get $str) (i32.const 5)))
+    (local.set $d1 (call $__date_digit (local.get $str) (i32.const 6)))
+    (if (i32.or (i32.lt_s (local.get $d0) (i32.const 0)) (i32.lt_s (local.get $d1) (i32.const 0)))
+      (then (return (f64.const nan))))
+    (local.set $m (f64.convert_i32_s (i32.add (i32.mul (local.get $d0) (i32.const 10)) (local.get $d1))))
+    (if (i32.or (f64.lt (local.get $m) (f64.const 1)) (f64.gt (local.get $m) (f64.const 12)))
+      (then (return (f64.const nan))))
+
+    (local.set $d0 (call $__date_digit (local.get $str) (i32.const 8)))
+    (local.set $d1 (call $__date_digit (local.get $str) (i32.const 9)))
+    (if (i32.or (i32.lt_s (local.get $d0) (i32.const 0)) (i32.lt_s (local.get $d1) (i32.const 0)))
+      (then (return (f64.const nan))))
+    (local.set $d (f64.convert_i32_s (i32.add (i32.mul (local.get $d0) (i32.const 10)) (local.get $d1))))
+    (if (i32.or (f64.lt (local.get $d) (f64.const 1)) (f64.gt (local.get $d) (f64.const 31)))
+      (then (return (f64.const nan))))
+
+    (call $__date_time_clip
+      (f64.mul
+        (call $__date_make_day (local.get $y) (f64.sub (local.get $m) (f64.const 1)) (local.get $d))
+        (f64.const ${MS_PER_DAY}))))`
+
+  ctx.core.stdlib['__date_from_value'] = `(func $__date_from_value (param $v i64) (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 (call $__date_time_clip (local.get $f)))))
+    (if (i32.eq (call $__ptr_type (local.get $v)) (i32.const ${PTR.STRING}))
+      (then (return (call $__date_parse_iso_date (local.get $v)))))
+    (call $__date_time_clip (call $__to_num (local.get $v))))`
+
   // ── Time decomposition (ECMA-262 §21.4.1) ────────────────────────────────
 
   ctx.core.stdlib['__date_day'] = `(func $__date_day (param $t f64) (result f64)
@@ -513,13 +582,26 @@ export default (ctx) => {
   // Represented as PTR.OBJECT with a single f64 slot at offset 0 (the time value).
   // No schemaId (aux=0); dynamic property access falls through to undefined.
 
-  ctx.core.emit['new.Date'] = (ms) => {
+  ctx.core.emit['new.Date'] = (ms, month, date, hours, minutes, seconds, millis) => {
     let timeVal
     if (ms === undefined || ms === null) {
-      timeVal = typed(['f64.const', NaN], 'f64')
+      const now = ctx.core.emit['Date.now']
+      if (!now) throw new Error('Date constructor requires Date.now support')
+      timeVal = now()
+    } else if (!missingArg(month)) {
+      inc('__date_utc')
+      timeVal = typed(['call', '$__date_utc',
+        asF64(dateArg(ms, NaN, true)),
+        asF64(dateArg(month, 0)),
+        asF64(dateArg(date, 1)),
+        asF64(dateArg(hours, 0)),
+        asF64(dateArg(minutes, 0)),
+        asF64(dateArg(seconds, 0)),
+        asF64(dateArg(millis, 0)),
+      ], 'f64')
     } else {
-      inc('__date_time_clip')
-      timeVal = typed(['call', '$__date_time_clip', toNumF64(ms, emit(ms))], 'f64')
+      inc('__date_from_value')
+      timeVal = typed(['call', '$__date_from_value', ['i64.reinterpret_f64', asF64(emit(ms))]], 'f64')
     }
     const out = allocPtr({ type: PTR.OBJECT, len: 1, cap: 1, stride: 8, tag: 'date' })
     return typed(['block', ['result', 'f64'],
@@ -585,6 +667,21 @@ export default (ctx) => {
   ctx.core.emit['.getUTCMilliseconds'] = dateGetter('__date_ms_from_time')
   ctx.core.emit[`.${VAL.DATE}:getUTCMilliseconds`] = dateGetter('__date_ms_from_time')
 
+  // UTC-backed local getters. Full timezone-aware local time is intentionally
+  // staged separately; these aliases make deterministic/server Date use cases
+  // available without a timezone database.
+  ctx.core.emit['.getFullYear'] = ctx.core.emit['.getUTCFullYear']
+  ctx.core.emit[`.${VAL.DATE}:getFullYear`] = ctx.core.emit[`.${VAL.DATE}:getUTCFullYear`]
+
+  ctx.core.emit['.getMonth'] = ctx.core.emit['.getUTCMonth']
+  ctx.core.emit[`.${VAL.DATE}:getMonth`] = ctx.core.emit[`.${VAL.DATE}:getUTCMonth`]
+
+  ctx.core.emit['.getDate'] = ctx.core.emit['.getUTCDate']
+  ctx.core.emit[`.${VAL.DATE}:getDate`] = ctx.core.emit[`.${VAL.DATE}:getUTCDate`]
+
+  ctx.core.emit['.getDay'] = ctx.core.emit['.getUTCDay']
+  ctx.core.emit[`.${VAL.DATE}:getDay`] = ctx.core.emit[`.${VAL.DATE}:getUTCDay`]
+
   // ── UTC setter emit handlers ──────────────────────────────────────────────
 
   const emitDatePtr = (dateExpr) =>

package/module/function.js

@@ -11,7 +11,8 @@
  */
 
 import { typed, asF64, asI32, mkPtrIR, temp, tempI32, MAX_CLOSURE_ARITY, UNDEF_NAN } from '../src/ir.js'
-import { emit, isReassigned } from '../src/emit.js'
+import { emit } from '../src/emit.js'
+import { isReassigned } from '../src/ast.js'
 import { T, lookupValType, repOf, findFreeVars } from '../src/analyze.js'
 import { PTR, LAYOUT, inc, err } from '../src/ctx.js'
 

package/module/json.js

@@ -50,7 +50,8 @@ export default (ctx) => {
     __jput_str: ['__char_at', '__str_byteLen'],
     __jp: ['__jp_val', '__jp_str', '__jp_num', '__jp_arr', '__jp_obj', '__sso_char', '__ptr_aux', '__ptr_type', '__ptr_offset', '__str_byteLen'],
     __jp_val: ['__jp_str', '__jp_num', '__jp_arr', '__jp_obj'],
-    __jp_str: ['__sso_char', '__char_at', '__str_byteLen'],
+    __jp_str: ['__sso_char', '__char_at', '__str_byteLen', '__hex4', '__utf8_enc'],
+    __hex4: ['__hex1'],
     __jp_num: ['__pow10'],
     __jp_arr: ['__jp_val'],
     __jp_obj: ['__jp_val', '__jp_str', '__jp_schema_get', '__alloc_hdr', '__mkptr'],
@@ -319,8 +320,45 @@ export default (ctx) => {
   // SSO byte packing for ≤4-char ASCII keys, and FNV-1a hash. The hash is
   // stashed in $__jp_keyh so __jp_obj can use the prehashed insert and skip
   // a redundant __str_hash call.
+  // Hex nibble: '0'-'9' / 'a'-'f' / 'A'-'F' → 0..15; anything else → 0 (lenient).
+  ctx.core.stdlib['__hex1'] = `(func $__hex1 (param $c i32) (result i32)
+    (if (i32.le_u (i32.sub (local.get $c) (i32.const 48)) (i32.const 9))
+      (then (return (i32.sub (local.get $c) (i32.const 48)))))
+    (if (i32.le_u (i32.sub (i32.or (local.get $c) (i32.const 0x20)) (i32.const 97)) (i32.const 5))
+      (then (return (i32.sub (i32.or (local.get $c) (i32.const 0x20)) (i32.const 87)))))
+    (i32.const 0))`
+
+  // Read 4 hex bytes at absolute address $p → 16-bit value.
+  ctx.core.stdlib['__hex4'] = `(func $__hex4 (param $p i32) (result i32)
+    (i32.or (i32.or (i32.or
+      (i32.shl (call $__hex1 (i32.load8_u (local.get $p))) (i32.const 12))
+      (i32.shl (call $__hex1 (i32.load8_u (i32.add (local.get $p) (i32.const 1)))) (i32.const 8)))
+      (i32.shl (call $__hex1 (i32.load8_u (i32.add (local.get $p) (i32.const 2)))) (i32.const 4)))
+      (call $__hex1 (i32.load8_u (i32.add (local.get $p) (i32.const 3))))))`
+
+  // Encode code point $cp as UTF-8 at $off; returns bytes written (1-4).
+  ctx.core.stdlib['__utf8_enc'] = `(func $__utf8_enc (param $off i32) (param $cp i32) (result i32)
+    (if (i32.lt_u (local.get $cp) (i32.const 0x80))
+      (then (i32.store8 (local.get $off) (local.get $cp)) (return (i32.const 1))))
+    (if (i32.lt_u (local.get $cp) (i32.const 0x800))
+      (then
+        (i32.store8 (local.get $off) (i32.or (i32.const 0xC0) (i32.shr_u (local.get $cp) (i32.const 6))))
+        (i32.store8 (i32.add (local.get $off) (i32.const 1)) (i32.or (i32.const 0x80) (i32.and (local.get $cp) (i32.const 0x3F))))
+        (return (i32.const 2))))
+    (if (i32.lt_u (local.get $cp) (i32.const 0x10000))
+      (then
+        (i32.store8 (local.get $off) (i32.or (i32.const 0xE0) (i32.shr_u (local.get $cp) (i32.const 12))))
+        (i32.store8 (i32.add (local.get $off) (i32.const 1)) (i32.or (i32.const 0x80) (i32.and (i32.shr_u (local.get $cp) (i32.const 6)) (i32.const 0x3F))))
+        (i32.store8 (i32.add (local.get $off) (i32.const 2)) (i32.or (i32.const 0x80) (i32.and (local.get $cp) (i32.const 0x3F))))
+        (return (i32.const 3))))
+    (i32.store8 (local.get $off) (i32.or (i32.const 0xF0) (i32.shr_u (local.get $cp) (i32.const 18))))
+    (i32.store8 (i32.add (local.get $off) (i32.const 1)) (i32.or (i32.const 0x80) (i32.and (i32.shr_u (local.get $cp) (i32.const 12)) (i32.const 0x3F))))
+    (i32.store8 (i32.add (local.get $off) (i32.const 2)) (i32.or (i32.const 0x80) (i32.and (i32.shr_u (local.get $cp) (i32.const 6)) (i32.const 0x3F))))
+    (i32.store8 (i32.add (local.get $off) (i32.const 3)) (i32.or (i32.const 0x80) (i32.and (local.get $cp) (i32.const 0x3F))))
+    (i32.const 4))`
+
   ctx.core.stdlib['__jp_str'] = `(func $__jp_str (result f64)
-    (local $start i32) (local $ch i32) (local $len i32) (local $off i32) (local $i i32) (local $simple i32) (local $sso i32) (local $h i32)
+    (local $start i32) (local $ch i32) (local $len i32) (local $off i32) (local $i i32) (local $simple i32) (local $sso i32) (local $h i32) (local $cp i32)
     (local.set $start (global.get $__jppos))
     (local.set $simple (i32.const 1))
     (local.set $h (i32.const 0x811c9dc5))
@@ -382,12 +420,32 @@ export default (ctx) => {
           ${ADV(1)}
           (local.set $ch ${PEEK})
           ${ADV(1)}
-          ;; Decode escape: n→10 t→9 r→13 b→8 f→12, else literal
-          (if (i32.eq (local.get $ch) (i32.const 110)) (then (local.set $ch (i32.const 10))))
-          (if (i32.eq (local.get $ch) (i32.const 116)) (then (local.set $ch (i32.const 9))))
-          (if (i32.eq (local.get $ch) (i32.const 114)) (then (local.set $ch (i32.const 13))))
-          (if (i32.eq (local.get $ch) (i32.const 98))  (then (local.set $ch (i32.const 8))))
-          (if (i32.eq (local.get $ch) (i32.const 102)) (then (local.set $ch (i32.const 12)))))
+          (if (i32.eq (local.get $ch) (i32.const 117))  ;; \\uXXXX
+            (then
+              (local.set $cp (call $__hex4 (i32.add (global.get $__jpstr) (global.get $__jppos))))
+              ${ADV(4)}
+              ;; High surrogate immediately followed by \\uXXXX low surrogate → combine.
+              (if (i32.and
+                    (i32.eq (i32.and (local.get $cp) (i32.const 0xFC00)) (i32.const 0xD800))
+                    (i32.and (i32.eq ${PEEK} (i32.const 92))
+                             (i32.eq (i32.load8_u (i32.add (global.get $__jpstr) (i32.add (global.get $__jppos) (i32.const 1)))) (i32.const 117))))
+                (then
+                  ${ADV(2)}
+                  (local.set $i (call $__hex4 (i32.add (global.get $__jpstr) (global.get $__jppos))))
+                  ${ADV(4)}
+                  (local.set $cp (i32.add (i32.const 0x10000)
+                    (i32.or (i32.shl (i32.and (local.get $cp) (i32.const 0x3FF)) (i32.const 10))
+                            (i32.and (local.get $i) (i32.const 0x3FF)))))))
+              (local.set $len (i32.add (local.get $len)
+                (call $__utf8_enc (i32.add (local.get $off) (local.get $len)) (local.get $cp))))
+              (br $l2))
+            (else
+              ;; Decode simple escape: n→10 t→9 r→13 b→8 f→12, else literal char.
+              (if (i32.eq (local.get $ch) (i32.const 110)) (then (local.set $ch (i32.const 10))))
+              (if (i32.eq (local.get $ch) (i32.const 116)) (then (local.set $ch (i32.const 9))))
+              (if (i32.eq (local.get $ch) (i32.const 114)) (then (local.set $ch (i32.const 13))))
+              (if (i32.eq (local.get $ch) (i32.const 98))  (then (local.set $ch (i32.const 8))))
+              (if (i32.eq (local.get $ch) (i32.const 102)) (then (local.set $ch (i32.const 12)))))))
         (else ${ADV(1)}))
       (i32.store8 (i32.add (local.get $off) (local.get $len)) (local.get $ch))
       (local.set $len (i32.add (local.get $len) (i32.const 1)))

package/module/number.js

@@ -10,7 +10,8 @@
  */
 
 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 { emit } from '../src/emit.js'
+import { isReassigned } from '../src/ast.js'
 import { valTypeOf, VAL } from '../src/analyze.js'
 import { inc, PTR } from '../src/ctx.js'
 
@@ -22,6 +23,7 @@ export default (ctx) => {
     __to_num: ['__char_at', '__str_byteLen', '__pow10', '__to_str'],
     __to_bigint: ['__char_at', '__str_byteLen'],
     __parseInt: ['__char_at', '__str_byteLen'],
+    __parseFloat: ['__char_at', '__str_byteLen', '__pow10', '__to_str'],
   })
 
 
@@ -346,7 +348,6 @@ export default (ctx) => {
       ['f64.eq', ['local.get', `$${t}`], ['f64.trunc', ['local.get', `$${t}`]]]], 'i32')
   }
 
-  // parseInt(str, radix) — parse string to integer
   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)
@@ -592,14 +593,135 @@ export default (ctx) => {
         (then (i64.sub (i64.const 0) (local.get $result)))
         (else (local.get $result)))))`
 
+  ctx.core.stdlib['__parseFloat'] = `(func $__parseFloat (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 $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))))
+    (local.set $t (call $__ptr_type (local.get $v)))
+    ;; parseFloat first applies ToString, then parses the longest decimal prefix.
+    ;; Unlike Number(), empty strings and non-decimal prefixes produce NaN/0
+    ;; according to the consumed prefix rather than whole-string numeric coercion.
+    (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
+      (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)))
+    ;; 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)))))
+    ;; 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)))))
+          (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)))))
+    ;; 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)))))))
+    (if (result f64) (local.get $neg) (then (f64.neg (local.get $result))) (else (local.get $result))))`
+
   ctx.core.emit['Number.parseInt'] = (x, radix) => {
-    inc('__parseInt')
+    needParseInt()
     return typed(['call', '$__parseInt', asI64(emit(x)), radix ? asI32(emit(radix)) : ['i32.const', 0]], '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',
+    ['func', '$__parseFloat', ['param', 'i64'], ['result', 'f64']])
+  const needParseInt = () => addImportOnce(ctx, 'env', 'parseInt',
+    ['func', '$__parseInt', ['param', 'i64'], ['param', 'i32'], ['result', 'f64']])
+
   ctx.core.emit['Number.parseFloat'] = (x) => {
-    inc('__to_num')
-    return typed(['call', '$__to_num', asI64(emit(x))], 'f64')
+    if (ctx.transform.host === 'wasi') {
+      inc('__parseFloat')
+      return typed(['call', '$__parseFloat', asI64(emit(x))], 'f64')
+    }
+    needParseFloat()
+    return typed(['call', '$__parseFloat', asI64(emit(x))], 'f64')
   }
   ctx.core.emit['parseFloat'] = ctx.core.emit['Number.parseFloat']