jz 0.6.0 → 0.8.0

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
@@ -752,22 +809,30 @@ export default (ctx) => {
   // statically proven (e.g. a Map read off an object field): resolve MAP vs SET
   // vs ARRAY once at runtime. ARRAY.values() is the array itself; .keys() yields
   // indices; .entries() yields [i, el]. Any other receiver passes through.
-  const collViewDyn = (mapWalk, setWalk, arrWalk) => (expr) => {
+  // A typed array (PTR.TYPED) is NOT PTR.ARRAY, so without an explicit branch it fell
+  // through to `local.get $t` (return the receiver). For .values that is correct (the
+  // receiver iterates its values), but .keys then yielded values instead of indices and
+  // .entries yielded scalars instead of [i, value] pairs. The typedWalk arg restores the
+  // right behavior for typed receivers (keys → index array, entries → typed-aware pairs).
+  const collViewDyn = (mapWalk, setWalk, arrWalk, typedWalk) => (expr) => {
     inc('__ptr_type')
     const t = temp('cd')
     const pt = () => ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]
     const branch = (tag, walk, rest) =>
       ['if', ['result', 'f64'], ['i32.eq', pt(), ['i32.const', tag]], ['then', walk(t)], ['else', rest]]
     const tree = branch(PTR.MAP, mapWalk, branch(PTR.SET, setWalk,
-      branch(PTR.ARRAY, arrWalk, ['local.get', `$${t}`])))
+      branch(PTR.ARRAY, arrWalk, branch(PTR.TYPED, typedWalk, ['local.get', `$${t}`]))))
     return typed(['block', ['result', 'f64'], ['local.set', `$${t}`, asF64(emit(expr))], tree], 'f64')
   }
+  // keys: index array [0..len-1] for both plain and typed (length-based, no element reads).
   ctx.core.emit['.keys'] = collViewDyn(
-    t => collKeysFromTemp(t, MAP_ENTRY, 8), t => collKeysFromTemp(t, SET_ENTRY, 8), arrIdxFromTemp)
+    t => collKeysFromTemp(t, MAP_ENTRY, 8), t => collKeysFromTemp(t, SET_ENTRY, 8), arrIdxFromTemp, arrIdxFromTemp)
+  // values: the receiver iterates its own elements (correct for plain and typed alike).
   ctx.core.emit['.values'] = collViewDyn(
-    t => collKeysFromTemp(t, MAP_ENTRY, 16), t => collKeysFromTemp(t, SET_ENTRY, 8), t => ['local.get', `$${t}`])
+    t => collKeysFromTemp(t, MAP_ENTRY, 16), t => collKeysFromTemp(t, SET_ENTRY, 8), t => ['local.get', `$${t}`], t => ['local.get', `$${t}`])
+  // entries: [i, element] pairs; the typed variant reads elements width/kind-aware.
   ctx.core.emit['.entries'] = collViewDyn(
-    t => collEntriesFromTemp(t, MAP_ENTRY, 8, 16), t => collEntriesFromTemp(t, SET_ENTRY, 8, 8), arrEntriesFromTemp)
+    t => collEntriesFromTemp(t, MAP_ENTRY, 8, 16), t => collEntriesFromTemp(t, SET_ENTRY, 8, 8), arrEntriesFromTemp, arrEntriesFromTempTyped)
 
   // Map/Set forEach(cb): invoke cb(value, key) per live entry in insertion order.
   // Map yields (value=val@16, key=key@8); Set yields (value=key@8, key@8) — the
@@ -807,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)
 
@@ -869,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))))
@@ -1754,3 +1820,31 @@ function arrEntriesFromTemp(t) {
       ['br', `$aeloop${id}`]]],
     out.ptr]
 }
+
+// TypedArray.prototype.entries() → dense Array of [index, element] pairs, reading each
+// element width/kind-aware via __typed_get_idx (the plain arrEntriesFromTemp uses a raw
+// f64.load, wrong for non-f64 typed arrays). Guarded on __typed_get_idx being registered:
+// it only is when the typedarray module is loaded, which is exactly when a PTR.TYPED
+// value can exist — so when absent, this branch is dead and falls back to the receiver.
+function arrEntriesFromTempTyped(t) {
+  if (!ctx.core.stdlib['__typed_get_idx']) return ['local.get', `$${t}`]
+  inc('__len', '__typed_get_idx', '__alloc_hdr')
+  const n = tempI32('aetn'), i = tempI32('aeti'), pair = tempI32('aetp')
+  const out = allocPtr({ type: PTR.ARRAY, len: ['local.get', `$${n}`], tag: 'aet' })
+  const id = ctx.func.uniq++
+  const P = () => ['i64.reinterpret_f64', ['local.get', `$${t}`]]
+  return ['block', ['result', 'f64'],
+    ['local.set', `$${n}`, ['call', '$__len', P()]],
+    out.init,
+    ['local.set', `$${i}`, ['i32.const', 0]],
+    ['block', `$aetbrk${id}`, ['loop', `$aetloop${id}`,
+      ['br_if', `$aetbrk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${n}`]]],
+      ['local.set', `$${pair}`, ['call', '$__alloc_hdr', ['i32.const', 2], ['i32.const', 2]]],
+      ['f64.store', ['local.get', `$${pair}`], ['f64.convert_i32_s', ['local.get', `$${i}`]]],
+      ['f64.store', ['i32.add', ['local.get', `$${pair}`], ['i32.const', 8]],
+        ['call', '$__typed_get_idx', P(), ['local.get', `$${i}`]]],
+      elemStore(out.local, i, mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${pair}`])),
+      ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+      ['br', `$aetloop${id}`]]],
+    out.ptr]
+}

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

package/module/core.js

@@ -10,13 +10,13 @@
  */
 
 import { typed, asF64, asI32, asI64, NULL_NAN, UNDEF_NAN, FALSE_NAN, TRUE_NAN, temp, usesDynProps, ptrOffsetIR, isNullish, valKindToPtr, sidecarOverride, undefExpr } from '../src/ir.js'
-import { emit, spread, deps } from '../src/bridge.js'
+import { emit, spread, deps, wat } from '../src/bridge.js'
 import { reconstructArgsWithSpreads } from '../src/ir.js'
 import { valTypeOf, shapeOf } from '../src/kind.js'
 import { T } from '../src/ast.js'
 import { inlineArraySid } from '../src/static.js'
 import { VAL, lookupValType, lookupNotString, repOf, updateRep } from '../src/reps.js'
-import { ctx, err, inc, PTR, LAYOUT, HEAP, emitArity, followForwardingWat, declGlobal } from '../src/ctx.js'
+import { ctx, err, inc, PTR, LAYOUT, HEAP, FORWARDING_MASK, emitArity, followForwardingWat, declGlobal } from '../src/ctx.js'
 import { ptrOffsetFwdWat, STR_INTERN_BIT } from '../layout.js'
 import { nanPrefixHex } from '../layout.js'
 import { initSchema } from './schema.js'
@@ -36,11 +36,12 @@ export default (ctx) => {
     __is_str_key: ['__ptr_type'],
     __str_len: ['__ptr_type', '__ptr_offset', '__ptr_aux'],
     __set_len: ['__ptr_offset_fwd'],
-    __length: ['__ptr_type', '__ptr_offset', '__str_len', '__len'],
+    __length: ['__ptr_type', '__str_len', '__len'],
     __alloc: ['__memgrow'],
     __alloc_hdr: ['__alloc'],
     __alloc_hdr_n: ['__alloc'],
     __coll_order: ['__alloc'],
+    __obj_clone: ['__ptr_type', '__ptr_aux', '__ptr_offset', '__len', '__cap', '__alloc_hdr', '__alloc_hdr_n', '__mkptr'],
   })
 
   ctx.core.stdlib['__is_nullish'] = `(func $__is_nullish (param $v i64) (result i32)
@@ -143,6 +144,79 @@ export default (ctx) => {
           (i64.shl (i64.and (i64.extend_i32_u (local.get $aux)) (i64.const ${LAYOUT.AUX_MASK})) (i64.const ${LAYOUT.AUX_SHIFT}))
           (i64.and (i64.extend_i32_u (local.get $offset)) (i64.const ${LAYOUT.OFFSET_MASK})))))))`
 
+  // Relative-index clamp to `[0, len]` — the JS `RelativeIndex`/`ToIntegerOrInfinity`
+  // bounds dance shared by slice/subarray/fill/copyWithin (string + typed + array).
+  // Single shared body so N method bodies don't each inline the same six branches.
+  wat('__clamp_idx', `(func $__clamp_idx (param $v i32) (param $len i32) (result i32)
+    (if (i32.lt_s (local.get $v) (i32.const 0)) (then (local.set $v (i32.add (local.get $v) (local.get $len)))))
+    (if (i32.lt_s (local.get $v) (i32.const 0)) (then (local.set $v (i32.const 0))))
+    (if (i32.gt_s (local.get $v) (local.get $len)) (then (local.set $v (local.get $len))))
+    (local.get $v))`)
+
+  // Polymorphic element read for any heap-indexable (ARRAY or TYPED). The one
+  // home for `arr[i]` lowering: ARRAY and typed reads both route here, plain-array
+  // programs get the ARRAY-only collapse, typed programs the full elem dispatch.
+  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)))))))))`
+  }
+
   ctx.core.stdlib['__ptr_offset_fwd'] = ptrOffsetFwdWat()
 
   ctx.core.stdlib['__ptr_offset'] = `(func $__ptr_offset (param $ptr i64) (result i32)
@@ -153,9 +227,7 @@ export default (ctx) => {
     ;; (cap=-1 sentinel at -4, new offset at -8). Other types never forward, so they skip
     ;; the loop; a well-formed ptr without forwarding pays one bounds + cap check per hop.
     (local.set $t (i32.wrap_i64 (i64.and (i64.shr_u (local.get $bits) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK}))))
-    (if (i32.or (i32.eq (local.get $t) (i32.const ${PTR.ARRAY}))
-          (i32.or (i32.eq (local.get $t) (i32.const ${PTR.HASH}))
-            (i32.or (i32.eq (local.get $t) (i32.const ${PTR.SET})) (i32.eq (local.get $t) (i32.const ${PTR.MAP})))))
+    (if (i32.and (i32.shl (i32.const 1) (local.get $t)) (i32.const ${FORWARDING_MASK}))
       (then
         ${followForwardingWat('$off', { lowGuard: true })}))
     (local.get $off))`
@@ -257,12 +329,29 @@ export default (ctx) => {
       (call $__memgrow (local.get $next))
       (i32.store (i32.const ${HEAP.PTR_ADDR}) (local.get $next))
       (local.get $ptr))`
+    // NOTE: shared memory rewinds to the raw HEAP.START, NOT a post-init high-water
+    // mark — so a shared module whose `__start` heap-allocates (strPool memory.init,
+    // module-init state) loses that state on `_clear`. Pre-existing; unlike the owned
+    // path below it has no `__heap_reset` analogue because the rewind target would need
+    // a reserved low-memory cell (the [0,HEAP.START) region is already spoken for —
+    // clock at 0, heap ptr at HEAP.PTR_ADDR). Owned memory (the self-host + default
+    // case) is the one fixed below; revisit shared if a thread-pooled reset hits it.
     ctx.core.stdlib['__clear'] = `(func $__clear
       (i32.store (i32.const ${HEAP.PTR_ADDR}) (i32.const ${HEAP.START})))`
   } else {
     // Own memory: heap offset in a global, exported so the JS-side adapter
     // (alloc:false, no `_alloc` export) shares the pointer.
     declGlobal('__heap', 'i32', HEAP.START, { export: '__heap' })
+    // `__clear` rewinds to the *post-module-init* high-water mark, not the static
+    // data end: a module whose top-level code heap-allocates (e.g. the self-host
+    // compiler building its GLOBALS/atom tables in `__start`) leaves live state
+    // above the data segment that a reset must preserve. `__heap_reset` is seeded
+    // to the data end (assemble.js heapBase patch) and overwritten by `__start`'s
+    // tail with the heap top after init runs (buildStartFn) — so for a module with
+    // no init allocations it equals the data end, and for self-host it spares the
+    // compiler's init state. (Distinct from `__heap_start`, the propsPtr watermark,
+    // which must stay at the data end or init-time heap objects misread as static.)
+    declGlobal('__heap_reset', 'i32', HEAP.START)
     ctx.core.stdlib['__alloc'] = `(func $__alloc (param $bytes i32) (result i32)
       (local $ptr i32) (local $next i32)
       (local.set $ptr (global.get $__heap))
@@ -271,7 +360,7 @@ export default (ctx) => {
       (global.set $__heap (local.get $next))
       (local.get $ptr))`
     ctx.core.stdlib['__clear'] = `(func $__clear
-      (global.set $__heap (i32.const ${HEAP.START})))`
+      (global.set $__heap (global.get $__heap_reset)))`
   }
 
   // Build an insertion-ordered list of live slot offsets for a Set/Map/HASH
@@ -409,14 +498,15 @@ export default (ctx) => {
           (else (i32.load (i32.sub (local.get $off) (i32.const 4))))))
       (else (i32.const 0))))`
 
-  // String length (UTF-8 byte count). Heap: [-4:len(i32)][chars...]; SSO: aux & 7.
+  // String length (UTF-8 byte count). Heap: [-4:len(i32)][chars...]; SSO (7-bit codec):
+  // len at aux bits 10-12 (= payload bits 42-44). See module/string.js codec.
   ctx.core.stdlib['__str_len'] = `(func $__str_len (param $ptr i64) (result i32)
     (local $off i32) (local $aux i32)
     (if (i32.ne (call $__ptr_type (local.get $ptr)) (i32.const ${PTR.STRING}))
       (then (return (i32.const 0))))
     (local.set $aux (call $__ptr_aux (local.get $ptr)))
     (if (i32.and (local.get $aux) (i32.const ${LAYOUT.SSO_BIT}))
-      (then (return (i32.and (local.get $aux) (i32.const 7)))))
+      (then (return (i32.and (i32.shr_u (local.get $aux) (i32.const 10)) (i32.const 7)))))
     (local.set $off (call $__ptr_offset (local.get $ptr)))
     (if (result i32) (i32.ge_u (local.get $off) (i32.const 4))
       (then (i32.load (i32.sub (local.get $off) (i32.const 4))))
@@ -477,6 +567,56 @@ export default (ctx) => {
     (memory.fill (i32.add (local.get $ptr) (i32.const 16)) (i32.const 0) (i32.mul (local.get $cap) (local.get $stride)))
     (i32.add (local.get $ptr) (i32.const 16)))`
 
+  // Shallow clone of an OBJECT or HASH, preserving its runtime type — the copy
+  // semantics of a single unknown spread `{ ...src }` (module/object.js). Without
+  // this, `{ ...src }` aliases src, so any later write to the result mutates the
+  // source (a real bug: jz's own narrow.js had to route around it). Per JS spread,
+  // the clone is SHALLOW: scalar slots are copied by value; nested object/string
+  // pointers are shared (immutable strings; nested objects are aliased as in V8).
+  //
+  //  - OBJECT: alloc a fresh header'd object with the same schemaId and copy its N
+  //    schema slots (N = key count of __schema_tbl[sid], robust to static-segment
+  //    sources that carry no len/cap header). Then deep-copy the per-instance
+  //    dyn-props HASH (base-16) so `o[k]=v` keys added before the spread carry over
+  //    independently — heap objects only; static-segment objects have no header.
+  //  - HASH: copy header + every probe slot wholesale (entries hold immutable
+  //    string keys + scalar/pointer values — a byte copy is an independent dict).
+  //  - anything else (primitive): nothing to clone, return as-is.
+  ctx.core.stdlib['__obj_clone'] = `(func $__obj_clone (param $v f64) (result f64)
+    (local $bits i64) (local $t i32) (local $sid i32) (local $n i32) (local $cap i32)
+    (local $src i32) (local $dst i32) (local $props i64)
+    (local.set $bits (i64.reinterpret_f64 (local.get $v)))
+    (local.set $t (call $__ptr_type (local.get $bits)))
+    (if (i32.eq (local.get $t) (i32.const ${PTR.OBJECT}))
+      (then
+        (local.set $sid (call $__ptr_aux (local.get $bits)))
+        (local.set $src (call $__ptr_offset (local.get $bits)))
+        (local.set $n (i32.const 0))
+        (if (i32.ne (global.get $__schema_tbl) (i32.const 0))
+          (then (local.set $n (call $__len
+            (i64.load (i32.add (global.get $__schema_tbl) (i32.shl (local.get $sid) (i32.const 3))))))))
+        (local.set $cap (i32.add (local.get $n) (i32.eqz (local.get $n))))
+        (local.set $dst (call $__alloc_hdr (i32.const 0) (local.get $cap)))
+        (memory.copy (local.get $dst) (local.get $src) (i32.shl (local.get $n) (i32.const 3)))
+        (if (i32.ge_u (local.get $src) (global.get $__heap_start))
+          (then
+            (local.set $props (i64.load (i32.sub (local.get $src) (i32.const 16))))
+            (if (i32.eq (call $__ptr_type (local.get $props)) (i32.const ${PTR.HASH}))
+              (then (i64.store (i32.sub (local.get $dst) (i32.const 16))
+                (i64.reinterpret_f64 (call $__obj_clone (f64.reinterpret_i64 (local.get $props)))))))))
+        (return (call $__mkptr (i32.const ${PTR.OBJECT}) (local.get $sid) (local.get $dst)))))
+    (if (i32.eq (local.get $t) (i32.const ${PTR.HASH}))
+      (then
+        (local.set $cap (call $__cap (local.get $bits)))
+        (local.set $src (call $__ptr_offset (local.get $bits)))
+        (local.set $dst (call $__alloc_hdr_n (i32.const 0) (local.get $cap) (i32.const 24)))
+        (memory.copy
+          (i32.sub (local.get $dst) (i32.const 16))
+          (i32.sub (local.get $src) (i32.const 16))
+          (i32.add (i32.const 16) (i32.mul (local.get $cap) (i32.const 24))))
+        (return (call $__mkptr (i32.const ${PTR.HASH}) (i32.const 0) (local.get $dst)))))
+    (local.get $v))`
+
   // Allocator + exports are deferred: only included when memory is actually needed.
   // Any module using allocPtr/inc('__alloc') pulls these in via ctx.core.stdlibDeps.
   // compile.js emits _alloc/_clear exports + memory section only when __alloc is in includes.
@@ -732,12 +872,14 @@ export default (ctx) => {
     const eqT = (n) => `(i32.eq (local.get $t) (i32.const ${n}))`
     let disj = eqT(types[0])
     for (let i = 1; i < types.length; i++) disj = `(i32.or ${disj} ${eqT(types[i])})`
-    const lenArm = `(if (result f64) ${disj}
+    const lenArm = `(block (result f64)
+            (local.set $off (i32.wrap_i64 (i64.and (local.get $v) (i64.const ${LAYOUT.OFFSET_MASK}))))
+            (if (result f64) ${disj}
               (then
                 (if (result f64) (i32.ge_u (local.get $off) (i32.const 8))
                   (then (f64.convert_i32_s (call $__len (local.get $v))))
                   (else (f64.const nan:${UNDEF_NAN}))))
-              (else (f64.const nan:${UNDEF_NAN})))`
+              (else (f64.const nan:${UNDEF_NAN}))))`
     const stringArm = `(if (result f64) (i32.eq (local.get $t) (i32.const ${PTR.STRING}))
             (then (f64.convert_i32_s (call $__str_len (local.get $v))))
             (else ${lenArm}))`
@@ -748,7 +890,6 @@ export default (ctx) => {
       (then (f64.const nan:${UNDEF_NAN}))
       (else
         (local.set $t (call $__ptr_type (local.get $v)))
-        (local.set $off (call $__ptr_offset (local.get $v)))
         ${stringArm})))`
   }
 
@@ -825,8 +966,9 @@ export default (ctx) => {
     const ptRep = typeof obj === 'string' ? repOf(obj) : null
     const ptVt = ptRep ? ptRep.val : valTypeOf(obj)
     if (ptVt) {
-      const tpEmitter = ctx.core.emit[`.${ptVt}:${prop}`]
-      if (tpEmitter?.getter) return tpEmitter(obj)
+      const tpKey = `.${ptVt}:${prop}`
+      const tpEmitter = ctx.core.emit[tpKey]
+      if (tpEmitter && ctx.core.getters.has(tpKey)) return tpEmitter(obj)
     }
 
     // valueOf/toString are ToPrimitive hooks (ES2024 7.1.1) that an own data
@@ -853,7 +995,7 @@ export default (ctx) => {
     // fall through to a real property read — `m.values` reads the "values" field.
     const propKey = `.${prop}`
     const propEmitter = ctx.core.emit[propKey]
-    if (propEmitter?.getter) return propEmitter(obj)
+    if (propEmitter && ctx.core.getters.has(propKey)) return propEmitter(obj)
 
     return emitPropAccess(emit(obj), obj, prop)
   }
@@ -906,11 +1048,13 @@ export default (ctx) => {
     // re-emitting `obj`. Without this `s?.size` fell straight to emitPropAccess (a
     // plain field read) and returned undefined — a Set/Map size getter never ran.
     if (vt) {
-      const tg = ctx.core.emit[`.${vt}:${prop}`]
-      if (tg?.getter) return tg(t)
+      const tgKey = `.${vt}:${prop}`
+      const tg = ctx.core.emit[tgKey]
+      if (tg && ctx.core.getters.has(tgKey)) return tg(t)
     }
-    const g = ctx.core.emit[`.${prop}`]
-    if (g?.getter) return g(t)
+    const gKey = `.${prop}`
+    const g = ctx.core.emit[gKey]
+    if (g && ctx.core.getters.has(gKey)) return g(t)
     return emitPropAccess(typed(['local.get', `$${t}`], 'f64'), obj, prop, true)
   })
 

package/module/json.js

@@ -711,12 +711,12 @@ export default (ctx) => {
           (local.set $len (i32.add (local.get $len) (i32.const 1)))
           ${ADV(2)})
         (else
-          ;; Pack first 4 bytes into SSO slot (used only when len ≤ 4).
+          ;; Pack first 4 bytes into SSO slot (used only when len ≤ 4): 7-bit ASCII, char at bit len*7.
           (if (i32.lt_u (local.get $len) (i32.const 4))
             (then (local.set $sso
               (i32.or (local.get $sso)
                 (i32.shl (i32.and (local.get $ch) (i32.const 0xFF))
-                  (i32.shl (local.get $len) (i32.const 3)))))))
+                  (i32.mul (local.get $len) (i32.const 7)))))))
           (local.set $h (i32.mul (i32.xor (local.get $h) (i32.and (local.get $ch) (i32.const 0xFF))) (i32.const 0x01000193)))
           (local.set $len (i32.add (local.get $len) (i32.const 1)))
           ${ADV(1)}))
@@ -735,7 +735,7 @@ export default (ctx) => {
     ;; SSO fast path: ≤4 ASCII chars, no escapes — bytes already packed inline.
     (if (i32.and (local.get $simple) (i32.le_u (local.get $len) (i32.const 4)))
       (then
-        (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.or (i32.const ${LAYOUT.SSO_BIT}) (local.get $len)) (local.get $sso)))))
+        (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.or (i32.const ${LAYOUT.SSO_BIT}) (i32.shl (local.get $len) (i32.const 10))) (local.get $sso)))))
     ;; Simple STRING fast path: no escapes, len > 4 — bulk memcpy from parse buffer,
     ;; skip rewind + per-byte escape-decode loop. Hits 5+ char keys without escapes.
     (if (local.get $simple)