jz 0.6.0 → 0.7.0

package/module/string.js

@@ -114,8 +114,8 @@ export default (ctx) => {
     __str_copy: [],
     __str_slice: ['__str_byteLen', '__alloc'],
     __str_slice_view: ['__str_byteLen', '__mkptr', '__str_slice'],
-    __str_indexof: ['__str_byteLen', '__to_str'],
-    __str_lastindexof: ['__str_byteLen', '__to_str'],
+    __str_indexof: ['__str_byteLen'],
+    __str_lastindexof: ['__str_byteLen'],
     __wrap1: ['__alloc', '__mkptr'],
     __str_substring: ['__str_slice'],
     __str_startswith: ['__str_byteLen'],
@@ -145,9 +145,21 @@ export default (ctx) => {
     __str_byteLen: ['__ptr_type', '__ptr_aux', '__str_len'],
   })
 
+  // String *runtime* construction (concat/slice/split/`String(n)`/shared-memory
+  // pools) allocates and boxes pointers, so the module eagerly declares its core
+  // heap deps — same as object.js / typedarray.js / array.js. Several such helpers
+  // (`__str_slice`, `__str_split`, `__str_case`, …) call `$__mkptr`/`$__alloc` only
+  // through nested template thunks (sliceSsoPackWat/internProbeWat); resolveIncludes'
+  // auto-derivation realizes those thunks to recover the dep, but that re-realization
+  // is not reliable under self-host (the jz.wasm kernel re-runs the thunk late, with
+  // intern/heap state the native run never reaches), so a runtime string op would
+  // emit `call $__mkptr` with no definition. Declaring the deps explicitly here makes
+  // inclusion independent of thunk re-realization. Reachability pruning still drops
+  // both for a literals-only module (no `__mkptr`/`__alloc` call site → unreachable),
+  // so a heap-free program stays heap-free — no allocator, no memory, no exports.
   inc('__mkptr', '__alloc')
 
-  // === String literal: "abc" → SSO if ≤4 ASCII, else heap ===
+  // === String literal: "abc" → SSO if ≤4 ASCII, else static data ===
 
   bind('str', (str) => {
     const MAX_SSO = 4
@@ -684,8 +696,8 @@ export default (ctx) => {
     (local $hlen i32) (local $nlen i32) (local $i i32) (local $j i32) (local $match i32)
     (local $hoff i32) (local $noff i32)
     (local $hsso i32) (local $nsso i32) (local $hb i32) (local $nb i32) (local $k i32)
-    ;; ToString the search value (21.1.3.9 step 4) — coerces undefined/null/number/etc.
-    (local.set $ndl (call $__to_str (local.get $ndl)))
+    ;; The search value is ToString'd at the call site (searchArg) per 21.1.3.9 step 4 —
+    ;; a known-string needle passes raw, so this helper carries no float-pulling __to_str.
     (local.set $hlen (call $__str_byteLen (local.get $hay)))
     (local.set $nlen (call $__str_byteLen (local.get $ndl)))
     (if (i32.eqz (local.get $nlen)) (then (return (local.get $from))))
@@ -729,8 +741,7 @@ export default (ctx) => {
     (local $hlen i32) (local $nlen i32) (local $i i32) (local $j i32) (local $match i32)
     (local $hoff i32) (local $noff i32)
     (local $hsso i32) (local $nsso i32) (local $hb i32) (local $nb i32) (local $k i32)
-    ;; ToString the search value (21.1.3.10 step 4)
-    (local.set $ndl (call $__to_str (local.get $ndl)))
+    ;; The search value is ToString'd at the call site (searchArg) per 21.1.3.10 step 4.
     (local.set $hlen (call $__str_byteLen (local.get $hay)))
     (local.set $nlen (call $__str_byteLen (local.get $ndl)))
     ;; Empty needle always matches at the clamp(from,0,hlen) position
@@ -1430,9 +1441,22 @@ export default (ctx) => {
   // covers string/number/null/undefined needles, but two cases need help here:
   // a BOOL rides the 0/1 carrier (→ "0"/"1" not "true"/"false"), and an OBJECT
   // needs compile-time ToPrimitive(string) (__to_str can't invoke user toString).
-  const searchArg = (search) =>
-    valTypeOf(search) === VAL.BOOL ? asI64(bool(search)) :
-    valTypeOf(search) === VAL.OBJECT ? toStrI64(search, emit(search)) : asI64(emit(search))
+  // Coerce the search operand to a string AT THE CALL SITE (21.1.3.x ToString step),
+  // so the `__str_indexof` family carries no embedded `__to_str`. A known-STRING arg
+  // (the overwhelmingly common `s.indexOf("x")` / `s.indexOf(t)` shape) passes raw —
+  // dropping the whole ToString → float-formatter dep tree (~4 KB) that an internal,
+  // unconditional coercion forced into every search-method program. Mirrors
+  // `stringSearchMethod` (startsWith/endsWith), which has always coerced here.
+  const searchArg = (search) => {
+    const vt = valTypeOf(search)
+    if (vt === VAL.STRING) return asI64(emit(search))
+    if (vt === VAL.BOOL) return asI64(bool(search))
+    if (vt === VAL.OBJECT) return toStrI64(search, emit(search))
+    inc('__to_str')
+    return ['call', '$__to_str', asI64(emit(search))]
+  }
+  // Replacement operand of .replace/.replaceAll — same call-site ToString as searchArg.
+  const strReplArg = searchArg
 
   bind('.string:indexOf', (str, search, from) => {
     inc('__str_indexof')
@@ -1573,9 +1597,14 @@ export default (ctx) => {
             asI64(tail)], 'f64')]]], 'f64')
     }
     inc('__str_replace')
-    return typed(['call', '$__str_replace', asI64(emit(str)), asI64(emit(search)), asI64(emit(repl))], 'f64')
+    // search/repl ToString'd at the call site (searchArg) — __str_replace's __str_indexof
+    // no longer coerces internally, so a non-string search must be stringified here.
+    return typed(['call', '$__str_replace', asI64(emit(str)), searchArg(search), strReplArg(repl)], 'f64')
+  })
+  bind('.replaceAll', (str, search, repl) => {
+    inc('__str_replaceall')
+    return typed(['call', '$__str_replaceall', asI64(emit(str)), searchArg(search), strReplArg(repl)], 'f64')
   })
-  bind('.replaceAll', method('__str_replaceall', 'III'))
 
   const caseMethod = (lo, hi, delta) => (str) => {
     inc('__str_case')

package/module/typedarray.js

@@ -12,7 +12,7 @@ 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, getter } from '../src/ctx.js'
+import { inc, PTR, LAYOUT, getter } from '../src/ctx.js'
 
 const _NAN_BITS = nanPrefixHex()
 
@@ -201,6 +201,11 @@ export default (ctx) => {
     __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'],
@@ -842,18 +847,21 @@ 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 = TYPED_ELEM_CODE[name]
     return et == null ? null : { et, isView, isBigInt: name === 'BigInt64Array' || name === 'BigUint64Array' }
@@ -863,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.
@@ -956,6 +974,219 @@ 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, i) => {
     const r = resolveElem(arr)
@@ -1257,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')
   }
@@ -1276,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')
   }
@@ -1328,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')
@@ -1460,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')
+  }
 }