jz 0.7.0 → 0.8.1

package/module/core.js

@@ -10,7 +10,7 @@
  */
 
 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'
@@ -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)
@@ -255,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))
@@ -269,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
@@ -407,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))))
@@ -475,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.
@@ -730,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}))`
@@ -746,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})))`
   }
 
@@ -823,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
@@ -851,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)
   }
@@ -904,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)