jz 0.2.1 → 0.3.1

package/module/collection.js

@@ -44,6 +44,16 @@ function numConstLiteral(expr) {
 const sameValueZeroEq = '(call $__same_value_zero (i64.load (i32.add (local.get $slot) (i32.const 8))) (local.get $key))'
 const strEq = '(call $__str_eq (i64.load (i32.add (local.get $slot) (i32.const 8))) (local.get $key))'
 
+// Open-addressing probe walked additively by entrySize: avoids an i32.mul + mask per
+// step (vs recomputing slot = off + idx*entrySize). Needs $off/$cap/$h set and $end/$slot
+// locals declared. `idxExpr` is the first-slot index (defaults to h mod cap; cap is pow2).
+const probeStart = (entrySize, idxExpr = '(i32.and (local.get $h) (i32.sub (local.get $cap) (i32.const 1)))') =>
+  `(local.set $end (i32.add (local.get $off) (i32.mul (local.get $cap) (i32.const ${entrySize}))))
+    (local.set $slot (i32.add (local.get $off) (i32.mul ${idxExpr} (i32.const ${entrySize}))))`
+const probeNext = (entrySize) =>
+  `(local.set $slot (i32.add (local.get $slot) (i32.const ${entrySize})))
+      (if (i32.ge_u (local.get $slot) (local.get $end)) (then (local.set $slot (local.get $off))))`
+
 /** Generate upsert (add/set) probe function. hasVal: store value at slot+16.
  *  hasExt: emit EXTERNAL fallthrough (call $__ext_set on non-matching type).
  *  Gated off → type mismatch just returns coll unchanged. */
@@ -62,14 +72,13 @@ function genUpsert(name, entrySize, hashFn, eqExpr, expectedType, hasVal, hasExt
     ? `(if (i32.ne ${tExpr} (i32.const ${expectedType})) (then (if (i32.eq ${tExpr} (i32.const ${PTR.EXTERNAL})) ${extBranch}) (return (local.get $coll))))`
     : `(if (i32.ne ${tExpr} (i32.const ${expectedType})) (then (return (local.get $coll))))`
   return `(func $${name} (param $coll i64) (param $key i64) ${valParam}(result i64)
-    (local $off i32) (local $cap i32) (local $h i32) (local $idx i32) (local $slot i32)
+    (local $off i32) (local $cap i32) (local $h i32) (local $end i32) (local $slot i32)
     ${typeGuard}
     (local.set $off (i32.wrap_i64 (i64.and (local.get $coll) (i64.const ${LAYOUT.OFFSET_MASK}))))
     (local.set $cap (i32.load (i32.sub (local.get $off) (i32.const 4))))
     (local.set $h (call ${hashFn} (local.get $key)))
-    (local.set $idx (i32.and (local.get $h) (i32.sub (local.get $cap) (i32.const 1))))
+    ${probeStart(entrySize)}
     (block $done (loop $probe
-      (local.set $slot (i32.add (local.get $off) (i32.mul (local.get $idx) (i32.const ${entrySize}))))
       (if (i64.eqz (i64.load (local.get $slot)))
         (then
           (i64.store (local.get $slot) (i64.extend_i32_u (local.get $h)))
@@ -78,7 +87,7 @@ function genUpsert(name, entrySize, hashFn, eqExpr, expectedType, hasVal, hasExt
             (i32.add (i32.load (i32.sub (local.get $off) (i32.const 8))) (i32.const 1)))
           (br $done)))
       (if ${eqExpr} ${onMatch})
-      (local.set $idx (i32.and (i32.add (local.get $idx) (i32.const 1)) (i32.sub (local.get $cap) (i32.const 1))))
+      ${probeNext(entrySize)}
       (br $probe)))
     (local.get $coll))`
 }
@@ -108,17 +117,16 @@ function genLookup(name, entrySize, hashFn, eqExpr, expectedType, wantValue, has
     : `(if (i32.ne ${tExpr} (i32.const ${expectedType})) (then ${onEmpty}))`
 
   return `(func $${name} (param $coll i64) (param $key i64) (result ${rt})
-    (local $off i32) (local $cap i32) (local $h i32) (local $idx i32) (local $slot i32) (local $tries i32)
+    (local $off i32) (local $cap i32) (local $h i32) (local $end i32) (local $slot i32) (local $tries i32)
     ${typeGuard}
     (local.set $off (i32.wrap_i64 (i64.and (local.get $coll) (i64.const ${LAYOUT.OFFSET_MASK}))))
     (local.set $cap (i32.load (i32.sub (local.get $off) (i32.const 4))))
     (local.set $h (call ${hashFn} (local.get $key)))
-    (local.set $idx (i32.and (local.get $h) (i32.sub (local.get $cap) (i32.const 1))))
+    ${probeStart(entrySize)}
     (block $done (loop $probe
-      (local.set $slot (i32.add (local.get $off) (i32.mul (local.get $idx) (i32.const ${entrySize}))))
       (if (i64.eqz (i64.load (local.get $slot))) (then ${onEmpty}))
       (if ${eqExpr} (then ${onFound}))
-      (local.set $idx (i32.and (i32.add (local.get $idx) (i32.const 1)) (i32.sub (local.get $cap) (i32.const 1))))
+      ${probeNext(entrySize)}
       (local.set $tries (i32.add (local.get $tries) (i32.const 1)))
       (br_if $done (i32.ge_s (local.get $tries) (local.get $cap)))
       (br $probe)))
@@ -128,21 +136,20 @@ function genLookup(name, entrySize, hashFn, eqExpr, expectedType, wantValue, has
 /** Generate delete probe function. Zero out entry on match. */
 function genDelete(name, entrySize, hashFn, eqExpr, expectedType) {
   return `(func $${name} (param $coll i64) (param $key i64) (result i32)
-    (local $off i32) (local $cap i32) (local $h i32) (local $idx i32) (local $slot i32) (local $tries i32)
+    (local $off i32) (local $cap i32) (local $h i32) (local $end i32) (local $slot i32) (local $tries i32)
     (if (i32.ne (call $__ptr_type (local.get $coll)) (i32.const ${expectedType})) (then (return (i32.const 0))))
     (local.set $off (call $__ptr_offset (local.get $coll)))
     (local.set $cap (i32.load (i32.sub (local.get $off) (i32.const 4))))
     (local.set $h (call ${hashFn} (local.get $key)))
-    (local.set $idx (i32.and (local.get $h) (i32.sub (local.get $cap) (i32.const 1))))
+    ${probeStart(entrySize)}
     (block $done (loop $probe
-      (local.set $slot (i32.add (local.get $off) (i32.mul (local.get $idx) (i32.const ${entrySize}))))
       (if (i64.eqz (i64.load (local.get $slot))) (then (return (i32.const 0))))
       (if ${eqExpr}
         (then
           (i64.store (local.get $slot) (i64.const 0))
           (i64.store (i32.add (local.get $slot) (i32.const 8)) (i64.const 0))
           (return (i32.const 1))))
-      (local.set $idx (i32.and (i32.add (local.get $idx) (i32.const 1)) (i32.sub (local.get $cap) (i32.const 1))))
+      ${probeNext(entrySize)}
       (local.set $tries (i32.add (local.get $tries) (i32.const 1)))
       (br_if $done (i32.ge_s (local.get $tries) (local.get $cap)))
       (br $probe)))
@@ -168,7 +175,7 @@ function genUpsertGrow(name, entrySize, hashFn, eqExpr, typeConst, strict = fals
           ${nonHashFallback}
           (return (local.get $obj))))`
   return `(func $${name} (param $obj i64) (param $key i64) (param $val i64) (result i64)
-    (local $off i32) (local $cap i32) (local $h i32) (local $idx i32) (local $slot i32)
+    (local $off i32) (local $cap i32) (local $h i32) (local $end i32) (local $slot i32)
     (local $size i32) (local $newptr i32) (local $newcap i32) (local $i i32)
     (local $oldslot i32) (local $newidx i32) (local $newslot i32)
     ${typeGuard}
@@ -205,9 +212,8 @@ function genUpsertGrow(name, entrySize, hashFn, eqExpr, typeConst, strict = fals
         (local.set $obj (i64.reinterpret_f64 (call $__mkptr (i32.const ${typeConst}) (i32.const 0) (local.get $newptr))))))
     ;; Insert/update
     (local.set $h (call ${hashFn} (local.get $key)))
-    (local.set $idx (i32.and (local.get $h) (i32.sub (local.get $cap) (i32.const 1))))
+    ${probeStart(entrySize)}
     (block $done (loop $probe
-      (local.set $slot (i32.add (local.get $off) (i32.mul (local.get $idx) (i32.const ${entrySize}))))
       (if (i64.eqz (i64.load (local.get $slot)))
         (then
           (i64.store (local.get $slot) (i64.extend_i32_u (local.get $h)))
@@ -220,14 +226,14 @@ function genUpsertGrow(name, entrySize, hashFn, eqExpr, typeConst, strict = fals
         (then
           (i64.store (i32.add (local.get $slot) (i32.const 16)) (local.get $val))
           (br $done)))
-      (local.set $idx (i32.and (i32.add (local.get $idx) (i32.const 1)) (i32.sub (local.get $cap) (i32.const 1))))
+      ${probeNext(entrySize)}
       (br $probe)))
     (local.get $obj))`
 }
 
 function genLookupStrict(name, entrySize, hashFn, eqExpr, expectedType, missing = UNDEF_NAN) {
   return `(func $${name} (param $coll i64) (param $key i64) (result i64)
-    (local $off i32) (local $cap i32) (local $h i32) (local $idx i32) (local $slot i32) (local $tries i32)
+    (local $off i32) (local $cap i32) (local $h i32) (local $end i32) (local $slot i32) (local $tries i32)
     (if (i32.ne
           (i32.wrap_i64 (i64.and (i64.shr_u (local.get $coll) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK})))
           (i32.const ${expectedType}))
@@ -235,14 +241,13 @@ function genLookupStrict(name, entrySize, hashFn, eqExpr, expectedType, missing
     (local.set $off (i32.wrap_i64 (i64.and (local.get $coll) (i64.const ${LAYOUT.OFFSET_MASK}))))
     (local.set $cap (i32.load (i32.sub (local.get $off) (i32.const 4))))
     (local.set $h (call ${hashFn} (local.get $key)))
-    (local.set $idx (i32.and (local.get $h) (i32.sub (local.get $cap) (i32.const 1))))
+    ${probeStart(entrySize)}
     (block $done (loop $probe
-      (local.set $slot (i32.add (local.get $off) (i32.mul (local.get $idx) (i32.const ${entrySize}))))
       (if (i64.eqz (i64.load (local.get $slot)))
         (then (return (i64.const ${missing}))))
       (if ${eqExpr}
         (then (return (i64.load (i32.add (local.get $slot) (i32.const 16))))))
-      (local.set $idx (i32.and (i32.add (local.get $idx) (i32.const 1)) (i32.sub (local.get $cap) (i32.const 1))))
+      ${probeNext(entrySize)}
       (local.set $tries (i32.add (local.get $tries) (i32.const 1)))
       (br_if $done (i32.ge_s (local.get $tries) (local.get $cap)))
       (br $probe)))
@@ -260,18 +265,17 @@ function genLookupStrictPrehashed(name, entrySize, eqExpr, expectedType, missing
     : `(if (i32.ne ${tExpr} (i32.const ${expectedType}))
       (then (return (i64.const ${missing}))))`
   return `(func $${name} (param $coll i64) (param $key i64) (param $h i32) (result i64)
-    (local $off i32) (local $cap i32) (local $idx i32) (local $slot i32) (local $tries i32)
+    (local $off i32) (local $cap i32) (local $end i32) (local $slot i32) (local $tries i32)
     ${typeGuard}
     (local.set $off (i32.wrap_i64 (i64.and (local.get $coll) (i64.const ${LAYOUT.OFFSET_MASK}))))
     (local.set $cap (i32.load (i32.sub (local.get $off) (i32.const 4))))
-    (local.set $idx (i32.and (local.get $h) (i32.sub (local.get $cap) (i32.const 1))))
+    ${probeStart(entrySize)}
     (block $done (loop $probe
-      (local.set $slot (i32.add (local.get $off) (i32.mul (local.get $idx) (i32.const ${entrySize}))))
       (if (i64.eqz (i64.load (local.get $slot)))
         (then (return (i64.const ${missing}))))
       (if ${eqExpr}
         (then (return (i64.load (i32.add (local.get $slot) (i32.const 16))))))
-      (local.set $idx (i32.and (i32.add (local.get $idx) (i32.const 1)) (i32.sub (local.get $cap) (i32.const 1))))
+      ${probeNext(entrySize)}
       (local.set $tries (i32.add (local.get $tries) (i32.const 1)))
       (br_if $done (i32.ge_s (local.get $tries) (local.get $cap)))
       (br $probe)))
@@ -280,16 +284,15 @@ function genLookupStrictPrehashed(name, entrySize, eqExpr, expectedType, missing
 
 function genUpsertStrictPrehashed(name, entrySize, eqExpr, expectedType) {
   return `(func $${name} (param $obj i64) (param $key i64) (param $h i32) (param $val i64) (result i64)
-    (local $off i32) (local $cap i32) (local $idx i32) (local $slot i32)
+    (local $off i32) (local $cap i32) (local $end i32) (local $slot i32)
     (if (i32.ne
           (i32.wrap_i64 (i64.and (i64.shr_u (local.get $obj) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK})))
           (i32.const ${expectedType}))
       (then (return (local.get $obj))))
     (local.set $off (i32.wrap_i64 (i64.and (local.get $obj) (i64.const ${LAYOUT.OFFSET_MASK}))))
     (local.set $cap (i32.load (i32.sub (local.get $off) (i32.const 4))))
-    (local.set $idx (i32.and (local.get $h) (i32.sub (local.get $cap) (i32.const 1))))
+    ${probeStart(entrySize)}
     (block $done (loop $probe
-      (local.set $slot (i32.add (local.get $off) (i32.mul (local.get $idx) (i32.const ${entrySize}))))
       (if (i64.eqz (i64.load (local.get $slot)))
         (then
           (i64.store (local.get $slot) (i64.extend_i32_u (local.get $h)))
@@ -302,7 +305,7 @@ function genUpsertStrictPrehashed(name, entrySize, eqExpr, expectedType) {
         (then
           (i64.store (i32.add (local.get $slot) (i32.const 16)) (local.get $val))
           (br $done)))
-      (local.set $idx (i32.and (i32.add (local.get $idx) (i32.const 1)) (i32.sub (local.get $cap) (i32.const 1))))
+      ${probeNext(entrySize)}
       (br $probe)))
     (local.get $obj))`
 }
@@ -340,9 +343,11 @@ export default (ctx) => {
     __hash_set_local: ['__str_hash', '__str_eq'],
     __ihash_get_local: ['__map_hash'],
     __ihash_set_local: ['__map_hash', '__alloc_hdr', '__mkptr'],
-    __dyn_get_t: ['__ihash_get_local', '__str_hash', '__str_eq', '__is_nullish'],
+    __dyn_get_t: ['__dyn_get_t_h', '__str_hash'],
+    __dyn_get_t_h: ['__ihash_get_local', '__str_eq', '__is_nullish'],
     __dyn_get: ['__dyn_get_t', '__ptr_type'],
     __dyn_get_expr_t: ['__dyn_get_t', '__hash_get_local'],
+    __dyn_get_expr_t_h: ['__dyn_get_t_h', '__hash_get_local_h'],
     __dyn_get_expr: ['__dyn_get_expr_t', '__ptr_type'],
     __dyn_get_any: ['__dyn_get_any_t', '__ptr_type'],
     __dyn_get_any_t: () => ctx.features.external
@@ -666,11 +671,22 @@ export default (ctx) => {
   ctx.core.stdlib['__dyn_get'] = `(func $__dyn_get (param $obj i64) (param $key i64) (result i64)
     (call $__dyn_get_t (local.get $obj) (local.get $key) (call $__ptr_type (local.get $obj))))`
 
-  ctx.core.stdlib['__dyn_get_t'] = () => `(func $__dyn_get_t (param $obj i64) (param $key i64) (param $type i32) (result i64)
+  // Thin wrapper: hash the key once, delegate to the prehashed body. Constant-key
+  // call sites bypass this and call $__dyn_get_t_h directly with strHashLiteral().
+  ctx.core.stdlib['__dyn_get_t'] = `(func $__dyn_get_t (param $obj i64) (param $key i64) (param $type i32) (result i64)
+    (call $__dyn_get_t_h (local.get $obj) (local.get $key) (local.get $type) (call $__str_hash (local.get $key))))`
+
+  ctx.core.stdlib['__dyn_get_t_h'] = () => `(func $__dyn_get_t_h (param $obj i64) (param $key i64) (param $type i32) (param $h i32) (result i64)
     (local $props i64) (local $off i32)
-    (local $poff i32) (local $pcap i32) (local $h i32) (local $idx i32) (local $slot i32) (local $tries i32)
+    (local $poff i32) (local $pcap i32) (local $pend i32) (local $idx i32) (local $slot i32) (local $tries i32)
     ${buildObjectSchemaLocals()}
     (local.set $off (i32.wrap_i64 (i64.and (local.get $obj) (i64.const ${LAYOUT.OFFSET_MASK}))))
+    ;; CLOSURE with no env (offset 0): many function refs share offset 0, so key the
+    ;; global __dyn_props hash on the function table index (negative — can't collide
+    ;; with real heap/data offsets). Closures *with* env keep their unique env ptr.
+    (if (i32.and (i32.eq (local.get $type) (i32.const ${PTR.CLOSURE})) (i32.eqz (local.get $off)))
+      (then (local.set $off (i32.sub (i32.const -1)
+        (i32.wrap_i64 (i64.and (i64.shr_u (local.get $obj) (i64.const ${LAYOUT.AUX_SHIFT})) (i64.const ${LAYOUT.AUX_MASK})))))))
     (if (i32.eq (local.get $type) (i32.const ${PTR.ARRAY}))
       (then
         (block $done
@@ -735,14 +751,14 @@ export default (ctx) => {
                 (global.set $__dyn_get_cache_props (f64.reinterpret_i64 (local.get $props))))))))
       (local.set $poff (i32.wrap_i64 (i64.and (local.get $props) (i64.const ${LAYOUT.OFFSET_MASK}))))
       (local.set $pcap (i32.load (i32.sub (local.get $poff) (i32.const 4))))
-      (local.set $h (call $__str_hash (local.get $key)))
-      (local.set $idx (i32.and (local.get $h) (i32.sub (local.get $pcap) (i32.const 1))))
+      (local.set $pend (i32.add (local.get $poff) (i32.mul (local.get $pcap) (i32.const ${MAP_ENTRY}))))
+      (local.set $slot (i32.add (local.get $poff) (i32.mul (i32.and (local.get $h) (i32.sub (local.get $pcap) (i32.const 1))) (i32.const ${MAP_ENTRY}))))
       (block $hdone (loop $hprobe
-        (local.set $slot (i32.add (local.get $poff) (i32.mul (local.get $idx) (i32.const ${MAP_ENTRY}))))
         (br_if $dynDone (i64.eqz (i64.load (local.get $slot))))
         (if (call $__str_eq (i64.load (i32.add (local.get $slot) (i32.const 8))) (local.get $key))
           (then (return (i64.load (i32.add (local.get $slot) (i32.const 16))))))
-        (local.set $idx (i32.and (i32.add (local.get $idx) (i32.const 1)) (i32.sub (local.get $pcap) (i32.const 1))))
+        (local.set $slot (i32.add (local.get $slot) (i32.const ${MAP_ENTRY})))
+        (if (i32.ge_u (local.get $slot) (local.get $pend)) (then (local.set $slot (local.get $poff))))
         (local.set $tries (i32.add (local.get $tries) (i32.const 1)))
         (br_if $hdone (i32.ge_s (local.get $tries) (local.get $pcap)))
         (br $hprobe))))${buildObjectSchemaArm()}
@@ -770,6 +786,19 @@ export default (ctx) => {
           (then (call $__hash_get_local (local.get $obj) (local.get $key)))
           (else (i64.const ${NULL_NAN}))))))`
 
+  // Prehashed variant of __dyn_get_expr_t for constant string keys: the FNV hash
+  // is folded at compile time (strHashLiteral), so no __str_hash call at runtime.
+  ctx.core.stdlib['__dyn_get_expr_t_h'] = `(func $__dyn_get_expr_t_h (param $obj i64) (param $key i64) (param $t i32) (param $h i32) (result i64)
+    (local $val i64)
+    (local.set $val (call $__dyn_get_t_h (local.get $obj) (local.get $key) (local.get $t) (local.get $h)))
+    (if (result i64)
+      (i64.ne (local.get $val) (i64.const ${UNDEF_NAN}))
+      (then (local.get $val))
+      (else
+        (if (result i64) (i32.eq (local.get $t) (i32.const ${PTR.HASH}))
+          (then (call $__hash_get_local_h (local.get $obj) (local.get $key) (local.get $h)))
+          (else (i64.const ${NULL_NAN}))))))`
+
   // Like __dyn_get_expr but also resolves EXTERNAL host objects via __ext_prop.
   // Used at call sites where receiver type is statically unknown.
   // When features.external is off, collapses to __dyn_get_expr shape (no EXTERNAL probe).
@@ -809,6 +838,10 @@ export default (ctx) => {
     (local $off i32) (local $type i32) ${buildObjectSchemaSetLocals()}
     (local.set $off (i32.wrap_i64 (i64.and (local.get $obj) (i64.const ${LAYOUT.OFFSET_MASK}))))
     (local.set $type (i32.wrap_i64 (i64.and (i64.shr_u (local.get $obj) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK}))))
+    ;; CLOSURE with no env (offset 0): key __dyn_props on the function table index — see __dyn_get_t.
+    (if (i32.and (i32.eq (local.get $type) (i32.const ${PTR.CLOSURE})) (i32.eqz (local.get $off)))
+      (then (local.set $off (i32.sub (i32.const -1)
+        (i32.wrap_i64 (i64.and (i64.shr_u (local.get $obj) (i64.const ${LAYOUT.AUX_SHIFT})) (i64.const ${LAYOUT.AUX_MASK})))))))
     (if (i32.eq (local.get $type) (i32.const ${PTR.ARRAY}))
       (then
         (block $done

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)))