jz 0.5.1 → 0.7.0

package/module/typedarray.js

@@ -7,23 +7,17 @@
  * @module typed
  */
 
-import { typed, asF64, asI32, asI64, toNumF64, UNDEF_NAN, allocPtr, mkPtrIR, ptrOffsetIR, temp, tempI32, tempI64, undefExpr, truthyIR } 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'
-
-
-// Element types and their byte sizes
-const ELEM = {
-  Int8Array: 0, Uint8Array: 1,
-  Int16Array: 2, Uint16Array: 3,
-  Int32Array: 4, Uint32Array: 5,
-  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)
+import { typed, asF64, asI32, asI64, toNumF64, UNDEF_NAN, allocPtr, mkPtrIR, ptrOffsetIR, ptrTypeEq, temp, tempI32, tempI64, undefExpr, truthyIR } from '../src/ir.js'
+import { emit, idx, deps, call } from '../src/bridge.js'
+import { valTypeOf } from '../src/kind.js'
+import { VAL, lookupValType } from '../src/reps.js'
+import { nanPrefixHex, TYPED_ELEM_NAMES, TYPED_ELEM_CODE, TYPED_ELEM_BIGINT_FLAG, encodeTypedElemAux } from '../layout.js'
+import { inc, PTR, LAYOUT, getter } from '../src/ctx.js'
+
+const _NAN_BITS = nanPrefixHex()
+
+
+const typedAux = (name, isView = false) => encodeTypedElemAux(name, isView)
 const STRIDE = [1, 1, 2, 2, 4, 4, 4, 8]
 const SHIFT = [0, 0, 1, 1, 2, 2, 2, 3]
 const LOAD = [
@@ -202,11 +196,19 @@ function genSimdMap(name, elemType, pattern) {
 
 
 export default (ctx) => {
-  Object.assign(ctx.core.stdlibDeps, {
+  deps({
     __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'],
+    __typed_get_idx: ['__ptr_aux', '__ptr_offset'],
+    __typed_fill: ['__len', '__typed_set_idx'],
+    __typed_reverse: ['__len', '__typed_get_idx', '__typed_set_idx'],
+    __typed_copyWithin: ['__len', '__typed_get_idx', '__typed_set_idx'],
+    __typed_sort: ['__len', '__typed_get_idx', '__typed_set_idx'],
+    // __str_join uses __typed_idx when typedarray is loaded (plain arrays promoted to
+    // Int32Array by promoteIntArrayLiterals can produce PTR.TYPED results via .map()).
+    __str_join: [...(ctx.core.stdlibDeps.__str_join ?? []), '__typed_idx'],
   })
 
   // .map invokes with arity 1; .forEach/.find/.some/.every/.filter/.findIndex
@@ -217,6 +219,10 @@ export default (ctx) => {
 
   inc('__mkptr', '__alloc', '__len')
 
+  const buf = call('__to_buffer', 'I')
+  const blen = call('__byte_length', 'I', 'i32')
+  const boff = call('__byte_offset', 'I', 'i32')
+
   // === Runtime helpers: byte length, buffer coerce ===
   // __typed_shift lives in core (needed by __len/__cap).
 
@@ -261,7 +267,7 @@ export default (ctx) => {
           (else (call $__mkptr (i32.const ${PTR.BUFFER}) (i32.const 0) (local.get $off)))))))`
 
   // Constructor: new Float64Array(len) | new F64Array(arr) | new F64Array(buf) | new F64Array(buf, off, len)
-  for (const [name, elemType] of Object.entries(ELEM)) {
+  for (const [name, elemType] of Object.entries(TYPED_ELEM_CODE)) {
     const aux = typedAux(name)
     const stride = STRIDE[elemType]
     ctx.core.emit[`new.${name}`] = (lenExpr, offsetExpr, lenExpr2) => {
@@ -317,7 +323,7 @@ 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', ['i64.reinterpret_f64', ['local.get', `$${src}`]]], ['i32.const', PTR.ARRAY]],
+              ptrTypeEq(['local.get', `$${src}`], PTR.ARRAY),
               ['then', ctx.core.emit[`${name}.from`](src)],
               ['else', mkPtrIR(PTR.TYPED, aux,
                 ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${src}`]]])]]]]], 'f64')
@@ -404,14 +410,14 @@ export default (ctx) => {
   // .buffer — always aliased (zero-copy). BUFFER: passthrough.
   // Owned TYPED: retag as BUFFER at same offset — the byteLen header is shared.
   // TYPED view (incl. DataView): BUFFER at descriptor[8] (root parent data offset).
-  ctx.core.emit['.buffer'] = (obj) => {
+  ctx.core.emit['.buffer'] = getter((obj) => {
     if (typeof obj === 'string') {
       const ctor = ctx.types.typedElem?.get(obj)
       if (ctor === 'new.ArrayBuffer') return asF64(emit(obj))
       if (ctor?.startsWith('new.')) {
         const isView = ctor.endsWith('.view')
         const name = isView ? ctor.slice(4, -5) : ctor.slice(4)
-        if (ELEM[name] != null) {
+        if (TYPED_ELEM_CODE[name] != null) {
           const parentOff = isView
             ? ['i32.load', ['i32.add', ptrOffsetIR(emit(obj), VAL.TYPED), ['i32.const', 8]]]
             : ptrOffsetIR(emit(obj), VAL.TYPED)
@@ -419,13 +425,12 @@ export default (ctx) => {
         }
       }
     }
-    inc('__to_buffer')
-    return typed(['call', '$__to_buffer', asI64(emit(obj))], 'f64')
-  }
+    return buf(obj)
+  })
 
   // .byteLength — BUFFER: raw __len. Owned TYPED: elemCount * stride.
   // View TYPED (incl. DataView): descriptor[0], via the __byte_length fallback.
-  ctx.core.emit['.byteLength'] = (obj) => {
+  ctx.core.emit['.byteLength'] = getter((obj) => {
     if (typeof obj === 'string') {
       const ctor = ctx.types.typedElem?.get(obj)
       if (ctor === 'new.ArrayBuffer') {
@@ -434,7 +439,7 @@ export default (ctx) => {
       if (ctor && ctor.startsWith('new.')) {
         const isView = ctor.endsWith('.view')
         const name = isView ? ctor.slice(4, -5) : ctor.slice(4)
-        const et = ELEM[name]
+        const et = TYPED_ELEM_CODE[name]
         if (et != null) {
           if (isView) {
             return typed(['f64.convert_i32_s',
@@ -445,12 +450,11 @@ export default (ctx) => {
         }
       }
     }
-    inc('__byte_length')
-    return typed(['f64.convert_i32_s', ['call', '$__byte_length', asI64(emit(obj))]], 'f64')
-  }
+    return blen(obj)
+  })
 
   // .byteOffset — owned: 0. View: descriptor[4] - descriptor[8].
-  ctx.core.emit['.byteOffset'] = (obj) => {
+  ctx.core.emit['.byteOffset'] = getter((obj) => {
     if (typeof obj === 'string') {
       const ctor = ctx.types.typedElem?.get(obj)
       if (ctor?.endsWith('.view')) {
@@ -462,11 +466,10 @@ export default (ctx) => {
               ['i32.load', ['i32.add', ['local.get', `$${t}`], ['i32.const', 4]]],
               ['i32.load', ['i32.add', ['local.get', `$${t}`], ['i32.const', 8]]]]]], 'f64')
       }
-      if (ctor?.startsWith('new.') && ELEM[ctor.slice(4)] != null) return typed(['f64.const', 0], 'f64')
+      if (ctor?.startsWith('new.') && TYPED_ELEM_CODE[ctor.slice(4)] != null) return typed(['f64.const', 0], 'f64')
     }
-    inc('__byte_offset')
-    return typed(['f64.convert_i32_s', ['call', '$__byte_offset', asI64(emit(obj))]], 'f64')
-  }
+    return boff(obj)
+  })
 
   // Runtime fallback for .byteOffset when variable view-ness is unknown.
   ctx.core.stdlib['__byte_offset'] = `(func $__byte_offset (param $ptr i64) (result i32)
@@ -488,8 +491,7 @@ export default (ctx) => {
   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', ['i64.reinterpret_f64', va]], ['i32.const', PTR.TYPED]]], 'f64')
+    return typed(['f64.convert_i32_s', ptrTypeEq(va, PTR.TYPED)], 'f64')
   }
 
   // x instanceof Float64Array | Int32Array | … — typed-pointer predicate emitted
@@ -502,7 +504,7 @@ export default (ctx) => {
     const t = temp('ityp')
     return typed(['i32.and',
       ['f64.ne', ['local.tee', `$${t}`, v], ['local.get', `$${t}`]],
-      ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${t}`]]], ['i32.const', PTR.TYPED]]], 'i32')
+      ptrTypeEq(['local.get', `$${t}`], PTR.TYPED)], 'i32')
   }
 
   // buf.slice(begin?, end?) on a BUFFER → fresh BUFFER with the byte range copied.
@@ -598,7 +600,7 @@ export default (ctx) => {
   // (cheap: 4 wasm ops) so `getFloat32`/`getFloat64` return a real-spec NaN value.
   ctx.core.stdlib['__canon_nan'] = `(func $__canon_nan (param $v f64) (result f64)
     (select
-      (f64.reinterpret_i64 (i64.const 0x7FF8000000000000))
+      (f64.reinterpret_i64 (i64.const ${_NAN_BITS}))
       (local.get $v)
       (f64.ne (local.get $v) (local.get $v))))`
   const canonNaN = (vIR) => { inc('__canon_nan'); return typed(['call', '$__canon_nan', vIR], 'f64') }
@@ -799,7 +801,7 @@ export default (ctx) => {
   }
 
   // TypedArray.from(arr) — convert regular array to typed array
-  for (const [name, elemType] of Object.entries(ELEM)) {
+  for (const [name, elemType] of Object.entries(TYPED_ELEM_CODE)) {
     const aux = typedAux(name)
     const stride = STRIDE[elemType], store = STORE[elemType]
     ctx.core.emit[`${name}.from`] = (src) => {
@@ -845,20 +847,23 @@ export default (ctx) => {
    *      at the chain output (the result is always an owned typed array). */
   const TYPED_CHAIN_METHODS = new Set(['map', 'filter', 'slice'])
   const resolveElem = (arr) => {
-    let receiver = arr, chainOutput = false
+    let receiver = arr, chainOutput = false, viewOutput = false
     // Walk method-call chain inward. `arr.method(...)` parses as
-    // ['()', ['.', recv, 'method'], ...args] — peel until we hit a name.
+    // ['()', ['.', recv, 'method'], ...args] — peel until we hit a name. The OUTERMOST
+    // op decides view-ness: `.subarray(...)` yields a zero-copy VIEW (reads must indirect
+    // through the descriptor), whereas `.map`/`.slice`/… yield a fresh non-view copy.
     while (Array.isArray(receiver) && receiver[0] === '()' &&
         Array.isArray(receiver[1]) && receiver[1][0] === '.' &&
-        TYPED_CHAIN_METHODS.has(receiver[1][2])) {
+        (TYPED_CHAIN_METHODS.has(receiver[1][2]) || receiver[1][2] === 'subarray')) {
+      if (!chainOutput) viewOutput = receiver[1][2] === 'subarray'
       receiver = receiver[1][1]
       chainOutput = true
     }
     const ctor = typeof receiver === 'string' && ctx.types.typedElem?.get(receiver)
     if (!ctor) return null
-    const isView = !chainOutput && ctor.endsWith('.view')
+    const isView = viewOutput || (!chainOutput && ctor.endsWith('.view'))
     const name = ctor.endsWith('.view') ? ctor.slice(4, -5) : ctor.slice(4)
-    const et = ELEM[name]
+    const et = TYPED_ELEM_CODE[name]
     return et == null ? null : { et, isView, isBigInt: name === 'BigInt64Array' || name === 'BigUint64Array' }
   }
 
@@ -866,9 +871,19 @@ export default (ctx) => {
    *  Owned: low 32 bits of the NaN-box (or the unboxed local directly).
    *  View: load descriptor[4]. Uses ptrOffsetIR so unboxed-TYPED locals pass through
    *  without a rebox-then-unbox round trip, and globals fold to inline bit-extract. */
+  // A typed array (Float64Array/Int32Array/…) is a FIXED-SIZE allocation — it has no
+  // grow op, so it can never relocate, so its base needs no realloc-forwarding follow.
+  // An already-unboxed pointer is the offset itself; a boxed f64 pointer extracts its
+  // low-32 offset directly — no __ptr_offset call. (The general ptrOffsetIR keeps the
+  // forwarding follow because ARRAY/HASH/SET/MAP relocate and an *inferred* OBJECT can
+  // alias a relocated ARRAY — but VAL.TYPED is a narrow type that can only be a real
+  // typed array, so the follow is provably dead here.)
+  const typedBase = (objIR) => objIR.ptrKind != null && objIR.ptrKind !== VAL.ARRAY
+    ? objIR
+    : ['i32.wrap_i64', ['i64.and', ['i64.reinterpret_f64', asF64(objIR)], ['i64.const', LAYOUT.OFFSET_MASK]]]
   const typedDataAddr = (objIR, isView) => isView
-    ? ['i32.load', ['i32.add', ptrOffsetIR(objIR, VAL.TYPED), ['i32.const', 4]]]
-    : ptrOffsetIR(objIR, VAL.TYPED)
+    ? ['i32.load', ['i32.add', typedBase(objIR), ['i32.const', 4]]]
+    : typedBase(objIR)
 
   // Runtime-dispatch typed index: checks ptr_type + aux to load with correct stride.
   // For TYPED views (aux bit 3), $off indirects through descriptor[4] to real data.
@@ -913,7 +928,7 @@ 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 (if (result f64) (i32.and (local.get $aux) (i32.const ${BIGINT_ELEM_FLAG}))
+                (then (if (result f64) (i32.and (local.get $aux) (i32.const ${TYPED_ELEM_BIGINT_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))))))))
@@ -938,7 +953,7 @@ export default (ctx) => {
     (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}))
+    (if (i32.and (local.get $aux) (i32.const ${TYPED_ELEM_BIGINT_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))
@@ -959,12 +974,225 @@ export default (ctx) => {
                     (else (i32.store8 (i32.add (local.get $off) (local.get $i)) (local.get $bits))))))))))))
     (local.get $v))`
 
+  // .fill(value, start?, end?) for typed arrays. The plain-array __arr_fill gates
+  // on PTR.ARRAY and silently no-ops a typed receiver (the storage layout and
+  // element width differ); this loops the element-width-aware __typed_set_idx
+  // over the clamped range so every element kind (u8…f64, BigInt) fills correctly.
+  // start/end default 0/length, accept negatives, and clamp to [0, length].
+  ctx.core.stdlib['__typed_fill'] = `(func $__typed_fill (param $ptr i64) (param $val f64) (param $start i32) (param $end i32) (result f64)
+    (local $len i32) (local $i i32)
+    (local.set $len (call $__len (local.get $ptr)))
+    (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 $i (local.get $start))
+    (block $done (loop $fill
+      (br_if $done (i32.ge_s (local.get $i) (local.get $end)))
+      (drop (call $__typed_set_idx (local.get $ptr) (local.get $i) (local.get $val)))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (br $fill)))
+    (f64.reinterpret_i64 (local.get $ptr)))`
+
+  // Element-width/-kind-aware read: arr[i] → f64, the read mirror of __typed_set_idx.
+  // Integers convert by signedness (et&1 ⇒ unsigned); BigInt returns the raw i64 bits
+  // reinterpreted as f64 so a get→set roundtrip is bit-exact (set_idx stores the bits
+  // back unchanged). Used by the in-place algorithms below for random-access reads.
+  ctx.core.stdlib['__typed_get_idx'] = `(func $__typed_get_idx (param $ptr i64) (param $i i32) (result f64)
+    (local $off i32) (local $aux i32) (local $et i32)
+    (local.set $aux (call $__ptr_aux (local.get $ptr)))
+    (local.set $off (call $__ptr_offset (local.get $ptr)))
+    (if (i32.and (local.get $aux) (i32.const 8))
+      (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 (result f64) (i32.and (local.get $aux) (i32.const ${TYPED_ELEM_BIGINT_FLAG}))
+      (then (f64.reinterpret_i64 (i64.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3))))))
+      (else (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)))))
+        (else (if (result f64) (i32.eq (local.get $et) (i32.const 6))
+          (then (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)))))))))))))))))`
+
+  // .reverse() — in-place, element-kind-agnostic via get/set (bit-exact for BigInt).
+  ctx.core.stdlib['__typed_reverse'] = `(func $__typed_reverse (param $ptr i64) (result f64)
+    (local $len i32) (local $i i32) (local $j i32) (local $t f64)
+    (local.set $len (call $__len (local.get $ptr)))
+    (local.set $i (i32.const 0))
+    (local.set $j (i32.sub (local.get $len) (i32.const 1)))
+    (block $done (loop $rev
+      (br_if $done (i32.ge_s (local.get $i) (local.get $j)))
+      (local.set $t (call $__typed_get_idx (local.get $ptr) (local.get $i)))
+      (drop (call $__typed_set_idx (local.get $ptr) (local.get $i) (call $__typed_get_idx (local.get $ptr) (local.get $j))))
+      (drop (call $__typed_set_idx (local.get $ptr) (local.get $j) (local.get $t)))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (local.set $j (i32.sub (local.get $j) (i32.const 1)))
+      (br $rev)))
+    (f64.reinterpret_i64 (local.get $ptr)))`
+
+  // .copyWithin(target, start, end) — in-place overlap-safe move. Indices accept
+  // negatives (from end) and clamp to [0, len]; count = min(end-start, len-target).
+  // Direction picked so overlapping ranges don't clobber unread source elements.
+  ctx.core.stdlib['__typed_copyWithin'] = `(func $__typed_copyWithin (param $ptr i64) (param $target i32) (param $start i32) (param $end i32) (result f64)
+    (local $len i32) (local $count i32) (local $k i32)
+    (local.set $len (call $__len (local.get $ptr)))
+    (if (i32.lt_s (local.get $target) (i32.const 0)) (then (local.set $target (i32.add (local.get $len) (local.get $target)))))
+    (if (i32.lt_s (local.get $target) (i32.const 0)) (then (local.set $target (i32.const 0))))
+    (if (i32.gt_s (local.get $target) (local.get $len)) (then (local.set $target (local.get $len))))
+    (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 $count (i32.sub (local.get $end) (local.get $start)))
+    (if (i32.gt_s (local.get $count) (i32.sub (local.get $len) (local.get $target)))
+      (then (local.set $count (i32.sub (local.get $len) (local.get $target)))))
+    (if (i32.lt_s (local.get $target) (local.get $start))
+      (then
+        (local.set $k (i32.const 0))
+        (block $fd (loop $fl
+          (br_if $fd (i32.ge_s (local.get $k) (local.get $count)))
+          (drop (call $__typed_set_idx (local.get $ptr) (i32.add (local.get $target) (local.get $k))
+            (call $__typed_get_idx (local.get $ptr) (i32.add (local.get $start) (local.get $k)))))
+          (local.set $k (i32.add (local.get $k) (i32.const 1)))
+          (br $fl))))
+      (else
+        (local.set $k (local.get $count))
+        (block $bd (loop $bl
+          (br_if $bd (i32.le_s (local.get $k) (i32.const 0)))
+          (local.set $k (i32.sub (local.get $k) (i32.const 1)))
+          (drop (call $__typed_set_idx (local.get $ptr) (i32.add (local.get $target) (local.get $k))
+            (call $__typed_get_idx (local.get $ptr) (i32.add (local.get $start) (local.get $k)))))
+          (br $bl)))))
+    (f64.reinterpret_i64 (local.get $ptr)))`
+
+  // .sort() — default numeric order (insertion sort, stable). NaN sorts to the end,
+  // -0 before +0 (the equal-value tiebreak via signed-bit compare). BigInt arrays are
+  // compared as signed i64 on their exact bits. A user comparator is handled inline by
+  // the .typed:sort emitter (this helper is the no-argument numeric path).
+  ctx.core.stdlib['__typed_sort'] = `(func $__typed_sort (param $ptr i64) (result f64)
+    (local $isbig i32) (local $len i32) (local $i i32) (local $j i32) (local $saved f64) (local $nb f64)
+    (local.set $isbig (i32.and (call $__ptr_aux (local.get $ptr)) (i32.const ${TYPED_ELEM_BIGINT_FLAG})))
+    (local.set $len (call $__len (local.get $ptr)))
+    (local.set $i (i32.const 1))
+    (block $od (loop $ol
+      (br_if $od (i32.ge_s (local.get $i) (local.get $len)))
+      (local.set $saved (call $__typed_get_idx (local.get $ptr) (local.get $i)))
+      (local.set $j (i32.sub (local.get $i) (i32.const 1)))
+      (block $id (loop $il
+        (br_if $id (i32.lt_s (local.get $j) (i32.const 0)))
+        (local.set $nb (call $__typed_get_idx (local.get $ptr) (local.get $j)))
+        (br_if $id (i32.eqz
+          (if (result i32) (local.get $isbig)
+            (then (i64.gt_s (i64.reinterpret_f64 (local.get $nb)) (i64.reinterpret_f64 (local.get $saved))))
+            (else (if (result i32) (f64.ne (local.get $nb) (local.get $nb))
+              (then (i32.eqz (f64.ne (local.get $saved) (local.get $saved))))
+              (else (if (result i32) (f64.ne (local.get $saved) (local.get $saved))
+                (then (i32.const 0))
+                (else (if (result i32) (f64.gt (local.get $nb) (local.get $saved))
+                  (then (i32.const 1))
+                  (else (if (result i32) (f64.lt (local.get $nb) (local.get $saved))
+                    (then (i32.const 0))
+                    (else (i64.gt_s (i64.reinterpret_f64 (local.get $nb)) (i64.reinterpret_f64 (local.get $saved)))))))))))))))
+        (drop (call $__typed_set_idx (local.get $ptr) (i32.add (local.get $j) (i32.const 1)) (local.get $nb)))
+        (local.set $j (i32.sub (local.get $j) (i32.const 1)))
+        (br $il)))
+      (drop (call $__typed_set_idx (local.get $ptr) (i32.add (local.get $j) (i32.const 1)) (local.get $saved)))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (br $ol)))
+    (f64.reinterpret_i64 (local.get $ptr)))`
+
+  ctx.core.emit['.typed:fill'] = (arr, val, start, end) => {
+    inc('__typed_fill')
+    return typed(['call', '$__typed_fill',
+      asI64(emit(arr)),
+      val == null ? undefExpr() : asF64(emit(val)),
+      start == null ? ['i32.const', 0] : asI32(emit(start)),
+      end == null ? ['i32.const', 0x7FFFFFFF] : asI32(emit(end))], 'f64')
+  }
+
+  // .reverse() / .copyWithin(...) for typed arrays. The plain-array helpers gate on
+  // PTR.ARRAY and silently no-op a typed receiver; these go through the element-kind-
+  // aware get/set helpers so every width and signedness reverses/moves correctly.
+  ctx.core.emit['.typed:reverse'] = (arr) => {
+    inc('__typed_reverse')
+    return typed(['call', '$__typed_reverse', asI64(emit(arr))], 'f64')
+  }
+
+  ctx.core.emit['.typed:copyWithin'] = (arr, target, start, end) => {
+    inc('__typed_copyWithin')
+    return typed(['call', '$__typed_copyWithin',
+      asI64(emit(arr)),
+      target == null ? ['i32.const', 0] : asI32(emit(target)),
+      start == null ? ['i32.const', 0] : asI32(emit(start)),
+      end == null ? ['i32.const', 0x7FFFFFFF] : asI32(emit(end))], 'f64')
+  }
+
+  // .sort(compareFn?) for typed arrays. No argument → the numeric __typed_sort helper
+  // (typed-array default is NUMERIC, unlike Array.sort's lexicographic default — so it
+  // must NOT route through the plain-array string comparator). With a comparator, an
+  // insertion sort is emitted inline, calling the closure per neighbor compare; a
+  // positive return shifts (same convention as Array.prototype.sort).
+  // Sort the typed array VALUE `arrValIR` in place and return it. Factored out so
+  // .typed:sort sorts the receiver and .typed:toSorted sorts a fresh copy with one body.
+  const emitTypedSort = (arrValIR, fn) => {
+    if (fn == null) {
+      inc('__typed_sort')
+      return typed(['call', '$__typed_sort', asI64(arrValIR)], 'f64')
+    }
+    inc('__len', '__typed_get_idx', '__typed_set_idx')
+    const arrL = temp('tsa'), cbL = temp('tsf')
+    const len = tempI32('tsn'), i = tempI32('tsi'), j = tempI32('tsj')
+    const cur = temp('tsc'), nb = temp('tsb')
+    const id = ctx.func.uniq++
+    const oE = `$tsoe${id}`, oL = `$tsol${id}`, iE = `$tsie${id}`, iL = `$tsil${id}`
+    const ptr = () => ['i64.reinterpret_f64', ['local.get', `$${arrL}`]]
+    const jp1 = ['i32.add', ['local.get', `$${j}`], ['i32.const', 1]]
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${arrL}`, asF64(arrValIR)],
+      ['local.set', `$${cbL}`, asF64(emit(fn))],
+      ['local.set', `$${len}`, ['call', '$__len', ptr()]],
+      ['local.set', `$${i}`, ['i32.const', 1]],
+      ['block', oE, ['loop', oL,
+        ['br_if', oE, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${len}`]]],
+        ['local.set', `$${cur}`, ['call', '$__typed_get_idx', ptr(), ['local.get', `$${i}`]]],
+        ['local.set', `$${j}`, ['i32.sub', ['local.get', `$${i}`], ['i32.const', 1]]],
+        ['block', iE, ['loop', iL,
+          ['br_if', iE, ['i32.lt_s', ['local.get', `$${j}`], ['i32.const', 0]]],
+          ['local.set', `$${nb}`, ['call', '$__typed_get_idx', ptr(), ['local.get', `$${j}`]]],
+          // Break unless cmp(neighbor, cur) > 0. f64.gt is false for NaN (spec NaN-as-0).
+          ['br_if', iE, ['i32.eqz', ['f64.gt',
+            asF64(ctx.closure.call(typed(['local.get', `$${cbL}`], 'f64'),
+              [typed(['local.get', `$${nb}`], 'f64'), typed(['local.get', `$${cur}`], 'f64')])),
+            ['f64.const', 0]]]],
+          ['drop', ['call', '$__typed_set_idx', ptr(), jp1, ['local.get', `$${nb}`]]],
+          ['local.set', `$${j}`, ['i32.sub', ['local.get', `$${j}`], ['i32.const', 1]]],
+          ['br', iL]]],
+        ['drop', ['call', '$__typed_set_idx', ptr(), jp1, ['local.get', `$${cur}`]]],
+        ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+        ['br', oL]]],
+      ['local.get', `$${arrL}`]], 'f64')
+  }
+  ctx.core.emit['.typed:sort'] = (arr, fn) => emitTypedSort(emit(arr), fn)
+
   // Type-aware TypedArray read: arr[i]
-  ctx.core.emit['.typed:[]'] = (arr, idx) => {
+  ctx.core.emit['.typed:[]'] = (arr, i) => {
     const r = resolveElem(arr)
     if (r == null) return null // unknown type, fallback to generic
     const { et, isView, isBigInt } = r
-    const objIR = emit(arr), vi = asI32(emit(idx))
+    const objIR = emit(arr), vi = idx(i)
     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
@@ -974,11 +1202,11 @@ export default (ctx) => {
   }
 
   // Type-aware TypedArray write: arr[i] = val
-  ctx.core.emit['.typed:[]='] = (arr, idx, val, void_ = false) => {
+  ctx.core.emit['.typed:[]='] = (arr, i, val, void_ = false) => {
     const r = resolveElem(arr)
     if (r == null) return null
     const { et, isView, isBigInt } = r
-    const objIR = emit(arr), vi = asI32(emit(idx)), valIR = emit(val)
+    const objIR = emit(arr), vi = idx(i), valIR = emit(val)
     const off = ['i32.add', typedDataAddr(objIR, isView), ['i32.shl', vi, ['i32.const', SHIFT[et]]]]
     if (isBigInt) {
       const vt = temp('tw')
@@ -1213,7 +1441,7 @@ export default (ctx) => {
   // ABI width at 2 to spare a slot across the whole program). Reduce passes
   // (acc, item). Closure invocation goes through `ctx.closure.call` directly.
   // The element-type-name list is needed by allocPtr for typedAux:
-  const ET_NAME = ['Int8Array','Uint8Array','Int16Array','Uint16Array','Int32Array','Uint32Array','Float32Array','Float64Array']
+  const ET_NAME = TYPED_ELEM_NAMES
 
   // .forEach: callback (item, idx). Result is 0 to match array.js's
   // convention (spec says undefined; both modules pick 0 since f() exposes the
@@ -1260,18 +1488,54 @@ export default (ctx) => {
 
   // .indexOf: scalar value-equality search. Returns -1 on miss. Compare on f64
   // — Array.prototype.indexOf uses strict equality (NaN ≠ NaN).
-  ctx.core.emit['.typed:indexOf'] = (arr, val) => {
-    const found = tempI32('tif'), needle = temp('tin')
-    const loop = typedLoop(arr, (load, i, _len, _ptr, exit) => [
-      ['if', ['f64.eq', load(), ['local.get', `$${needle}`]],
-        ['then',
-          ['local.set', `$${found}`, ['local.get', `$${i}`]],
-          ['br', exit]]]
-    ])
+  // Effective start index for a fromIndex arg: negative counts from the end. The match
+  // guard is `i >= start` and i ≥ 0, so a start below 0 needs no clamp (always passes).
+  const fromStart = (fiL, len) => ['if', ['result', 'i32'],
+    ['i32.lt_s', ['local.get', `$${fiL}`], ['i32.const', 0]],
+    ['then', ['i32.add', ['local.get', `$${fiL}`], ['local.get', `$${len}`]]],
+    ['else', ['local.get', `$${fiL}`]]]
+
+  ctx.core.emit['.typed:indexOf'] = (arr, val, fromIndex) => {
+    const found = tempI32('tif'), needle = temp('tin'), fiL = tempI32('tifx')
+    const loop = typedLoop(arr, (load, i, len, _ptr, exit) => {
+      const matched = ['f64.eq', load(), ['local.get', `$${needle}`]]
+      const cond = fromIndex == null ? matched
+        : ['i32.and', ['i32.ge_s', ['local.get', `$${i}`], fromStart(fiL, len)], matched]
+      return [['if', cond, ['then',
+        ['local.set', `$${found}`, ['local.get', `$${i}`]], ['br', exit]]]]
+    })
+    if (!loop) return null
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${needle}`, asF64(emit(val))],
+      ['local.set', `$${found}`, ['i32.const', -1]],
+      ...(fromIndex == null ? [] : [['local.set', `$${fiL}`, asI32(emit(fromIndex))]]),
+      ...loop.setup,
+      ['f64.convert_i32_s', ['local.get', `$${found}`]]], 'f64')
+  }
+
+  // .lastIndexOf(val): the last index whose element strictly-equals val, else -1.
+  // Was unimplemented for typed arrays (threw). A forward scan that keeps the latest
+  // match needs no reverse iteration — equivalent for the no-fromIndex form, which is
+  // the common case. With a fromIndex the matcher additionally bounds i ≤ fromIndex
+  // (negative counts from the end, resolved against the typedLoop len). NaN never
+  // strict-equals (f64.eq), matching JS.
+  ctx.core.emit['.typed:lastIndexOf'] = (arr, val, fromIndex) => {
+    const found = tempI32('tlf'), needle = temp('tln'), fiL = tempI32('tlfi')
+    const loop = typedLoop(arr, (load, i, len) => {
+      const matched = ['f64.eq', load(), ['local.get', `$${needle}`]]
+      if (fromIndex == null)
+        return [['if', matched, ['then', ['local.set', `$${found}`, ['local.get', `$${i}`]]]]]
+      const lim = ['if', ['result', 'i32'], ['i32.lt_s', ['local.get', `$${fiL}`], ['i32.const', 0]],
+        ['then', ['i32.add', ['local.get', `$${fiL}`], ['local.get', `$${len}`]]],
+        ['else', ['local.get', `$${fiL}`]]]
+      return [['if', ['i32.and', ['i32.le_s', ['local.get', `$${i}`], lim], matched],
+        ['then', ['local.set', `$${found}`, ['local.get', `$${i}`]]]]]
+    })
     if (!loop) return null
     return typed(['block', ['result', 'f64'],
       ['local.set', `$${needle}`, asF64(emit(val))],
       ['local.set', `$${found}`, ['i32.const', -1]],
+      ...(fromIndex == null ? [] : [['local.set', `$${fiL}`, asI32(emit(fromIndex))]]),
       ...loop.setup,
       ['f64.convert_i32_s', ['local.get', `$${found}`]]], 'f64')
   }
@@ -1279,21 +1543,23 @@ export default (ctx) => {
   // .includes: like indexOf but NaN-equal-NaN (JS spec). Stash needle bits as
   // i64 and compare via i64.eq so two NaNs with matching bit patterns match
   // (f64.eq would say false).
-  ctx.core.emit['.typed:includes'] = (arr, val) => {
-    const found = tempI32('thf'), needle = temp('thn')
-    const loop = typedLoop(arr, (load, _i, _len, _ptr, exit) => [
-      ['if',
-        ['i32.or',
-          ['f64.eq', load(), ['local.get', `$${needle}`]],
-          ['i64.eq',
-            ['i64.reinterpret_f64', load()],
-            ['i64.reinterpret_f64', ['local.get', `$${needle}`]]]],
-        ['then', ['local.set', `$${found}`, ['i32.const', 1]], ['br', exit]]]
-    ])
+  ctx.core.emit['.typed:includes'] = (arr, val, fromIndex) => {
+    const found = tempI32('thf'), needle = temp('thn'), fiL = tempI32('thx')
+    const loop = typedLoop(arr, (load, i, len, _ptr, exit) => {
+      const matched = ['i32.or',
+        ['f64.eq', load(), ['local.get', `$${needle}`]],
+        ['i64.eq',
+          ['i64.reinterpret_f64', load()],
+          ['i64.reinterpret_f64', ['local.get', `$${needle}`]]]]
+      const cond = fromIndex == null ? matched
+        : ['i32.and', ['i32.ge_s', ['local.get', `$${i}`], fromStart(fiL, len)], matched]
+      return [['if', cond, ['then', ['local.set', `$${found}`, ['i32.const', 1]], ['br', exit]]]]
+    })
     if (!loop) return null
     return typed(['block', ['result', 'f64'],
       ['local.set', `$${needle}`, asF64(emit(val))],
       ['local.set', `$${found}`, ['i32.const', 0]],
+      ...(fromIndex == null ? [] : [['local.set', `$${fiL}`, asI32(emit(fromIndex))]]),
       ...loop.setup,
       ['f64.convert_i32_s', ['local.get', `$${found}`]]], 'f64')
   }
@@ -1331,6 +1597,40 @@ export default (ctx) => {
   ctx.core.emit['.typed:find'] = (arr, fn) => findCommon(arr, fn, false)
   ctx.core.emit['.typed:findIndex'] = (arr, fn) => findCommon(arr, fn, true)
 
+  // .findLast / .findLastIndex — like find/findIndex but keep the LAST match instead of
+  // the first, so no early break (a forward scan that overwrites on each hit). Without a
+  // typed handler these routed through the plain-array versions, which read elements as
+  // raw f64 and returned garbage for non-f64 typed arrays.
+  const findLastCommon = (arr, fn, returnIndex) => {
+    const cbLoc = temp('tLc'), result = temp('tLr'), foundIdx = tempI32('tLi')
+    const loop = typedLoop(arr, (load, i) => {
+      const itemLoc = temp('tLit')
+      return [
+        ['local.set', `$${itemLoc}`, load()],
+        ['if', truthyIR(ctx.closure.call(
+          typed(['local.get', `$${cbLoc}`], 'f64'),
+          [typed(['local.get', `$${itemLoc}`], 'f64'),
+           typed(['f64.convert_i32_s', ['local.get', `$${i}`]], 'f64')])),
+          ['then',
+            returnIndex
+              ? ['local.set', `$${foundIdx}`, ['local.get', `$${i}`]]
+              : ['local.set', `$${result}`, typed(['local.get', `$${itemLoc}`], 'f64')]]]
+      ]
+    })
+    if (!loop) return null
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${cbLoc}`, asF64(emit(fn))],
+      returnIndex
+        ? ['local.set', `$${foundIdx}`, ['i32.const', -1]]
+        : ['local.set', `$${result}`, undefExpr()],
+      ...loop.setup,
+      returnIndex
+        ? typed(['f64.convert_i32_s', ['local.get', `$${foundIdx}`]], 'f64')
+        : typed(['local.get', `$${result}`], 'f64')], 'f64')
+  }
+  ctx.core.emit['.typed:findLast'] = (arr, fn) => findLastCommon(arr, fn, false)
+  ctx.core.emit['.typed:findLastIndex'] = (arr, fn) => findLastCommon(arr, fn, true)
+
   // .some / .every: short-circuit boolean reduction. some=∃, every=∀.
   const anyAllCommon = (arr, fn, isEvery) => {
     const cbLoc = temp('tac'), result = tempI32('tar')
@@ -1463,4 +1763,90 @@ export default (ctx) => {
         ['i32.shl', ['local.get', `$${n}`], ['i32.const', SHIFT[et]]]],
       dst.ptr], 'f64')
   }
+
+  // .toReversed() — a reversed COPY (receiver unchanged): full slice-copy, then reverse
+  // the copy in place. (slice bails on BigInt, so BigInt receivers fall back to a throw.)
+  ctx.core.emit['.typed:toReversed'] = (arr) => {
+    const copy = ctx.core.emit['.typed:slice'](arr)
+    if (!copy) return null
+    inc('__typed_reverse')
+    const c = temp('ttv')
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${c}`, asF64(copy)],
+      ['call', '$__typed_reverse', ['i64.reinterpret_f64', ['local.get', `$${c}`]]]], 'f64')
+  }
+
+  // .toSorted(fn?) — a sorted COPY (receiver unchanged): slice-copy, then sort in place.
+  ctx.core.emit['.typed:toSorted'] = (arr, fn) => {
+    const copy = ctx.core.emit['.typed:slice'](arr)
+    return copy ? emitTypedSort(copy, fn) : null
+  }
+
+  // .with(index, value) — a COPY with one element replaced (receiver unchanged). Negative
+  // index counts from the end; out of range throws RangeError ($__jz_err), per spec.
+  ctx.core.emit['.typed:with'] = (arr, index, value) => {
+    const copy = ctx.core.emit['.typed:slice'](arr)
+    if (!copy) return null
+    ctx.runtime.throws = true
+    inc('__len', '__typed_set_idx')
+    const c = temp('twc'), idx = tempI32('twi'), len = tempI32('twl')
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${c}`, asF64(copy)],
+      ['local.set', `$${len}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${c}`]]]],
+      ['local.set', `$${idx}`, asI32(emit(index))],
+      ['if', ['i32.lt_s', ['local.get', `$${idx}`], ['i32.const', 0]],
+        ['then', ['local.set', `$${idx}`, ['i32.add', ['local.get', `$${idx}`], ['local.get', `$${len}`]]]]],
+      ['if', ['i32.or',
+          ['i32.lt_s', ['local.get', `$${idx}`], ['i32.const', 0]],
+          ['i32.ge_s', ['local.get', `$${idx}`], ['local.get', `$${len}`]]],
+        ['then', ['throw', '$__jz_err', ['f64.const', 0]]]],
+      ['drop', ['call', '$__typed_set_idx', ['i64.reinterpret_f64', ['local.get', `$${c}`]],
+        ['local.get', `$${idx}`], asF64(emit(value))]],
+      ['local.get', `$${c}`]], 'f64')
+  }
+
+  // .subarray(begin, end) — a zero-copy VIEW sharing the receiver's buffer (writes alias,
+  // NOT a copy). Builds the 16-byte descriptor [byteLen][dataOff][parentOff] and tags the
+  // TYPED ptr with aux|view, exactly like new TypedArray(buffer, byteOffset, length).
+  ctx.core.emit['.typed:subarray'] = (arr, begin, end) => {
+    const r = resolveElem(arr)
+    if (!r) return null
+    const { et, isView, isBigInt } = r
+    const shift = SHIFT[et]
+    const viewAux = et | 8 | (isBigInt ? 16 : 0)
+    const arrL = temp('tua'), srcOff = tempI32('tuo'), data = tempI32('tud'), root = tempI32('tur')
+    const len = tempI32('tul'), lo = tempI32('tulo'), hi = tempI32('tuhi'), n = tempI32('tun'), desc = tempI32('tude')
+    inc('__len')
+    const off4 = (o) => ['i32.load', ['i32.add', ['local.get', `$${srcOff}`], ['i32.const', o]]]
+    const clamp = (boundExpr, dflt, name) => {
+      if (boundExpr == null) return dflt
+      const v = tempI32(name)
+      return ['block', ['result', 'i32'],
+        ['local.set', `$${v}`, asI32(emit(boundExpr))],
+        ['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}`]]
+    }
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${arrL}`, asF64(emit(arr))],
+      ['local.set', `$${srcOff}`, typedBase(typed(['local.get', `$${arrL}`], 'f64'))],
+      ['local.set', `$${data}`, isView ? off4(4) : ['local.get', `$${srcOff}`]],
+      ['local.set', `$${root}`, isView ? off4(8) : ['local.get', `$${srcOff}`]],
+      ['local.set', `$${len}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${arrL}`]]]],
+      ['local.set', `$${lo}`, clamp(begin, ['i32.const', 0], 'tub')],
+      ['local.set', `$${hi}`, clamp(end, ['local.get', `$${len}`], 'tue')],
+      ['local.set', `$${n}`, ['select',
+        ['i32.sub', ['local.get', `$${hi}`], ['local.get', `$${lo}`]], ['i32.const', 0],
+        ['i32.gt_s', ['local.get', `$${hi}`], ['local.get', `$${lo}`]]]],
+      ['local.set', `$${desc}`, ['call', '$__alloc', ['i32.const', 16]]],
+      ['i32.store', ['local.get', `$${desc}`], ['i32.shl', ['local.get', `$${n}`], ['i32.const', shift]]],
+      ['i32.store', ['i32.add', ['local.get', `$${desc}`], ['i32.const', 4]],
+        ['i32.add', ['local.get', `$${data}`], ['i32.shl', ['local.get', `$${lo}`], ['i32.const', shift]]]],
+      ['i32.store', ['i32.add', ['local.get', `$${desc}`], ['i32.const', 8]], ['local.get', `$${root}`]],
+      mkPtrIR(PTR.TYPED, viewAux, ['local.get', `$${desc}`])], 'f64')
+  }
 }