jz 0.1.1 → 0.2.1

package/module/typedarray.js

@@ -7,7 +7,7 @@
  * @module typed
  */
 
-import { typed, asF64, asI32, UNDEF_NAN, allocPtr, mkPtrIR, ptrOffsetIR, temp, tempI32 } from '../src/ir.js'
+import { typed, asF64, asI32, asI64, UNDEF_NAN, allocPtr, mkPtrIR, ptrOffsetIR, temp, tempI32, undefExpr } from '../src/ir.js'
 import { emit } from '../src/emit.js'
 import { valTypeOf, lookupValType, VAL } from '../src/analyze.js'
 import { inc, PTR } from '../src/ctx.js'
@@ -21,6 +21,9 @@ const ELEM = {
   Float32Array: 6, Float64Array: 7,
   BigInt64Array: 7, BigUint64Array: 7,
 }
+const BIGINT_ELEM_FLAG = 16
+const typedAux = (name, isView = false) => ELEM[name] | (isView ? 8 : 0) |
+  (name === 'BigInt64Array' || name === 'BigUint64Array' ? BIGINT_ELEM_FLAG : 0)
 const STRIDE = [1, 1, 2, 2, 4, 4, 4, 8]
 const SHIFT = [0, 0, 1, 1, 2, 2, 2, 3]
 const LOAD = [
@@ -165,7 +168,7 @@ function genSimdMap(name, elemType, pattern) {
     : `(local.set $ei (${scalarLoad} ${byteOff}))`
   const scalarStoreExpr = `${scalarLoadSet}\n      (${store} ${dstByteOff} ${scalarOp})`
 
-  return `(func $${name} (param $src f64) (result f64)
+  return `(func $${name} (param $src i64) (result f64)
     (local $len i32) (local $srcOff i32) (local $dstOff i32) (local $dst i32)
     (local $i i32) (local $simdLen i32) (local $byteOff i32)
     (local $v v128)
@@ -203,6 +206,7 @@ export default (ctx) => {
     __byte_length: ['__ptr_type', '__ptr_offset', '__ptr_aux'],
     __byte_offset: ['__ptr_type', '__ptr_offset', '__ptr_aux'],
     __to_buffer: ['__ptr_type', '__ptr_offset', '__ptr_aux', '__mkptr'],
+    __typed_set_idx: ['__ptr_aux', '__ptr_offset'],
   })
 
   // .map/.filter invoke callbacks with arity 1 internally.
@@ -216,7 +220,7 @@ export default (ctx) => {
   // __byte_length(ptr) — byte size for BUFFER/TYPED; 0 otherwise.
   // BUFFER and owned TYPED store byteLen at [-8]. TYPED view (aux bit 3) stores byteLen
   // at descriptor[0].
-  ctx.core.stdlib['__byte_length'] = `(func $__byte_length (param $ptr f64) (result i32)
+  ctx.core.stdlib['__byte_length'] = `(func $__byte_length (param $ptr i64) (result i32)
     (local $t i32) (local $off i32)
     (local.set $t (call $__ptr_type (local.get $ptr)))
     (if (result i32)
@@ -238,11 +242,11 @@ export default (ctx) => {
   // Owned TYPED: retag as BUFFER at same offset — the byteLen header is shared.
   // TYPED view: retag as BUFFER at the parent data offset (descriptor[8]) — reconstructs
   // the root ArrayBuffer so its own header supplies byteLength.
-  ctx.core.stdlib['__to_buffer'] = `(func $__to_buffer (param $ptr f64) (result f64)
+  ctx.core.stdlib['__to_buffer'] = `(func $__to_buffer (param $ptr i64) (result f64)
     (local $t i32) (local $off i32)
     (local.set $t (call $__ptr_type (local.get $ptr)))
     (if (result f64) (i32.eq (local.get $t) (i32.const ${PTR.BUFFER}))
-      (then (local.get $ptr))
+      (then (f64.reinterpret_i64 (local.get $ptr)))
       (else
         (local.set $off (call $__ptr_offset (local.get $ptr)))
         (if (result f64)
@@ -255,6 +259,7 @@ export default (ctx) => {
 
   // Constructor: new Float64Array(len) | new F64Array(arr) | new F64Array(buf) | new F64Array(buf, off, len)
   for (const [name, elemType] of Object.entries(ELEM)) {
+    const aux = typedAux(name)
     const stride = STRIDE[elemType]
     ctx.core.emit[`new.${name}`] = (lenExpr, offsetExpr, lenExpr2) => {
       ctx.features.typedarray = true
@@ -280,7 +285,7 @@ export default (ctx) => {
           ['i32.store',
             ['i32.add', ['local.get', `$${dst}`], ['i32.const', 8]],
             ['local.get', `$${parentOff}`]],
-          mkPtrIR(PTR.TYPED, elemType | 8, ['local.get', `$${dst}`])], 'f64')
+          mkPtrIR(PTR.TYPED, typedAux(name, true), ['local.get', `$${dst}`])], 'f64')
       }
       // Single arg array-like source: copy elements instead of treating the pointer as a length.
       if (srcType === VAL.ARRAY && ctx.core.emit[`${name}.from`])
@@ -289,7 +294,7 @@ export default (ctx) => {
       // TYPED retagged at the same offset — the byteLen header is shared with the parent.
       // __len(view) = byteLen >> shift computes elemCount for this view's elemType.
       if (srcType === VAL.BUFFER || srcType === VAL.TYPED) {
-        return mkPtrIR(PTR.TYPED, elemType, ['call', '$__ptr_offset', asF64(emit(lenExpr))])
+        return mkPtrIR(PTR.TYPED, aux, ['call', '$__ptr_offset', ['i64.reinterpret_f64', asF64(emit(lenExpr))]])
       }
       if (srcType == null && ctx.core.emit[`${name}.from`]) {
         // Runtime dispatch: number → allocate; array → copy elements; buffer/typed → zero-copy view.
@@ -297,7 +302,7 @@ export default (ctx) => {
         const len = tempI32('tl')
         const shift = SHIFT[elemType]
         const numBytes = ['i32.shl', ['local.get', `$${len}`], ['i32.const', shift]]
-        const numAlloc = allocPtr({ type: PTR.TYPED, aux: elemType, len: numBytes, stride: 1, tag: 'ta' })
+        const numAlloc = allocPtr({ type: PTR.TYPED, aux, len: numBytes, stride: 1, tag: 'ta' })
         return typed(['block', ['result', 'f64'],
           ['local.set', `$${src}`, asF64(emit(lenExpr))],
           ['if', ['result', 'f64'],
@@ -309,15 +314,15 @@ export default (ctx) => {
               numAlloc.ptr]],
             // Pointer: array → copy elements; buffer/typed → zero-copy view on same offset
             ['else', ['if', ['result', 'f64'],
-              ['i32.eq', ['call', '$__ptr_type', ['local.get', `$${src}`]], ['i32.const', PTR.ARRAY]],
+              ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${src}`]]], ['i32.const', PTR.ARRAY]],
               ['then', ctx.core.emit[`${name}.from`](src)],
-              ['else', mkPtrIR(PTR.TYPED, elemType,
-                ['call', '$__ptr_offset', ['local.get', `$${src}`]])]]]]], 'f64')
+              ['else', mkPtrIR(PTR.TYPED, aux,
+                ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${src}`]]])]]]]], 'f64')
       }
       // Normal: allocate fresh typed array (lenExpr is numeric size). Header stores byteLen.
       const shift = SHIFT[elemType]
       const lenL = tempI32('tan')
-      const out = allocPtr({ type: PTR.TYPED, aux: elemType,
+      const out = allocPtr({ type: PTR.TYPED, aux,
         len: ['i32.shl', ['local.get', `$${lenL}`], ['i32.const', shift]], stride: 1, tag: 'ta' })
       return typed(['block', ['result', 'f64'],
         ['local.set', `$${lenL}`, asI32(emit(lenExpr))],
@@ -345,7 +350,7 @@ export default (ctx) => {
   ctx.core.emit['BigInt64Array'] = (bufExpr) => {
     ctx.features.typedarray = true
     const va = asF64(emit(bufExpr))
-    return mkPtrIR(PTR.TYPED, 7, ['call', '$__ptr_offset', va])
+    return mkPtrIR(PTR.TYPED, typedAux('BigInt64Array'), ['call', '$__ptr_offset', ['i64.reinterpret_f64', va]])
   }
 
   // .buffer — always aliased (zero-copy). BUFFER/DataView: passthrough.
@@ -367,7 +372,7 @@ export default (ctx) => {
       }
     }
     inc('__to_buffer')
-    return typed(['call', '$__to_buffer', asF64(emit(obj))], 'f64')
+    return typed(['call', '$__to_buffer', asI64(emit(obj))], 'f64')
   }
 
   // .byteLength — BUFFER: raw __len. Owned TYPED: elemCount * stride. View TYPED: descriptor[0].
@@ -375,7 +380,7 @@ export default (ctx) => {
     if (typeof obj === 'string') {
       const ctor = ctx.types.typedElem?.get(obj)
       if (ctor === 'new.ArrayBuffer' || ctor === 'new.DataView') {
-        return typed(['f64.convert_i32_s', ['call', '$__len', asF64(emit(obj))]], 'f64')
+        return typed(['f64.convert_i32_s', ['call', '$__len', ['i64.reinterpret_f64', asF64(emit(obj))]]], 'f64')
       }
       if (ctor && ctor.startsWith('new.')) {
         const isView = ctor.endsWith('.view')
@@ -387,12 +392,12 @@ export default (ctx) => {
               ['i32.load', ptrOffsetIR(emit(obj), VAL.TYPED)]], 'f64')
           }
           return typed(['f64.convert_i32_s',
-            ['i32.shl', ['call', '$__len', asF64(emit(obj))], ['i32.const', SHIFT[et]]]], 'f64')
+            ['i32.shl', ['call', '$__len', ['i64.reinterpret_f64', asF64(emit(obj))]], ['i32.const', SHIFT[et]]]], 'f64')
         }
       }
     }
     inc('__byte_length')
-    return typed(['f64.convert_i32_s', ['call', '$__byte_length', asF64(emit(obj))]], 'f64')
+    return typed(['f64.convert_i32_s', ['call', '$__byte_length', asI64(emit(obj))]], 'f64')
   }
 
   // .byteOffset — owned: 0. View: descriptor[4] - descriptor[8].
@@ -411,11 +416,11 @@ export default (ctx) => {
       if (ctor?.startsWith('new.') && ELEM[ctor.slice(4)] != null) return typed(['f64.const', 0], 'f64')
     }
     inc('__byte_offset')
-    return typed(['f64.convert_i32_s', ['call', '$__byte_offset', asF64(emit(obj))]], 'f64')
+    return typed(['f64.convert_i32_s', ['call', '$__byte_offset', asI64(emit(obj))]], 'f64')
   }
 
   // Runtime fallback for .byteOffset when variable view-ness is unknown.
-  ctx.core.stdlib['__byte_offset'] = `(func $__byte_offset (param $ptr f64) (result i32)
+  ctx.core.stdlib['__byte_offset'] = `(func $__byte_offset (param $ptr i64) (result i32)
     (local $off i32)
     (if (result i32)
       (i32.and
@@ -431,9 +436,10 @@ export default (ctx) => {
   // ArrayBuffer.isView(x) — true iff x is a TYPED pointer. (DataView passthrough cannot be
   // distinguished from ArrayBuffer since both are BUFFER pointers; both report false.)
   ctx.core.emit['ArrayBuffer.isView'] = (v) => {
+    if (v === undefined) return typed(['f64.const', 0], 'f64')
     const va = asF64(emit(v))
     return typed(['f64.convert_i32_s',
-      ['i32.eq', ['call', '$__ptr_type', va], ['i32.const', PTR.TYPED]]], 'f64')
+      ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', va]], ['i32.const', PTR.TYPED]]], 'f64')
   }
 
   // buf.slice(begin?, end?) on a BUFFER → fresh BUFFER with the byte range copied.
@@ -446,7 +452,7 @@ export default (ctx) => {
     const out = allocPtr({ type: PTR.BUFFER, len: ['local.get', `$${bytes}`], stride: 1, tag: 'bsd' })
     const beginWat = beginExpr == null ? ['i32.const', 0] : asI32(emit(beginExpr))
     const endWat = endExpr == null
-      ? ['call', '$__len', ['local.get', `$${src}`]]
+      ? ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${src}`]]]
       : asI32(emit(endExpr))
     return typed(['block', ['result', 'f64'],
       ['local.set', `$${src}`, asF64(emit(obj))],
@@ -459,7 +465,7 @@ export default (ctx) => {
       out.init,
       ['memory.copy',
         ['local.get', `$${out.local}`],
-        ['i32.add', ['call', '$__ptr_offset', ['local.get', `$${src}`]], ['local.get', `$${beg}`]],
+        ['i32.add', ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${src}`]]], ['local.get', `$${beg}`]],
         ['local.get', `$${bytes}`]],
       out.ptr], 'f64')
   }
@@ -507,12 +513,13 @@ export default (ctx) => {
 
   // TypedArray.from(arr) — convert regular array to typed array
   for (const [name, elemType] of Object.entries(ELEM)) {
+    const aux = typedAux(name)
     const stride = STRIDE[elemType], store = STORE[elemType]
     ctx.core.emit[`${name}.from`] = (src) => {
       ctx.features.typedarray = true
       const srcL = temp('tfs')
       const len = tempI32('tfl'), i = tempI32('tfi'), off = tempI32('tfo')
-      const out = allocPtr({ type: PTR.TYPED, aux: elemType,
+      const out = allocPtr({ type: PTR.TYPED, aux,
         len: ['i32.mul', ['local.get', `$${len}`], ['i32.const', stride]], stride: 1, tag: 'tf' })
       const t = out.local
       const id = ctx.func.uniq++
@@ -528,8 +535,8 @@ export default (ctx) => {
             ['f64.load', ['i32.add', ['local.get', `$${off}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]]]]]
       return typed(['block', ['result', 'f64'],
         ['local.set', `$${srcL}`, asF64(emit(src))],
-        ['local.set', `$${off}`, ['call', '$__ptr_offset', ['local.get', `$${srcL}`]]],
-        ['local.set', `$${len}`, ['call', '$__len', ['local.get', `$${srcL}`]]],
+        ['local.set', `$${off}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${srcL}`]]]],
+        ['local.set', `$${len}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${srcL}`]]]],
         out.init,
         ['local.set', `$${i}`, ['i32.const', 0]],
         ['block', `$brk${id}`, ['loop', `$loop${id}`,
@@ -544,14 +551,14 @@ export default (ctx) => {
   // .length handled by ptr.js's __len (reads from memory header [-8:len])
 
   /** Resolve element type + view-ness for a known TypedArray variable.
-   *  Returns { et, isView } or null. */
+   *  Returns { et, isView, isBigInt } or null. */
   const resolveElem = (arr) => {
     const ctor = typeof arr === 'string' && ctx.types.typedElem?.get(arr)
     if (!ctor) return null
     const isView = ctor.endsWith('.view')
     const name = isView ? ctor.slice(4, -5) : ctor.slice(4)
     const et = ELEM[name]
-    return et == null ? null : { et, isView }
+    return et == null ? null : { et, isView, isBigInt: name === 'BigInt64Array' || name === 'BigUint64Array' }
   }
 
   /** Emit the real data byte-address for a typed array IR node.
@@ -568,7 +575,7 @@ export default (ctx) => {
   // Identical factory in array.js; whichever module loads last wins the registration.
   ctx.core.stdlib['__typed_idx'] = () => {
     if (!ctx.features.typedarray && !ctx.features.external) {
-      return `(func $__typed_idx (param $ptr f64) (param $i i32) (result f64)
+      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)
@@ -578,7 +585,7 @@ export default (ctx) => {
       (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)))))))`
     }
-    return `(func $__typed_idx (param $ptr f64) (param $i i32) (result f64)
+    return `(func $__typed_idx (param $ptr i64) (param $i i32) (result f64)
     (local $off i32) (local $et i32) (local $len i32) (local $aux i32)
     (local.set $aux (call $__ptr_aux (local.get $ptr)))
     (local.set $off (call $__ptr_offset (local.get $ptr)))
@@ -599,7 +606,9 @@ export default (ctx) => {
             (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 (f64.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3)))))
+                (then (if (result f64) (i32.and (local.get $aux) (i32.const ${BIGINT_ELEM_FLAG}))
+                  (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))
@@ -615,13 +624,42 @@ export default (ctx) => {
           (else (f64.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3)))))))))`
   }
 
+  ctx.core.stdlib['__typed_set_idx'] = `(func $__typed_set_idx (param $ptr i64) (param $i i32) (param $v f64) (result f64)
+    (local $off i32) (local $aux i32) (local $et i32) (local $bits i32)
+    (local.set $aux (call $__ptr_aux (local.get $ptr)))
+    (local.set $off (call $__ptr_offset (local.get $ptr)))
+    (if (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 $et (i32.and (local.get $aux) (i32.const 7)))
+    (if (i32.and (local.get $aux) (i32.const ${BIGINT_ELEM_FLAG}))
+      (then (i64.store (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3))) (i64.reinterpret_f64 (local.get $v))))
+      (else
+        (if (i32.eq (local.get $et) (i32.const 7))
+          (then (f64.store (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3))) (local.get $v)))
+          (else
+            (if (i32.eq (local.get $et) (i32.const 6))
+              (then (f32.store (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 2))) (f32.demote_f64 (local.get $v))))
+              (else
+                (local.set $bits
+                  (i32.wrap_i64
+                    (if (result i64) (f64.lt (local.get $v) (f64.const 0))
+                      (then (i64.trunc_sat_f64_s (local.get $v)))
+                      (else (i64.trunc_sat_f64_u (local.get $v))))))
+                (if (i32.ge_u (local.get $et) (i32.const 4))
+                  (then (i32.store (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 2))) (local.get $bits)))
+                  (else (if (i32.ge_u (local.get $et) (i32.const 2))
+                    (then (i32.store16 (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 1))) (local.get $bits)))
+                    (else (i32.store8 (i32.add (local.get $off) (local.get $i)) (local.get $bits))))))))))))
+    (local.get $v))`
+
   // Type-aware TypedArray read: arr[i]
   ctx.core.emit['.typed:[]'] = (arr, idx) => {
     const r = resolveElem(arr)
     if (r == null) return null // unknown type, fallback to generic
-    const { et, isView } = r
+    const { et, isView, isBigInt } = r
     const objIR = emit(arr), vi = asI32(emit(idx))
     const off = ['i32.add', typedDataAddr(objIR, isView), ['i32.shl', vi, ['i32.const', SHIFT[et]]]]
+    if (isBigInt) return typed(['f64.reinterpret_i64', ['i64.load', off]], 'f64')
     if (et === 7) return typed(['f64.load', off], 'f64') // Float64Array
     if (et === 6) return typed(['f64.promote_f32', ['f32.load', off]], 'f64') // Float32Array
     // Integer types: load and convert to f64 (unsigned types use unsigned conversion)
@@ -629,19 +667,111 @@ export default (ctx) => {
   }
 
   // Type-aware TypedArray write: arr[i] = val
-  ctx.core.emit['.typed:[]='] = (arr, idx, val) => {
+  ctx.core.emit['.typed:[]='] = (arr, idx, val, void_ = false) => {
     const r = resolveElem(arr)
     if (r == null) return null
-    const { et, isView } = r
-    const objIR = emit(arr), vi = asI32(emit(idx)), vv = asF64(emit(val))
+    const { et, isView, isBigInt } = r
+    const objIR = emit(arr), vi = asI32(emit(idx)), valIR = emit(val)
     const off = ['i32.add', typedDataAddr(objIR, isView), ['i32.shl', vi, ['i32.const', SHIFT[et]]]]
-    if (et === 7) return ['f64.store', off, vv] // Float64Array
-    if (et === 6) return ['f32.store', off, ['f32.demote_f64', vv]] // Float32Array
-    // Integer types: truncate f64 to i32, then store. Peel f64.convert_i32_*(x) → x:
-    // store of bitwise-result already-i32 needs no round-trip.
-    const isConv = Array.isArray(vv) && (vv[0] === 'f64.convert_i32_s' || vv[0] === 'f64.convert_i32_u')
-    const i32val = isConv ? vv[1] : [(et & 1) ? 'i32.trunc_f64_u' : 'i32.trunc_f64_s', vv]
-    return [STORE[et], off, i32val]
+    if (isBigInt) {
+      const vt = temp('tw')
+      return typed(void_ ? ['block',
+        ['local.set', `$${vt}`, asF64(valIR)],
+        ['i64.store', off, ['i64.reinterpret_f64', ['local.get', `$${vt}`]]]]
+        : ['block', ['result', 'f64'],
+        ['local.set', `$${vt}`, asF64(valIR)],
+        ['i64.store', off, ['i64.reinterpret_f64', ['local.get', `$${vt}`]]],
+        ['local.get', `$${vt}`]], void_ ? 'void' : 'f64')
+    }
+    if (et === 7) {
+      const vt = temp('tw')
+      return typed(void_ ? ['block',
+        ['local.set', `$${vt}`, asF64(valIR)],
+        ['f64.store', off, ['local.get', `$${vt}`]]]
+        : ['block', ['result', 'f64'],
+        ['local.set', `$${vt}`, asF64(valIR)],
+        ['f64.store', off, ['local.get', `$${vt}`]],
+        ['local.get', `$${vt}`]], void_ ? 'void' : 'f64') // Float64Array
+    }
+    if (et === 6) {
+      const vt = temp('tw')
+      return typed(void_ ? ['block',
+        ['local.set', `$${vt}`, asF64(valIR)],
+        ['f32.store', off, ['f32.demote_f64', ['local.get', `$${vt}`]]]]
+        : ['block', ['result', 'f64'],
+        ['local.set', `$${vt}`, asF64(valIR)],
+        ['f32.store', off, ['f32.demote_f64', ['local.get', `$${vt}`]]],
+        ['local.get', `$${vt}`]], void_ ? 'void' : 'f64') // Float32Array
+    }
+    // Integer store: when the source is already i32-typed (bitwise ops, |0,
+    // typed-array load, known-i32 var), store it directly — skip the f64
+    // detour that costs a sign branch + i64 trunc + i32 wrap on every write.
+    if (valIR.type === 'i32') {
+      const cheap = Array.isArray(valIR) &&
+        ((valIR[0] === 'local.get' && typeof valIR[1] === 'string') ||
+         (valIR[0] === 'i32.const' && (typeof valIR[1] === 'number' || typeof valIR[1] === 'string')))
+      if (void_ && cheap) return typed([STORE[et], off, valIR], 'void')
+      const v32 = tempI32('tw')
+      return typed(void_ ? ['block',
+        ['local.set', `$${v32}`, valIR],
+        [STORE[et], off, ['local.get', `$${v32}`]]]
+        : ['block', ['result', 'f64'],
+        ['local.set', `$${v32}`, valIR],
+        [STORE[et], off, ['local.get', `$${v32}`]],
+        [(et & 1) ? 'f64.convert_i32_u' : 'f64.convert_i32_s', ['local.get', `$${v32}`]]], void_ ? 'void' : 'f64')
+    }
+    const vt = temp('tw')
+    const i32val = ['i32.wrap_i64',
+      ['if', ['result', 'i64'], ['f64.lt', ['local.get', `$${vt}`], ['f64.const', 0]],
+        ['then', ['i64.trunc_sat_f64_s', ['local.get', `$${vt}`]]],
+        ['else', ['i64.trunc_sat_f64_u', ['local.get', `$${vt}`]]]]]
+    return typed(void_ ? ['block',
+      ['local.set', `$${vt}`, asF64(valIR)],
+      [STORE[et], off, i32val]]
+      : ['block', ['result', 'f64'],
+      ['local.set', `$${vt}`, asF64(valIR)],
+      [STORE[et], off, i32val],
+      ['local.get', `$${vt}`]], void_ ? 'void' : 'f64')
+  }
+
+  // TypedArray.prototype.set(source, offset = 0). Copies array-like numeric
+  // values into the receiver. Falls back to runtime aux-byte dispatch via
+  // __typed_set_idx when sibling-scope decls poison the dst's typedElem (e.g.
+  // v128const's i-branch ternary `num===16 ? Uint8Array : Uint32Array`
+  // hoisted alongside the f-branch's plain `new Uint8Array(16)`).
+  ctx.core.emit['.typed:set'] = (arr, src, offset) => {
+    const r = resolveElem(arr)
+    inc('__len', '__typed_idx')
+    if (r == null) inc('__typed_set_idx')
+    const srcVal = src === undefined ? undefExpr() : asF64(emit(src))
+    const offVal = offset === undefined ? typed(['i32.const', 0], 'i32') : asI32(emit(offset))
+    const dst = r ? tempI32('tsd') : temp('tsd')
+    const srcTmp = temp('tss'), len = tempI32('tsl'), off = tempI32('tso'), i = tempI32('tsi')
+    const idx = ['i32.add', ['local.get', `$${off}`], ['local.get', `$${i}`]]
+    const val = typed(['call', '$__typed_idx', ['i64.reinterpret_f64', ['local.get', `$${srcTmp}`]], ['local.get', `$${i}`]], 'f64')
+    let store
+    if (r) {
+      const { et } = r
+      const addr = ['i32.add', ['local.get', `$${dst}`], ['i32.shl', idx, ['i32.const', SHIFT[et]]]]
+      store = et === 7 ? ['f64.store', addr, val]
+        : et === 6 ? ['f32.store', addr, ['f32.demote_f64', val]]
+        : [STORE[et], addr, [(et & 1) ? 'i32.trunc_f64_u' : 'i32.trunc_f64_s', val]]
+    } else {
+      store = ['drop', ['call', '$__typed_set_idx', ['i64.reinterpret_f64', ['local.get', `$${dst}`]], idx, val]]
+    }
+    const id = ctx.func.uniq++
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${dst}`, r ? typedDataAddr(emit(arr), r.isView) : asF64(emit(arr))],
+      ['local.set', `$${srcTmp}`, srcVal],
+      ['local.set', `$${len}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${srcTmp}`]]]],
+      ['local.set', `$${off}`, offVal],
+      ['local.set', `$${i}`, ['i32.const', 0]],
+      ['block', `$brk${id}`, ['loop', `$loop${id}`,
+        ['br_if', `$brk${id}`, ['i32.ge_u', ['local.get', `$${i}`], ['local.get', `$${len}`]]],
+        store,
+        ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+        ['br', `$loop${id}`]]],
+      undefExpr()], 'f64')
   }
 
   // .map() on TypedArrays — SIMD auto-vectorization when pattern detected
@@ -665,7 +795,7 @@ export default (ctx) => {
         if (wat) {
           ctx.core.stdlib[funcName] = wat
           inc(funcName, '__typed_data', '__len')
-          return typed(['call', `$${funcName}`, asF64(emit(arr))], 'f64')
+          return typed(['call', `$${funcName}`, asI64(emit(arr))], 'f64')
         }
       }
     }
@@ -675,7 +805,7 @@ export default (ctx) => {
       const va = emit(arr), vf = emit(fn)
       const len = tempI32('tml'), ptr = tempI32('tmp'), i = tempI32('tmi')
       const stride = STRIDE[elemType], shift = SHIFT[elemType]
-      const dst = allocPtr({ type: PTR.TYPED, aux: elemType,
+      const dst = allocPtr({ type: PTR.TYPED, aux: typedAux(elemName),
         len: ['i32.shl', ['local.get', `$${len}`], ['i32.const', shift]], stride: 1, tag: 'tmo' })
       const out = dst.local
 
@@ -695,7 +825,7 @@ export default (ctx) => {
       const id = ctx.func.uniq++
       return typed(['block', ['result', 'f64'],
         ['local.set', `$${ptr}`, typedDataAddr(va, isView)],
-        ['local.set', `$${len}`, ['call', '$__len', asF64(va)]],
+        ['local.set', `$${len}`, ['call', '$__len', ['i64.reinterpret_f64', asF64(va)]]],
         dst.init,
         ['local.set', `$${i}`, ['i32.const', 0]],
         ['block', `$brk${id}`, ['loop', `$loop${id}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jz",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Modern functional JS compiling to WASM",
   "main": "index.js",
   "type": "module",
@@ -21,17 +21,10 @@
   },
   "scripts": {
     "test": "node test/index.js",
-    "test:safe": "nice -n 15 node scripts/timebox.mjs 3000 node test/index.js",
-    "test:segments": "nice -n 15 node scripts/test-segments.mjs 3000 files",
-    "test:prefixes": "nice -n 15 node scripts/test-segments.mjs 3000 prefix",
     "test262": "node test/test262.js",
     "test262:builtins": "node test/test262-builtins.js",
-    "test262:runner": "node test/runner.js",
-    "dev": "node cli.js",
-    "build": "node cli.js compile examples/*.js",
     "bench": "node bench/bench.mjs",
     "bench:compile": "node scripts/bench-compile.mjs",
-    "bench:biquad": "node bench/bench.mjs biquad",
     "test:bench-pin": "node test/bench-pin.js"
   },
   "repository": {
@@ -45,7 +38,7 @@
   "author": "Dmitry Iv",
   "license": "MIT",
   "dependencies": {
-    "subscript": "^10.3.5",
+    "subscript": "^10.4.2",
     "watr": "^4.5.1"
   },
   "keywords": [
@@ -57,6 +50,6 @@
     "wasm"
   ],
   "devDependencies": {
-    "tst": "^9.2.0"
+    "tst": "^9.4.0"
   }
 }