jz 0.2.1 → 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

@@ -76,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)

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']
 

package/module/object.js

@@ -134,8 +134,9 @@ export default (ctx) => {
   ctx.core.emit[`.${VAL.CLOSURE}:hasOwnProperty`] = ctx.core.emit['.hasOwnProperty']
 
   ctx.core.emit['Object.values'] = (obj) => {
+    if (isHashTyped(obj)) return emitHashValues(obj)
     const schema = resolveSchema(obj)
-    if (!schema) err('Object.values requires object with known schema')
+    if (!schema) return emitRuntimeValues(obj)
     const va = asF64(emit(obj))
     const n = schema.length
     const t = temp('ov'), base = tempI32('vb')
@@ -225,6 +226,10 @@ export default (ctx) => {
     return typed(['block', ['result', 'f64'], ...body], 'f64')
   }
 
+  ctx.core.emit['Object.defineProperty'] = () => {
+    err('Object.defineProperty descriptor semantics are outside jz scope; jzify only folds static bundler export helpers')
+  }
+
   // Object.fromEntries(arr) → creates HASH from array of [key, value] pairs
   ctx.core.emit['Object.fromEntries'] = (arr) => {
     inc('__hash_new', '__hash_set')
@@ -450,6 +455,13 @@ function emitHashKeys(obj) {
     hashKeysFromTemp(t)], 'f64')
 }
 
+function emitHashValues(obj) {
+  const t = temp('hv')
+  return typed(['block', ['result', 'f64'],
+    ['local.set', `$${t}`, asF64(emit(obj))],
+    hashValuesFromTemp(t)], 'f64')
+}
+
 // Inline body of the HASH walk against an already-bound f64 local. Shared by
 // the static-HASH path and the runtime-dispatch path so both produce the same
 // IR shape from the same source — only difference is whether they enter from
@@ -481,6 +493,33 @@ function hashKeysFromTemp(t) {
     out.ptr]
 }
 
+function hashValuesFromTemp(t) {
+  inc('__ptr_offset', '__cap', '__len')
+  const off = tempI32('hvo'), cap = tempI32('hvc'), n = tempI32('hvn')
+  const i = tempI32('hvi'), o = tempI32('hvj'), slot = tempI32('hvs')
+  const out = allocPtr({ type: PTR.ARRAY, len: ['local.get', `$${n}`], tag: 'hva' })
+  const id = ctx.func.uniq++
+  return ['block', ['result', 'f64'],
+    ['local.set', `$${n}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    out.init,
+    ['local.set', `$${off}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['local.set', `$${cap}`, ['call', '$__cap', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['local.set', `$${i}`, ['i32.const', 0]],
+    ['local.set', `$${o}`, ['i32.const', 0]],
+    ['block', `$vbrk${id}`, ['loop', `$vloop${id}`,
+      ['br_if', `$vbrk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${cap}`]]],
+      ['local.set', `$${slot}`, ['i32.add', ['local.get', `$${off}`],
+        ['i32.mul', ['local.get', `$${i}`], ['i32.const', 24]]]],
+      ['if', ['f64.ne', ['f64.load', ['local.get', `$${slot}`]], ['f64.const', 0]],
+        ['then',
+          elemStore(out.local, o,
+            ['f64.load', ['i32.add', ['local.get', `$${slot}`], ['i32.const', 16]]]),
+          ['local.set', `$${o}`, ['i32.add', ['local.get', `$${o}`], ['i32.const', 1]]]]],
+      ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+      ['br', `$vloop${id}`]]],
+    out.ptr]
+}
+
 // Type-unknown receiver: bind the value, branch on ptr-type. HASH walks the
 // probe table; OBJECT loads the schema's key array (registered statically at
 // compile time or lazily at runtime by JSON.parse via __jp_schema_get); other
@@ -509,6 +548,26 @@ function emitRuntimeKeys(obj) {
         ['else', ['block', ['result', 'f64'], empty.init, empty.ptr]]]]]], 'f64')
 }
 
+function emitRuntimeValues(obj) {
+  inc('__ptr_type')
+  if (!ctx.scope.globals.has('__schema_tbl'))
+    ctx.scope.globals.set('__schema_tbl', '(global $__schema_tbl (mut i32) (i32.const 0))')
+  const t = temp('rv'), tt = tempI32('rvt')
+  const empty = allocPtr({ type: PTR.ARRAY, len: 0, tag: 'rve' })
+  return typed(['block', ['result', 'f64'],
+    ['local.set', `$${t}`, asF64(emit(obj))],
+    ['local.set', `$${tt}`, ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['if', ['result', 'f64'],
+      ['i32.eq', ['local.get', `$${tt}`], ['i32.const', PTR.HASH]],
+      ['then', hashValuesFromTemp(t)],
+      ['else', ['if', ['result', 'f64'],
+        ['i32.and',
+          ['i32.eq', ['local.get', `$${tt}`], ['i32.const', PTR.OBJECT]],
+          ['i32.ne', ['global.get', '$__schema_tbl'], ['i32.const', 0]]],
+        ['then', objectValuesFromTemp(t)],
+        ['else', ['block', ['result', 'f64'], empty.init, empty.ptr]]]]]], 'f64')
+}
+
 // Schema-keyed Object.keys: copy the schema's keys array (a jz Array of
 // STRINGs registered in __schema_tbl[sid]) into a fresh ARRAY so callers can
 // mutate without aliasing the schema substrate.
@@ -537,3 +596,31 @@ function objectKeysFromTemp(t) {
       ['br', `$kloop${id}`]]],
     mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${out}`])]
 }
+
+function objectValuesFromTemp(t) {
+  inc('__alloc_hdr', '__ptr_offset')
+  const sid = tempI32('ovs'), src = tempI32('ovsrc'), n = tempI32('ovn')
+  const base = tempI32('ovbase'), out = tempI32('ovo'), i = tempI32('ovi')
+  const id = ctx.func.uniq++
+  return ['block', ['result', 'f64'],
+    ['local.set', `$${sid}`, ['i32.wrap_i64', ['i64.and',
+      ['i64.shr_u', ['i64.reinterpret_f64', ['local.get', `$${t}`]], ['i64.const', LAYOUT.AUX_SHIFT]],
+      ['i64.const', LAYOUT.AUX_MASK]]]],
+    ['local.set', `$${src}`, ['i32.wrap_i64', ['i64.and',
+      ['i64.load', ['i32.add', ['global.get', '$__schema_tbl'], ['i32.shl', ['local.get', `$${sid}`], ['i32.const', 3]]]],
+      ['i64.const', LAYOUT.OFFSET_MASK]]]],
+    ['local.set', `$${n}`, ['i32.load', ['i32.sub', ['local.get', `$${src}`], ['i32.const', 8]]]],
+    ['local.set', `$${base}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['local.set', `$${out}`, ['call', '$__alloc_hdr',
+      ['local.get', `$${n}`], ['local.get', `$${n}`], ['i32.const', 8]]],
+    ['local.set', `$${i}`, ['i32.const', 0]],
+    ['block', `$ovbrk${id}`, ['loop', `$ovloop${id}`,
+      ['br_if', `$ovbrk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${n}`]]],
+      ['f64.store',
+        ['i32.add', ['local.get', `$${out}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]],
+        ['f64.load',
+          ['i32.add', ['local.get', `$${base}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]]]],
+      ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+      ['br', `$ovloop${id}`]]],
+    mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${out}`])]
+}

package/module/string.js

@@ -883,11 +883,12 @@ export default (ctx) => {
 
   ctx.core.emit['.string:slice'] = (str, start, end) => {
     inc('__str_slice')
-    if (end != null) return typed(['call', '$__str_slice', asI64(emit(str)), asI32(emit(start)), asI32(emit(end))], 'f64')
+    const startIR = start == null ? ['i32.const', 0] : asI32(emit(start))
+    if (end != null) return typed(['call', '$__str_slice', asI64(emit(str)), startIR, asI32(emit(end))], 'f64')
     const t = temp('t')
     return typed(['block', ['result', 'f64'],
       ['local.set', `$${t}`, asF64(emit(str))],
-      ['call', '$__str_slice', ['i64.reinterpret_f64', ['local.get', `$${t}`]], asI32(emit(start)),
+      ['call', '$__str_slice', ['i64.reinterpret_f64', ['local.get', `$${t}`]], startIR,
         ['call', '$__str_byteLen', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]]], 'f64')
   }
 

package/module/typedarray.js

@@ -587,8 +587,14 @@ export default (ctx) => {
     }
     return `(func $__typed_idx (param $ptr i64) (param $i i32) (result f64)
     (local $off i32) (local $et i32) (local $len i32) (local $aux i32)
-    (local.set $aux (call $__ptr_aux (local.get $ptr)))
     (local.set $off (call $__ptr_offset (local.get $ptr)))
+    ;; ARRAY fast path: __ptr_offset already followed any forwarding — read header len + f64.load, no $__len call.
+    (if (i32.and (i32.eq (call $__ptr_type (local.get $ptr)) (i32.const ${PTR.ARRAY})) (i32.ge_u (local.get $off) (i32.const 8)))
+      (then (return (if (result f64)
+        (i32.and (i32.ge_s (local.get $i) (i32.const 0)) (i32.lt_u (local.get $i) (i32.load (i32.sub (local.get $off) (i32.const 8)))))
+        (then (f64.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3)))))
+        (else (f64.const nan:${UNDEF_NAN}))))))
+    (local.set $aux (call $__ptr_aux (local.get $ptr)))
     (if
       (i32.and
         (i32.eq (call $__ptr_type (local.get $ptr)) (i32.const ${PTR.TYPED}))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jz",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Modern functional JS compiling to WASM",
   "main": "index.js",
   "type": "module",
@@ -38,8 +38,8 @@
   "author": "Dmitry Iv",
   "license": "MIT",
   "dependencies": {
-    "subscript": "^10.4.2",
-    "watr": "^4.5.1"
+    "subscript": "^10.4.7",
+    "watr": "^4.5.3"
   },
   "keywords": [
     "javascript",