jz 0.7.0 → 0.8.1

package/layout.js

@@ -46,6 +46,24 @@ export const ATOM = { NULL: 1, UNDEF: 2, FALSE: 4, TRUE: 5 }
  *  tests membership in one shl+and, replacing a 4-way tag-equality OR. */
 export const FORWARDING_MASK = (1 << PTR.ARRAY) | (1 << PTR.HASH) | (1 << PTR.SET) | (1 << PTR.MAP)
 
+// BigInt views of the NaN-box fields — the carrier is 64-bit, JS bit-ops are 32-bit.
+const TAG_SHIFT = BigInt(LAYOUT.TAG_SHIFT), TAG_MASK = BigInt(LAYOUT.TAG_MASK)
+const AUX_SHIFT = BigInt(LAYOUT.AUX_SHIFT), AUX_MASK = BigInt(LAYOUT.AUX_MASK)
+const OFFSET_MASK = BigInt(LAYOUT.OFFSET_MASK)
+
+/** Format an i64 BigInt as a zero-padded `0x…` hex literal for WAT/IR templates. */
+export const i64Hex = bits => '0x' + bits.toString(16).toUpperCase().padStart(16, '0')
+
+/** Pack (type, aux, offset) into the i64 NaN-box carrier — the single source of
+ *  truth for pointer bit layout. Compiler IR (`packPtrBits`/`mkPtrIR`), the
+ *  `$__mkptr` inline specializer, and the interop high-word encoder all derive
+ *  from this. `offset` defaults to 0 to yield the box prefix (offset OR'd later). */
+export const ptrBits = (type, aux = 0, offset = 0) =>
+  LAYOUT.NAN_PREFIX_BITS
+  | ((BigInt(type) & TAG_MASK) << TAG_SHIFT)
+  | ((BigInt(aux) & AUX_MASK) << AUX_SHIFT)
+  | (BigInt(offset >>> 0) & OFFSET_MASK)
+
 // =============================================================================
 // PTR.TYPED element-type aux codec — which typed-array flavor lives in the aux
 // field of a PTR.TYPED box. Pure (no compiler state) → lives with the NaN-box
@@ -94,20 +112,19 @@ export function ctorFromElemAux(aux) {
   return isView ? `new.${name}.view` : `new.${name}`
 }
 
-/** Host-side high u32 word for NaN-boxed f64 pointer encoding (interop). */
+/** Host-side high u32 word for NaN-boxed f64 pointer encoding (interop) — the
+ *  top 32 bits of `ptrBits(type, aux)` (offset lives in the low word). */
 export const encodePtrHi = (type, aux) =>
-  (0x7FF80000 | ((type & 0xF) << 15) | (aux & 0x7FFF)) >>> 0
+  ((LAYOUT.NAN_PREFIX << 16) | ((type & LAYOUT.TAG_MASK) << (LAYOUT.TAG_SHIFT - 32)) | (aux & LAYOUT.AUX_MASK)) >>> 0
 
-export const decodePtrType = hi => (hi >>> 15) & 0xF
-export const decodePtrAux = hi => hi & 0x7FFF
+export const decodePtrType = hi => (hi >>> (LAYOUT.TAG_SHIFT - 32)) & LAYOUT.TAG_MASK
+export const decodePtrAux = hi => hi & LAYOUT.AUX_MASK
 
 /** i64 NaN-prefix OR-mask for WAT `(i64.const …)` templates. */
-export const nanPrefixHex = () =>
-  '0x' + LAYOUT.NAN_PREFIX_BITS.toString(16).toUpperCase().padStart(16, '0')
+export const nanPrefixHex = () => i64Hex(LAYOUT.NAN_PREFIX_BITS)
 
 /** Atom sentinel as i64 hex (compiler WAT templates). */
-export const atomNanHex = atomId =>
-  '0x' + (LAYOUT.NAN_PREFIX_BITS | (BigInt(atomId) << BigInt(LAYOUT.AUX_SHIFT))).toString(16).toUpperCase().padStart(16, '0')
+export const atomNanHex = atomId => i64Hex(LAYOUT.NAN_PREFIX_BITS | (BigInt(atomId) << AUX_SHIFT))
 
 /** STRING aux bit 0 on a PLAIN-HEAP string (SSO and SLICE clear): this is a
  *  CANONICAL interned string — the static-pool copy (or an intern-table hit
@@ -120,22 +137,16 @@ export const atomNanHex = atomId =>
 export const STR_INTERN_BIT = 0x1
 
 /** Pre-shifted STRING SSO aux bit as i64 hex. */
-export const ssoBitI64Hex = () =>
-  '0x' + (BigInt(LAYOUT.SSO_BIT) << BigInt(LAYOUT.AUX_SHIFT)).toString(16).toUpperCase().padStart(16, '0')
+export const ssoBitI64Hex = () => i64Hex(BigInt(LAYOUT.SSO_BIT) << AUX_SHIFT)
 
 /** Pre-shifted STRING slice/view aux bit as i64 hex. */
-export const sliceBitI64Hex = () =>
-  '0x' + (BigInt(LAYOUT.SLICE_BIT) << BigInt(LAYOUT.AUX_SHIFT)).toString(16).toUpperCase().padStart(16, '0')
+export const sliceBitI64Hex = () => i64Hex(BigInt(LAYOUT.SLICE_BIT) << AUX_SHIFT)
 
 /** Full i64 NaN-box hex for `(i64.const …)` — ptr type + aux, offset OR'd separately. */
-export const ptrNanHex = (ptrType, aux = 0) =>
-  '0x' + ptrBoxPrefixBigInt(ptrType, aux).toString(16).toUpperCase().padStart(16, '0')
+export const ptrNanHex = (ptrType, aux = 0) => i64Hex(ptrBits(ptrType, aux))
 
 /** Compile-time i64 prefix for mkPtrIR (before offset OR). */
-export const ptrBoxPrefixBigInt = (ptrType, aux = 0) =>
-  (0x7FF8n << 48n)
-  | ((BigInt(ptrType) & 0xFn) << 47n)
-  | ((BigInt(aux) & 0x7FFFn) << 32n)
+export const ptrBoxPrefixBigInt = (ptrType, aux = 0) => ptrBits(ptrType, aux)
 
 /** Host-side atom sentinel high-u32 values (interop f64 decode). */
 export const ATOM_HI = {

package/module/array.js

@@ -13,7 +13,7 @@ import { inBoundsArrIdx } from '../src/type.js'
 import { emit, spread, deps, idx as emitIndex } from '../src/bridge.js'
 import { valTypeOf } from '../src/kind.js'
 import { extractParams, classifyParam, ASSIGN_OPS, refsName, REFS_IN_EXPR } from '../src/ast.js'
-import { staticPropertyKey, staticObjectProps, inlineArraySid, staticIndexKey } from '../src/static.js'
+import { staticPropertyKey, staticObjectProps, inlineArraySid, staticIndexKey, intLiteralValue } from '../src/static.js'
 import { VAL, lookupValType, lookupNotString, updateRep } from '../src/reps.js'
 import { structInline } from '../src/abi/index.js'
 import { ctx, inc, err, warnDeopt, PTR, LAYOUT, followForwardingWat } from '../src/ctx.js'
@@ -249,9 +249,9 @@ export default (ctx) => {
       '__ptr_offset',
       ...(needsArrayDynMove() ? ['__dyn_move', '__hash_new', '__ihash_set_local'] : []),
     ],
-    __arr_fill: ['__ptr_offset'],
+    __arr_fill: ['__ptr_offset', '__clamp_idx'],  // body-calls __clamp_idx; declare it (self-host auto-scan can't be relied on — see test/selfhost-includes.js)
     __arr_set_idx_ptr: ['__arr_grow', '__ptr_offset'],
-    __arr_push1: ['__arr_grow_known', '__ptr_offset'],
+    __arr_push1: ['__arr_grow_known', '__ptr_offset_fwd'],
     __arr_set_length: ['__arr_grow_known', '__ptr_offset', '__ptr_type'],
     __arr_unshift: ['__arr_grow', '__len', '__ptr_offset'],
     __arr_splice: ['__arr_grow', '__len', '__ptr_offset', '__alloc_hdr', '__mkptr'],
@@ -333,67 +333,6 @@ export default (ctx) => {
   // Full body handles TYPED element types and view indirection since external host can
   // pass typed arrays even when typedarray module isn't loaded. When features.typedarray
   // and features.external are both off, collapses to ARRAY-only f64 indexing.
-  ctx.core.stdlib['__typed_idx'] = () => {
-    if (!ctx.features.typedarray && !ctx.features.external) {
-      return `(func $__typed_idx (param $ptr i64) (param $i i32) (result f64)
-    (local $len i32)
-    (local.set $len (call $__len (local.get $ptr)))
-    (if (result f64)
-      (i32.or
-        (i32.lt_s (local.get $i) (i32.const 0))
-        (i32.ge_u (local.get $i) (local.get $len)))
-      (then (f64.const nan:${UNDEF_NAN}))
-      (else (f64.load (i32.add (call $__ptr_offset (local.get $ptr)) (i32.shl (local.get $i) (i32.const 3)))))))`
-    }
-    // Hot (~37M calls in watr self-host). Type/aux/offset extracted once from $ptr.
-    return `(func $__typed_idx (param $ptr i64) (param $i i32) (result f64)
-    (local $t i32) (local $off i32) (local $et i32) (local $len i32) (local $aux i32)
-    (local.set $t (i32.wrap_i64 (i64.and (i64.shr_u (local.get $ptr) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK}))))
-    (local.set $off (i32.wrap_i64 (i64.and (local.get $ptr) (i64.const ${LAYOUT.OFFSET_MASK}))))
-    ;; ARRAY fast path: follow forwarding inline, bounds-check against header len, f64.load — no $__len call.
-    (if (i32.and (i32.eq (local.get $t) (i32.const ${PTR.ARRAY})) (i32.ge_u (local.get $off) (i32.const 8)))
-      (then
-        ${followForwardingWat('$off', { lowGuard: false })}
-        (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 (i32.wrap_i64 (i64.and (i64.shr_u (local.get $ptr) (i64.const ${LAYOUT.AUX_SHIFT})) (i64.const ${LAYOUT.AUX_MASK}))))
-    (if
-      (i32.and
-        (i32.eq (local.get $t) (i32.const ${PTR.TYPED}))
-        (i32.ne (i32.and (local.get $aux) (i32.const 8)) (i32.const 0)))
-      (then (local.set $off (i32.load (i32.add (local.get $off) (i32.const 4))))))
-    (local.set $len (call $__len (local.get $ptr)))
-    (if (result f64)
-      (i32.or
-        (i32.lt_s (local.get $i) (i32.const 0))
-        (i32.ge_u (local.get $i) (local.get $len)))
-      (then (f64.const nan:${UNDEF_NAN}))
-      (else
-        (if (result f64) (i32.eq (local.get $t) (i32.const ${PTR.TYPED}))
-          (then
-            (local.set $et (i32.and (local.get $aux) (i32.const 7)))
-            (if (result f64) (i32.ge_u (local.get $et) (i32.const 6))
-              (then (if (result f64) (i32.eq (local.get $et) (i32.const 7))
-                (then (if (result f64) (i32.and (local.get $aux) (i32.const 16))
-                  (then (f64.reinterpret_i64 (i64.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3))))))
-                  (else (f64.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3)))))))
-                (else (f64.promote_f32 (f32.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 2))))))))
-              (else (if (result f64) (i32.ge_u (local.get $et) (i32.const 4))
-                (then (if (result f64) (i32.and (local.get $et) (i32.const 1))
-                  (then (f64.convert_i32_u (i32.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 2))))))
-                  (else (f64.convert_i32_s (i32.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 2))))))))
-                (else (if (result f64) (i32.ge_u (local.get $et) (i32.const 2))
-                  (then (if (result f64) (i32.and (local.get $et) (i32.const 1))
-                    (then (f64.convert_i32_u (i32.load16_u (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 1))))))
-                    (else (f64.convert_i32_s (i32.load16_s (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 1))))))))
-                  (else (if (result f64) (i32.and (local.get $et) (i32.const 1))
-                    (then (f64.convert_i32_u (i32.load8_u (i32.add (local.get $off) (local.get $i)))))
-                    (else (f64.convert_i32_s (i32.load8_s (i32.add (local.get $off) (local.get $i)))))))))))))
-          (else (f64.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3)))))))))`
-  }
-
   // Array.from(src) — shallow copy of array (memory.copy of f64 elements)
   ctx.core.stdlib['__arr_from'] = `(func $__arr_from (param $src i64) (result f64)
     (local $len i32) (local $dst i32)
@@ -576,12 +515,13 @@ export default (ctx) => {
   ctx.core.stdlib['__arr_push1'] = `(func $__arr_push1 (param $ptr i64) (param $val f64) (result f64)
     (local $p f64) (local $base i32) (local $len i32)
     (local.set $p (f64.reinterpret_i64 (local.get $ptr)))
-    (local.set $base (call $__ptr_offset (local.get $ptr)))
+    (local.set $base (i32.wrap_i64 (i64.and (local.get $ptr) (i64.const ${LAYOUT.OFFSET_MASK}))))
+    ${followForwardingWat('$base', { lowGuard: true })}
     (local.set $len (i32.load (i32.sub (local.get $base) (i32.const 8))))
     (if (i32.lt_s (i32.load (i32.sub (local.get $base) (i32.const 4))) (i32.add (local.get $len) (i32.const 1)))
       (then
         (local.set $p (call $__arr_grow_known (local.get $ptr) (i32.add (local.get $len) (i32.const 1))))
-        (local.set $base (call $__ptr_offset (i64.reinterpret_f64 (local.get $p))))))
+        (local.set $base (i32.wrap_i64 (i64.and (i64.reinterpret_f64 (local.get $p)) (i64.const ${LAYOUT.OFFSET_MASK}))))))
     (f64.store (i32.add (local.get $base) (i32.shl (local.get $len) (i32.const 3))) (local.get $val))
     (i32.store (i32.sub (local.get $base) (i32.const 8)) (i32.add (local.get $len) (i32.const 1)))
     (local.get $p))`
@@ -657,6 +597,14 @@ export default (ctx) => {
   // === Index read ===
 
   ctx.core.emit['[]'] = (arr, idx) => {
+    // A literal NEGATIVE index is always out of range → undefined (JS semantics), never a
+    // raw `payload + (-1)*8` load that reads heap before the allocation. A side-effecting
+    // receiver still evaluates. Mirrors VT['[]'] returning null for the same case.
+    { const li = intLiteralValue(idx)
+      if (li != null && li < 0)
+        return typeof arr === 'string'
+          ? undefExpr()
+          : typed(['block', ['result', 'f64'], ['drop', asF64(emit(arr))], undefExpr()], 'f64') }
     // Hoist non-identifier arr so side-effecting sources (e.g. `foo.shift()[i]`) execute once.
     // The rest of the handler inlines `emit(arr)` into multiple IR positions, which would
     // otherwise re-execute the source expression per use at runtime.
@@ -731,6 +679,12 @@ export default (ctx) => {
       return ['f64.reinterpret_i64', ['call', '$__dyn_get', ['i64.reinterpret_f64', objExpr], ['i64.reinterpret_f64', keyExpr]]]
     }
     const stringLoad = () => (inc('__str_idx'), ['call', '$__str_idx', ['i64.reinterpret_f64', ptrExpr], vi])
+    // A numeric index on an unknown receiver is array/typed access by design — kept
+    // lean (no OBJECT/HASH dyn-get fork): an object with numeric keys is a degenerate
+    // pattern not worth a per-access string-coercion + hash probe in every hot loop.
+    // The WRITE path still routes a numeric `o[i]=v` on an OBJECT to __dyn_set for
+    // SAFETY (no schema-slot corruption / OOB), so such a read returns undefined
+    // rather than corrupting — matching JS for an out-of-range typed/array index.
     const arrayLoad = (['call', '$__typed_idx', ['i64.reinterpret_f64', ptrExpr], vi])
     const emitDynamicKeyDispatch = (objExpr, numericLoad) => {
       const keyTmp = temp()
@@ -929,6 +883,10 @@ export default (ctx) => {
 
   // .push(val) → append, increment len, return array (possibly reallocated pointer)
   ctx.core.emit['.push'] = (arr, ...vals) => {
+    // `_expect` is overwritten by recursive emit() calls below. Capture the
+    // statement-position hint now so a dropped `xs.push(v)` can skip computing
+    // the JS return length while still performing the mutation/writeback.
+    const void_ = ctx.func._expect === 'void'
     // structInline Array<S>: `.push({S})` writes the K schema fields as K
     // consecutive f64 cells. Flatten the struct literal into K schema-ordered
     // field-value nodes and fall through to the general multi-value store path
@@ -956,8 +914,10 @@ export default (ctx) => {
       const readVar = box ? ['f64.load', ['local.get', `$${box}`]] : isGlobal ? ['global.get', `$${arr}`] : ['local.get', `$${arr}`]
       const writeVar = v => box ? ['f64.store', ['local.get', `$${box}`], v] : isGlobal ? ['global.set', `$${arr}`, v] : ['local.set', `$${arr}`, v]
       const vv = asF64(emit(vals[0]))
+      const pushed = ['call', '$__arr_push1', ['i64.reinterpret_f64', readVar], vv]
+      if (void_) return typed(['block', writeVar(pushed)], 'void')
       return typed(['block', ['result', 'f64'],
-        writeVar(['call', '$__arr_push1', ['i64.reinterpret_f64', readVar], vv]),
+        writeVar(pushed),
         ['f64.convert_i32_s', ['i32.load', ['i32.sub',
           ['call', '$__ptr_offset', ['i64.reinterpret_f64', readVar]], ['i32.const', 8]]]]], 'f64')
     }
@@ -1109,12 +1069,8 @@ export default (ctx) => {
         (if (i32.ge_u (local.get $off) (i32.const 8))
           (then
             (local.set $len (i32.load (i32.sub (local.get $off) (i32.const 8))))
-            (if (i32.lt_s (local.get $start) (i32.const 0)) (then (local.set $start (i32.add (local.get $len) (local.get $start)))))
-            (if (i32.lt_s (local.get $start) (i32.const 0)) (then (local.set $start (i32.const 0))))
-            (if (i32.gt_s (local.get $start) (local.get $len)) (then (local.set $start (local.get $len))))
-            (if (i32.lt_s (local.get $end) (i32.const 0)) (then (local.set $end (i32.add (local.get $len) (local.get $end)))))
-            (if (i32.lt_s (local.get $end) (i32.const 0)) (then (local.set $end (i32.const 0))))
-            (if (i32.gt_s (local.get $end) (local.get $len)) (then (local.set $end (local.get $len))))
+            (local.set $start (call $__clamp_idx (local.get $start) (local.get $len)))
+            (local.set $end (call $__clamp_idx (local.get $end) (local.get $len)))
             (local.set $i (local.get $start))
             (block $done (loop $fill
               (br_if $done (i32.ge_s (local.get $i) (local.get $end)))
@@ -1764,6 +1720,26 @@ export default (ctx) => {
       ['f64.convert_i32_s', ['local.get', `$${result}`]]], 'f64')
   }
 
+  // Mirror of .indexOf scanning to the highest matching index — no early break, the last hit wins.
+  // Registering it (alongside .string:lastIndexOf) is what lets lastIndexOf leave STRING_ONLY_METHODS:
+  // an untyped receiver now forks string-vs-array at runtime instead of force-narrowing to string
+  // (which returned -1 for every array). fromIndex is unsupported, matching .indexOf's array path.
+  ctx.core.emit['.lastIndexOf'] = (arr, val) => {
+    const recv = hoistArrayValue(arr)
+    const vv = asF64(emit(val))
+    const eq = arrEqIR(val)
+    const result = tempI32('lx')
+    const loop = arrayLoop(recv.value, (_ptr, _len, i, item) => [
+      ['if', eq(item, vv),
+        ['then', ['local.set', `$${result}`, ['local.get', `$${i}`]]]]
+    ])
+    return typed(['block', ['result', 'f64'],
+      recv.setup,
+      ['local.set', `$${result}`, ['i32.const', -1]],
+      ...loop,
+      ['f64.convert_i32_s', ['local.get', `$${result}`]]], 'f64')
+  }
+
   // .at(i) → array element with negative index support
   ctx.core.emit['.array:at'] = (arr, idx) => {
     const vt = typeof arr === 'string' ? lookupValType(arr) : valTypeOf(arr)

package/module/collection.js

@@ -12,8 +12,8 @@ import { typed, asF64, asI64, asI32, NULL_NAN, UNDEF_NAN, temp, tempI32, tempI64
 import { emit, deps, call } from '../src/bridge.js'
 import { valTypeOf } from '../src/kind.js'
 import { VAL, lookupValType } from '../src/reps.js'
-import { hasOwnContinue, isBlockBody } from '../src/ast.js'
-import { ctx, inc, PTR, LAYOUT, getter, declGlobal } from '../src/ctx.js'
+import { hasOwnContinue, isBlockBody, isLiteralStr } from '../src/ast.js'
+import { ctx, inc, PTR, LAYOUT, registerGetter, declGlobal } from '../src/ctx.js'
 import { STR_INTERN_BIT } from '../layout.js'
 
 const SET_ENTRY = 16  // hash + key
@@ -43,6 +43,20 @@ function numConstLiteral(expr) {
   return null
 }
 
+// Compile-time probe hash for a LITERAL collection/property key, else null. A numeric
+// constant → numHashLiteral; an ASCII string literal → strHashLiteral. The string case is
+// ASCII-only on purpose: strHashLiteral folds `charCodeAt(i) & 0xFF`, which equals __str_hash /
+// __map_hash (FNV-1a over the UTF-8 bytes) ONLY for code points < 0x80 — a non-ASCII literal
+// would fold a different hash than its stored key and silently miss, so it falls back to the
+// runtime hash. Lets `m.get("if")` / `m.has("x")` skip the per-access __map_hash call.
+const ASCII_KEY = /^[\x00-\x7f]*$/
+const litKeyHash = (key) => {
+  const num = numConstLiteral(key)
+  if (num != null) return numHashLiteral(num)
+  if (isLiteralStr(key) && ASCII_KEY.test(key[1])) return strHashLiteral(key[1])
+  return null
+}
+
 // Equality expressions for probe templates
 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))'
@@ -55,9 +69,22 @@ const strEq = '(call $__str_eq (i64.load (i32.add (local.get $slot) (i32.const 8
 // walking shared-prefix bytes through __str_eq (31M unequal content-compares
 // per self-host bench run before this). If-expression for short-circuit:
 // i32.and would still evaluate the call.
+//
+// On a hash hit, an inline `storedKey == queryKey` (one i64.eq on the slot's key
+// word) decides the overwhelmingly-common identity case — interned/SSO literals and
+// the same heap pointer are bit-equal — WITHOUT the __str_eq / __same_value_zero call
+// frame. Sound for both: bit-equality implies string-equality and SameValueZero (the
+// only cross-bit-pattern equals — +0/-0, distinct NaN payloads — fall through to the
+// full compare, never the reverse). Only a content-equal-but-bit-distinct key (a heap
+// string vs a literal) still pays the call. This attacks the __str_eq call tax directly
+// and helps the runtimes that DON'T inline tiny callees (wasmtime, wasm2c).
 const hashGuard = (eqExpr) =>
   `(if (result i32) (i32.eq (i32.load (local.get $slot)) (local.get $h))
-    (then ${eqExpr}) (else (i32.const 0)))`
+    (then (if (result i32)
+        (i64.eq (i64.load (i32.add (local.get $slot) (i32.const 8))) (local.get $key))
+        (then (i32.const 1))
+        (else ${eqExpr})))
+    (else (i32.const 0)))`
 const strEqG = hashGuard(strEq)
 const sameValueZeroEqG = hashGuard(sameValueZeroEq)
 
@@ -367,34 +394,39 @@ function genLookupStrict(name, entrySize, hashFn, eqExpr, expectedType, missing
     (i64.const ${missing}))`
 }
 
-function genLookupStrictPrehashed(name, entrySize, eqExpr, expectedType, missing = UNDEF_NAN, hasExt = false) {
+// wantValue=true (default): return the slot value, missing → `missing` (i64). wantValue=false:
+// return an i32 0/1 existence flag (for `.has`). Mirrors genLookup's two-mode shape, prehashed.
+function genLookupStrictPrehashed(name, entrySize, eqExpr, expectedType, missing = UNDEF_NAN, hasExt = false, wantValue = true) {
+  const rt = wantValue ? 'i64' : 'i32'
+  const onEmpty = wantValue ? `(return (i64.const ${missing}))` : '(return (i32.const 0))'
+  const onFound = wantValue ? '(return (i64.load (i32.add (local.get $slot) (i32.const 16))))' : '(return (i32.const 1))'
+  const notFound = wantValue ? `(i64.const ${missing})` : '(i32.const 0)'
+  const extHit = wantValue ? '(call $__ext_prop (local.get $coll) (local.get $key))' : '(call $__ext_has (local.get $coll) (local.get $key))'
   const tExpr = `(i32.wrap_i64 (i64.and (i64.shr_u (local.get $coll) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK})))`
   const typeGuard = hasExt
     ? `(if (i32.ne ${tExpr} (i32.const ${expectedType}))
       (then
         (if (i32.eq ${tExpr} (i32.const ${PTR.EXTERNAL}))
-          (then (return (call $__ext_prop (local.get $coll) (local.get $key))))
-          (else (return (i64.const ${missing}))))))`
+          (then (return ${extHit}))
+          (else ${onEmpty}))))`
     : `(if (i32.ne ${tExpr} (i32.const ${expectedType}))
-      (then (return (i64.const ${missing}))))`
+      (then ${onEmpty}))`
   // SET/MAP/HASH grow by forward-marking; a boxed pointer may be stale → follow the chain.
   const offExpr = '(call $__ptr_offset (local.get $coll))'
-  return `(func $${name} (param $coll i64) (param $key i64) (param $h i32) (result i64)
+  return `(func $${name} (param $coll i64) (param $key i64) (param $h i32) (result ${rt})
     (local $off i32) (local $cap i32) (local $end i32) (local $slot i32) (local $tries i32)
     ${typeGuard}
     (local.set $off ${offExpr})
     (local.set $cap (i32.load (i32.sub (local.get $off) (i32.const 4))))
     ${probeStart(entrySize)}
     (block $done (loop $probe
-      (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))))))
+      (if (i64.eqz (i64.load (local.get $slot))) (then ${onEmpty}))
+      (if ${eqExpr} (then ${onFound}))
       ${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)))
-    (i64.const ${missing}))`
+    ${notFound})`
 }
 
 function genUpsertStrictPrehashed(name, entrySize, eqExpr, expectedType) {
@@ -440,6 +472,9 @@ export default (ctx) => {
     __map_get: () => ctx.features.external ? ['__ext_prop', '__map_set', '__ptr_offset'] : ['__map_set', '__ptr_offset'],
     __map_get_h: () => ctx.features.external ? ['__ext_prop', '__same_value_zero', '__ptr_offset'] : ['__same_value_zero', '__ptr_offset'],
     __map_has: () => ctx.features.external ? ['__map_hash', '__same_value_zero', '__ptr_offset', '__ext_has'] : ['__map_hash', '__same_value_zero', '__ptr_offset'],
+    // Prehashed has-probes: caller folds the hash, so no __map_hash dependency.
+    __map_has_h: () => ctx.features.external ? ['__same_value_zero', '__ptr_offset', '__ext_has'] : ['__same_value_zero', '__ptr_offset'],
+    __set_has_h: () => ctx.features.external ? ['__same_value_zero', '__ptr_offset', '__ext_has'] : ['__same_value_zero', '__ptr_offset'],
     __map_delete: ['__map_hash', '__same_value_zero'],
     __map_from: ['__ptr_type', '__ptr_offset', '__len', '__typed_idx', '__map_set', '__mkptr', '__alloc_hdr_n', '__coll_order'],
     __hash_set: () => ctx.features.external
@@ -628,20 +663,35 @@ export default (ctx) => {
   // the Set probe carries a PTR.SET type guard that rejects a Map outright, so
   // routing a Map through `__set_has`/`__set_delete` makes every lookup/delete
   // silently report absent. Mirrors collViewDyn below; typed receivers skip it.
-  const collProbeDyn = (mapFn, setFn) => (collExpr, key) => {
+  // `h` (optional precomputed key hash) appends to the call → routes to the `_h` prehashed
+  // probes, skipping __map_hash per access; omitted → the generic hashing probes.
+  const collProbeDyn = (mapFn, setFn) => (collExpr, key, h) => {
     inc(mapFn, setFn, '__ptr_type')
     const o = temp('cp'), k = tempI64('cpk')
+    const extra = h != null ? [['i32.const', h]] : []
     return typed(['block', ['result', 'f64'],
       ['local.set', `$${o}`, asF64(emit(collExpr))],
       ['local.set', `$${k}`, asI64(emit(key))],
       ['f64.convert_i32_s', ['if', ['result', 'i32'],
         ptrTypeEq(['local.get', `$${o}`], PTR.MAP),
-        ['then', ['call', `$${mapFn}`, ['i64.reinterpret_f64', ['local.get', `$${o}`]], ['local.get', `$${k}`]]],
-        ['else', ['call', `$${setFn}`, ['i64.reinterpret_f64', ['local.get', `$${o}`]], ['local.get', `$${k}`]]]]]], 'f64')
+        ['then', ['call', `$${mapFn}`, ['i64.reinterpret_f64', ['local.get', `$${o}`]], ['local.get', `$${k}`], ...extra]],
+        ['else', ['call', `$${setFn}`, ['i64.reinterpret_f64', ['local.get', `$${o}`]], ['local.get', `$${k}`], ...extra]]]]], 'f64')
+  }
+  // `.has` on an unproven receiver: a literal key folds its hash and uses the _h probes.
+  ctx.core.emit['.has'] = (collExpr, key) => {
+    const h = litKeyHash(key)
+    return h != null
+      ? collProbeDyn('__map_has_h', '__set_has_h')(collExpr, key, h)
+      : collProbeDyn('__map_has', '__set_has')(collExpr, key)
   }
-  ctx.core.emit['.has'] = collProbeDyn('__map_has', '__set_has')
   ctx.core.emit['.delete'] = collProbeDyn('__map_delete', '__set_delete')
-  ctx.core.emit[`.${VAL.SET}:has`] = call('__set_has', 'II', 'i32')
+  // Typed Set.has: literal key → prehashed __set_has_h, else the generic probe.
+  ctx.core.emit[`.${VAL.SET}:has`] = (collExpr, key) => {
+    const h = litKeyHash(key)
+    if (h == null) return call('__set_has', 'II', 'i32')(collExpr, key)
+    inc('__set_has_h')
+    return typed(['f64.convert_i32_s', ['call', '$__set_has_h', asI64(emit(collExpr)), asI64(emit(key)), ['i32.const', h]]], 'f64')
+  }
   ctx.core.emit[`.${VAL.SET}:delete`] = call('__set_delete', 'II', 'i32')
 
   // Map.prototype.clear / Set.prototype.clear — drop every entry. `.clear` only
@@ -666,7 +716,7 @@ export default (ctx) => {
         (i32.store (i32.sub (local.get $off) (i32.const 8)) (i32.const 0))))
     (f64.reinterpret_i64 (i64.const ${UNDEF_NAN})))`
 
-  ctx.core.emit['.size'] = getter((expr) => {
+  registerGetter('.size', (expr) => {
     return typed(['f64.convert_i32_s', ['call', '$__len', ['i64.reinterpret_f64', asF64(emit(expr))]]], 'f64')
   })
 
@@ -691,6 +741,7 @@ export default (ctx) => {
   // Generated Set probe functions
   ctx.core.stdlib['__set_add'] = () => genUpsert('__set_add', SET_ENTRY, '$__map_hash', sameValueZeroEqG, PTR.SET, false, ctx.features.external)
   ctx.core.stdlib['__set_has'] = () => genLookup('__set_has', SET_ENTRY, '$__map_hash', sameValueZeroEqG, PTR.SET, false, ctx.features.external)
+  ctx.core.stdlib['__set_has_h'] = () => genLookupStrictPrehashed('__set_has_h', SET_ENTRY, sameValueZeroEqG, PTR.SET, UNDEF_NAN, ctx.features.external, false)
   ctx.core.stdlib['__set_delete'] = genDelete('__set_delete', SET_ENTRY, '$__map_hash', sameValueZeroEqG, PTR.SET)
 
   // === Map ===
@@ -717,10 +768,10 @@ export default (ctx) => {
   ctx.core.emit[`.${VAL.MAP}:set`] = ctx.core.emit['.set']
 
   const emitMapGet = (mapExpr, key) => {
-    const constKey = numConstLiteral(key)
-    if (constKey != null) {
+    const h = litKeyHash(key)
+    if (h != null) {
       inc('__map_get_h')
-      return typed(['f64.reinterpret_i64', ['call', '$__map_get_h', asI64(emit(mapExpr)), asI64(emit(key)), ['i32.const', numHashLiteral(constKey)]]], 'f64')
+      return typed(['f64.reinterpret_i64', ['call', '$__map_get_h', asI64(emit(mapExpr)), asI64(emit(key)), ['i32.const', h]]], 'f64')
     }
     inc('__map_get')
     return typed(['f64.reinterpret_i64', ['call', '$__map_get', asI64(emit(mapExpr)), asI64(emit(key))]], 'f64')
@@ -729,7 +780,13 @@ export default (ctx) => {
   ctx.core.emit['.get'] = emitMapGet
   ctx.core.emit[`.${VAL.MAP}:get`] = emitMapGet
 
-  ctx.core.emit[`.${VAL.MAP}:has`] = call('__map_has', 'II', 'i32')
+  // Typed Map.has: literal key → prehashed __map_has_h, else the generic probe.
+  ctx.core.emit[`.${VAL.MAP}:has`] = (collExpr, key) => {
+    const h = litKeyHash(key)
+    if (h == null) return call('__map_has', 'II', 'i32')(collExpr, key)
+    inc('__map_has_h')
+    return typed(['f64.convert_i32_s', ['call', '$__map_has_h', asI64(emit(collExpr)), asI64(emit(key)), ['i32.const', h]]], 'f64')
+  }
   ctx.core.emit[`.${VAL.MAP}:delete`] = call('__map_delete', 'II', 'i32')
 
   // Map/Set iteration views: keys() / values() / entries() materialize a dense
@@ -815,6 +872,7 @@ export default (ctx) => {
   ctx.core.stdlib['__map_set'] = () => genUpsert('__map_set', MAP_ENTRY, '$__map_hash', sameValueZeroEqG, PTR.MAP, true, ctx.features.external)
   ctx.core.stdlib['__map_get'] = () => genLookup('__map_get', MAP_ENTRY, '$__map_hash', sameValueZeroEqG, PTR.MAP, true, ctx.features.external)
   ctx.core.stdlib['__map_get_h'] = () => genLookupStrictPrehashed('__map_get_h', MAP_ENTRY, sameValueZeroEqG, PTR.MAP, UNDEF_NAN, ctx.features.external)
+  ctx.core.stdlib['__map_has_h'] = () => genLookupStrictPrehashed('__map_has_h', MAP_ENTRY, sameValueZeroEqG, PTR.MAP, UNDEF_NAN, ctx.features.external, false)
   ctx.core.stdlib['__map_has'] = () => genLookup('__map_has', MAP_ENTRY, '$__map_hash', sameValueZeroEqG, PTR.MAP, false, ctx.features.external)
   ctx.core.stdlib['__map_delete'] = genDelete('__map_delete', MAP_ENTRY, '$__map_hash', sameValueZeroEqG, PTR.MAP)
 
@@ -877,12 +935,12 @@ export default (ctx) => {
     (local.set $aux (i32.wrap_i64 (i64.and (i64.shr_u (local.get $s) (i64.const ${LAYOUT.AUX_SHIFT})) (i64.const ${LAYOUT.AUX_MASK}))))
     (if (i32.and (i32.eq (local.get $t) (i32.const ${PTR.STRING})) (i32.shr_u (local.get $aux) (i32.const 14)))
       (then
-        (local.set $len (i32.and (local.get $aux) (i32.const 7)))
+        (local.set $len (i32.and (i32.shr_u (local.get $aux) (i32.const 10)) (i32.const 7)))
         (block $ds (loop $ls
           (br_if $ds (i32.ge_s (local.get $i) (local.get $len)))
           (local.set $h (i32.mul
             (i32.xor (local.get $h)
-              (i32.and (i32.shr_u (local.get $off) (i32.shl (local.get $i) (i32.const 3))) (i32.const 0xFF)))
+              (i32.wrap_i64 (i64.and (i64.shr_u (local.get $s) (i64.mul (i64.extend_i32_u (local.get $i)) (i64.const 7))) (i64.const 0x7f))))
             (i32.const 0x01000193)))
           (local.set $i (i32.add (local.get $i) (i32.const 1)))
           (br $ls))))

package/module/console.js

@@ -69,7 +69,7 @@ const setupWasi = (ctx) => {
     (local.set $aux (call $__ptr_aux (local.get $ptr)))
     (if (i32.and (local.get $aux) (i32.const ${LAYOUT.SSO_BIT}))
       (then
-        (local.set $len (i32.and (local.get $aux) (i32.const 7)))
+        (local.set $len (i32.and (i32.shr_u (local.get $aux) (i32.const 10)) (i32.const 7)))
         (local.set $buf (call $__alloc (local.get $len)))
         (local.set $off (i32.const 0))
         (block $done (loop $loop