jz 0.3.1 → 0.5.0

package/module/string.js

@@ -12,14 +12,30 @@
  * @module string
  */
 
-import { typed, asF64, asI32, asI64, NULL_NAN, UNDEF_NAN, mkPtrIR, temp, tempI32 } from '../src/ir.js'
-import { emit } from '../src/emit.js'
+import { typed, asF64, asI32, asI64, NULL_NAN, UNDEF_NAN, mkPtrIR, temp, tempI32, toNumF64, toStrI64 } from '../src/ir.js'
+import { emit, emitBoolStr } from '../src/emit.js'
 import { valTypeOf, VAL } from '../src/analyze.js'
-import { inc, PTR, LAYOUT } from '../src/ctx.js'
+import { inc, emitter, PTR, LAYOUT } from '../src/ctx.js'
 
 // SSO discriminator bit pre-shifted to its slot in the full i64 ptr (bit 46).
 // Used as `i64.and ptr SSO_BIT_I64` for branch-without-extracting-aux.
 const SSO_BIT_I64 = '0x' + (BigInt(LAYOUT.SSO_BIT) << BigInt(LAYOUT.AUX_SHIFT)).toString(16).toUpperCase().padStart(16, '0')
+// Slice/view discriminator bit, pre-shifted to bit 45 — same branch-without-aux trick.
+const SLICE_BIT_I64 = '0x' + (BigInt(LAYOUT.SLICE_BIT) << BigInt(LAYOUT.AUX_SHIFT)).toString(16).toUpperCase().padStart(16, '0')
+
+// WAT (no-locals expression): byte length of a heap STRING given its raw $-local
+// names for the offset and the i64 ptr. A view (SLICE_BIT) carries its length in
+// aux[12:0]; an own heap string reads the i32 header at off-4. Callers must have
+// already excluded SSO. Used inline by the hot char/eq helpers so a slice never
+// reads a bogus length out of a parent buffer's bytes.
+const heapLenExpr = (ptrLocal, offLocal) => `(if (result i32)
+  (i64.ne (i64.and (local.get ${ptrLocal}) (i64.const ${SLICE_BIT_I64})) (i64.const 0))
+  (then (i32.and
+    (i32.wrap_i64 (i64.shr_u (local.get ${ptrLocal}) (i64.const ${LAYOUT.AUX_SHIFT})))
+    (i32.const ${LAYOUT.SLICE_LEN_MASK})))
+  (else (if (result i32) (i32.ge_u (local.get ${offLocal}) (i32.const 4))
+    (then (i32.load (i32.sub (local.get ${offLocal}) (i32.const 4))))
+    (else (i32.const 0)))))`
 
 
 export default (ctx) => {
@@ -29,7 +45,8 @@ export default (ctx) => {
     __str_append_byte: ['__str_byteLen', '__alloc', '__mkptr', '__str_copy'],
     __str_copy: [],
     __str_slice: ['__str_byteLen', '__alloc'],
-    __str_indexof: ['__str_byteLen'],
+    __str_slice_view: ['__str_byteLen', '__mkptr', '__str_slice'],
+    __str_indexof: ['__str_byteLen', '__to_str'],
     __str_substring: ['__str_slice'],
     __str_startswith: ['__str_byteLen'],
     __str_endswith: ['__str_byteLen'],
@@ -42,11 +59,17 @@ export default (ctx) => {
     __str_replaceall: ['__str_indexof', '__str_slice', '__str_concat'],
     __str_split: ['__str_slice', '__str_byteLen', '__char_at', '__alloc'],
     __str_idx: [],
-    __str_eq: ['__char_at'],
+    __str_eq: ['__char_at', '__str_byteLen'],
     __str_cmp: ['__char_at', '__str_byteLen'],
+    __str_range_eq: ['__char_at', '__str_byteLen'],
+    __str_substring_eq: ['__str_byteLen', '__str_range_eq'],
+    __str_slice_eq: ['__str_byteLen', '__str_range_eq'],
     __str_pad: ['__str_byteLen', '__str_copy', '__alloc'],
     __str_join: ['__str_concat', '__to_str', '__str_byteLen', '__len', '__ptr_offset'],
     __str_encode: ['__str_byteLen', '__str_copy'],
+    __encodeURIComponent: ['__to_str', '__str_byteLen', '__char_at', '__alloc', '__mkptr'],
+    __decodeURIComponent: ['__to_str', '__str_byteLen', '__char_at', '__alloc', '__mkptr', '__uri_hex'],
+    __uri_hex: [],
     __to_str: ['__ftoa', '__static_str', '__str_join', '__mkptr'],
     __str_byteLen: ['__ptr_type', '__ptr_aux', '__str_len'],
   })
@@ -111,19 +134,63 @@ export default (ctx) => {
       (i32.wrap_i64 (i64.and (local.get $ptr) (i64.const ${LAYOUT.OFFSET_MASK})))
       (local.get $i))))`
 
-  // Hot (~37M calls in watr self-host). Caller guarantees $ptr is a STRING;
-  // SSO bit picks inline-byte-extract vs heap memory load.
+  // Hot (~37M calls in watr self-host, ~40k/scan in tokenizer bench). Caller
+  // guarantees $ptr is a STRING; SSO bit picks inline-byte-extract vs heap memory
+  // load. Returns 0 for OOB — internal tokenizer callers (number/json/regex
+  // parsers) rely on this sentinel to terminate `while (c > 32)`-shape loops
+  // past end-of-string. The SSO bounds check is essential: i32.shr_u wraps shift
+  // count mod 32, so without it `'a'.charCodeAt(4)` would return 'a' again
+  // (shift 32→0).
+  //
+  // Body written as a single nested-if expression with NO locals so watr's
+  // inliner picks it up (gate: no-locals + ≤4 params + body.length===1). After
+  // inlining into a hot loop, V8's LICM hoists the SSO-bit test, offset
+  // extraction and heap-length load out — the per-iteration cost collapses to a
+  // load+bounds-check, beating call-site overhead. Repeated `i32.wrap_i64 +
+  // i64.and OFFSET_MASK` subexpressions rely on CSE in the consumer; both
+  // V8/TurboFan and watr's own propagate pass handle this.
   ctx.core.stdlib['__char_at'] = `(func $__char_at (param $ptr i64) (param $i i32) (result i32)
-    (local $off i32)
-    (local.set $off (i32.wrap_i64 (i64.and (local.get $ptr) (i64.const ${LAYOUT.OFFSET_MASK}))))
     (if (result i32)
       (i64.ne (i64.and (local.get $ptr) (i64.const ${SSO_BIT_I64})) (i64.const 0))
       (then
-        (i32.and
-          (i32.shr_u (local.get $off) (i32.mul (local.get $i) (i32.const 8)))
-          (i32.const 0xFF)))
+        (if (result i32)
+          (i32.ge_u (local.get $i)
+            (i32.and
+              (i32.wrap_i64 (i64.shr_u (local.get $ptr) (i64.const ${LAYOUT.AUX_SHIFT})))
+              (i32.const ${LAYOUT.SSO_BIT - 1})))
+          (then (i32.const 0))
+          (else (i32.and
+            (i32.shr_u
+              (i32.wrap_i64 (i64.and (local.get $ptr) (i64.const ${LAYOUT.OFFSET_MASK})))
+              (i32.mul (local.get $i) (i32.const 8)))
+            (i32.const 0xFF)))))
       (else
-        (i32.load8_u (i32.add (local.get $off) (local.get $i))))))`
+        (if (result i32)
+          (i32.ge_u (local.get $i)
+            ;; non-SSO length: view → aux[12:0]; own heap string → header at off-4
+            ;; (off<4 sentinel guards the literal-data-segment edge). Both arms
+            ;; are loop-invariant — V8 LICM hoists the whole select.
+            (if (result i32)
+              (i64.ne (i64.and (local.get $ptr) (i64.const ${SLICE_BIT_I64})) (i64.const 0))
+              (then (i32.and
+                (i32.wrap_i64 (i64.shr_u (local.get $ptr) (i64.const ${LAYOUT.AUX_SHIFT})))
+                (i32.const ${LAYOUT.SLICE_LEN_MASK})))
+              (else
+                (if (result i32)
+                  (i32.lt_u
+                    (i32.wrap_i64 (i64.and (local.get $ptr) (i64.const ${LAYOUT.OFFSET_MASK})))
+                    (i32.const 4))
+                  (then (i32.const 0))
+                  (else (i32.load
+                    (i32.sub
+                      (i32.wrap_i64 (i64.and (local.get $ptr) (i64.const ${LAYOUT.OFFSET_MASK})))
+                      (i32.const 4))))))))
+          (then (i32.const 0))
+          (else
+            (i32.load8_u
+              (i32.add
+                (i32.wrap_i64 (i64.and (local.get $ptr) (i64.const ${LAYOUT.OFFSET_MASK})))
+                (local.get $i)))))))))`
 
   ctx.core.stdlib['__str_idx'] = `(func $__str_idx (param $ptr i64) (param $i i32) (result f64)
     (local $t i32) (local $off i32) (local $len i32) (local $isSso i32)
@@ -138,9 +205,15 @@ export default (ctx) => {
           (i32.wrap_i64 (i64.shr_u (local.get $ptr) (i64.const ${LAYOUT.AUX_SHIFT})))
           (i32.const ${LAYOUT.SSO_BIT - 1})))
         (else
-          (if (result i32) (i32.and (i32.eq (local.get $t) (i32.const ${PTR.STRING})) (i32.ge_u (local.get $off) (i32.const 4)))
-            (then (i32.load (i32.sub (local.get $off) (i32.const 4))))
-            (else (i32.const 0))))))
+          (if (result i32)
+            (i64.ne (i64.and (local.get $ptr) (i64.const ${SLICE_BIT_I64})) (i64.const 0))
+            (then (i32.and
+              (i32.wrap_i64 (i64.shr_u (local.get $ptr) (i64.const ${LAYOUT.AUX_SHIFT})))
+              (i32.const ${LAYOUT.SLICE_LEN_MASK})))
+            (else
+              (if (result i32) (i32.and (i32.eq (local.get $t) (i32.const ${PTR.STRING})) (i32.ge_u (local.get $off) (i32.const 4)))
+                (then (i32.load (i32.sub (local.get $off) (i32.const 4))))
+                (else (i32.const 0))))))))
     (if (result f64)
       (i32.or (i32.lt_s (local.get $i) (i32.const 0)) (i32.ge_u (local.get $i) (local.get $len)))
       (then (f64.const nan:${UNDEF_NAN}))
@@ -188,8 +261,8 @@ export default (ctx) => {
       (then
         (if (i32.or (i32.lt_u (local.get $offA) (i32.const 4)) (i32.lt_u (local.get $offB) (i32.const 4)))
           (then (return (i32.const 0))))
-        (local.set $len (i32.load (i32.sub (local.get $offA) (i32.const 4))))
-        (local.set $lenB (i32.load (i32.sub (local.get $offB) (i32.const 4))))
+        (local.set $len ${heapLenExpr('$a', '$offA')})
+        (local.set $lenB ${heapLenExpr('$b', '$offB')})
         (if (i32.ne (local.get $len) (local.get $lenB))
           (then (return (i32.const 0))))
         (local.set $lenB (i32.and (local.get $len) (i32.const -4)))
@@ -211,20 +284,9 @@ export default (ctx) => {
           (br $lh)))
         (return (i32.const 1))))
     ;; Mixed (SSO×heap) or anything else: compute len per side then per-byte via __char_at.
-    (if (local.get $ssoA)
-      (then (local.set $len (i32.and
-        (i32.wrap_i64 (i64.shr_u (local.get $a) (i64.const ${LAYOUT.AUX_SHIFT})))
-        (i32.const ${LAYOUT.SSO_BIT - 1}))))
-      (else
-        (if (i32.and (i32.eq (local.get $ta) (i32.const ${PTR.STRING})) (i32.ge_u (local.get $offA) (i32.const 4)))
-          (then (local.set $len (i32.load (i32.sub (local.get $offA) (i32.const 4))))))))
-    (if (local.get $ssoB)
-      (then (local.set $lenB (i32.and
-        (i32.wrap_i64 (i64.shr_u (local.get $b) (i64.const ${LAYOUT.AUX_SHIFT})))
-        (i32.const ${LAYOUT.SSO_BIT - 1}))))
-      (else
-        (if (i32.and (i32.eq (local.get $tb) (i32.const ${PTR.STRING})) (i32.ge_u (local.get $offB) (i32.const 4)))
-          (then (local.set $lenB (i32.load (i32.sub (local.get $offB) (i32.const 4))))))))
+    ;; __str_byteLen handles SSO, slice (SLICE_BIT) and own-heap encodings uniformly.
+    (local.set $len (call $__str_byteLen (local.get $a)))
+    (local.set $lenB (call $__str_byteLen (local.get $b)))
     (if (i32.ne (local.get $len) (local.get $lenB))
       (then (return (i32.const 0))))
     (block $dm (loop $lm
@@ -279,10 +341,14 @@ export default (ctx) => {
         (if (result i32) (i32.and (local.get $aux) (i32.const ${LAYOUT.SSO_BIT}))
           (then (i32.and (local.get $aux) (i32.const ${LAYOUT.SSO_BIT - 1})))
           (else
-            (local.set $off (i32.wrap_i64 (i64.and (local.get $ptr) (i64.const ${LAYOUT.OFFSET_MASK}))))
-            (if (result i32) (i32.ge_u (local.get $off) (i32.const 4))
-              (then (i32.load (i32.sub (local.get $off) (i32.const 4))))
-              (else (i32.const 0))))))
+            (if (result i32) (i32.and (local.get $aux) (i32.const ${LAYOUT.SLICE_BIT}))
+              ;; view: length lives in aux[12:0], not a header.
+              (then (i32.and (local.get $aux) (i32.const ${LAYOUT.SLICE_LEN_MASK})))
+              (else
+                (local.set $off (i32.wrap_i64 (i64.and (local.get $ptr) (i64.const ${LAYOUT.OFFSET_MASK}))))
+                (if (result i32) (i32.ge_u (local.get $off) (i32.const 4))
+                  (then (i32.load (i32.sub (local.get $off) (i32.const 4))))
+                  (else (i32.const 0))))))))
       (else (i32.const 0))))`
 
   // === WAT: string methods ===
@@ -329,6 +395,48 @@ export default (ctx) => {
         (memory.copy (local.get $off) (i32.add (local.get $srcOff) (local.get $start)) (local.get $nlen))))
     (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $off)))`
 
+  // No-copy slice: returns a VIEW into the receiver's buffer instead of copying
+  // bytes. Only emitted when escape analysis proves the result never outlives the
+  // parent (a non-escaping local). A view is a heap STRING with SLICE_BIT set and
+  // its length in aux[12:0]; the offset points straight into the parent's bytes,
+  // so it stays valid as long as the parent does. Falls back to a real copy
+  // (__str_slice) when the parent is SSO (no buffer to point into) or the result
+  // is longer than SLICE_LEN_MASK (aux can't hold the length). Clamping mirrors
+  // __str_slice; the fallback re-clamps idempotently.
+  ctx.core.stdlib['__str_slice_view'] = `(func $__str_slice_view (param $ptr i64) (param $start i32) (param $end i32) (result f64)
+    (local $len i32) (local $nlen i32) (local $srcOff i32) (local $tag i32)
+    (local.set $len (call $__str_byteLen (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 $end) (i32.const 0))
+      (then (local.set $end (i32.add (local.get $len) (local.get $end)))))
+    (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.const 0))))
+    (if (i32.gt_s (local.get $end) (local.get $len))
+      (then (local.set $end (local.get $len))))
+    (if (i32.ge_s (local.get $start) (local.get $end))
+      (then (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${LAYOUT.SSO_BIT}) (i32.const 0)))))
+    (local.set $nlen (i32.sub (local.get $end) (local.get $start)))
+    (local.set $tag (i32.wrap_i64 (i64.and (i64.shr_u (local.get $ptr) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK}))))
+    ;; View-eligible: STRING parent, not SSO, length fits aux[12:0].
+    (if (i32.and
+          (i32.and
+            (i32.eq (local.get $tag) (i32.const ${PTR.STRING}))
+            (i64.eqz (i64.and (local.get $ptr) (i64.const ${SSO_BIT_I64}))))
+          (i32.le_u (local.get $nlen) (i32.const ${LAYOUT.SLICE_LEN_MASK})))
+      (then
+        (local.set $srcOff (i32.wrap_i64 (i64.and (local.get $ptr) (i64.const ${LAYOUT.OFFSET_MASK}))))
+        (return (call $__mkptr
+          (i32.const ${PTR.STRING})
+          (i32.or (i32.const ${LAYOUT.SLICE_BIT}) (local.get $nlen))
+          (i32.add (local.get $srcOff) (local.get $start))))))
+    ;; Fallback: copy (SSO parent, or slice too long for the aux length field).
+    (call $__str_slice (local.get $ptr) (local.get $start) (local.get $end)))`
+
   ctx.core.stdlib['__str_substring'] = `(func $__str_substring (param $ptr i64) (param $start i32) (param $end i32) (result f64)
     (local $len i32) (local $tmp i32)
     (local.set $len (call $__str_byteLen (local.get $ptr)))
@@ -347,12 +455,91 @@ export default (ctx) => {
         (local.set $end (local.get $tmp))))
     (call $__str_slice (local.get $ptr) (local.get $start) (local.get $end)))`
 
+  // === WAT: fused substring-equality ===
+  //
+  // `<str>.{substr,substring,slice}(...) === <other>` consumed only by the
+  // equality materialises a transient substring (an __alloc + byte copy) just
+  // to feed __eq. emit.js's emitSubstringEqCmp peepholes that pair to these
+  // helpers, which clamp the range exactly like __str_substring / __str_slice
+  // then byte-compare it against `other` in place — zero allocation. Motivating
+  // hot path: the parser keyword scan, `cur.substr(i,l) === keyword`.
+  //
+  // __str_range_eq assumes the receiver is a STRING (every substring method
+  // returns one) and type-checks only `other`, mirroring __eq's STRING-vs-?
+  // arm: a genuine number never equals a string, and a NaN-boxed non-STRING
+  // never does either (jz `==` is strict).
+  ctx.core.stdlib['__str_range_eq'] = `(func $__str_range_eq (param $ptr i64) (param $start i32) (param $end i32) (param $other i64) (result i32)
+    (local $n i32) (local $i i32) (local $fb f64)
+    ;; A genuine number reinterprets to a non-NaN f64 (equals itself) — never a string.
+    (local.set $fb (f64.reinterpret_i64 (local.get $other)))
+    (if (f64.eq (local.get $fb) (local.get $fb))
+      (then (return (i32.const 0))))
+    ;; NaN-boxed but not STRING-tagged ⇒ not a string ⇒ not equal.
+    (if (i32.ne
+          (i32.wrap_i64 (i64.and (i64.shr_u (local.get $other) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK})))
+          (i32.const ${PTR.STRING}))
+      (then (return (i32.const 0))))
+    (local.set $n (i32.sub (local.get $end) (local.get $start)))
+    (if (i32.lt_s (local.get $n) (i32.const 0))
+      (then (local.set $n (i32.const 0))))
+    (if (i32.ne (local.get $n) (call $__str_byteLen (local.get $other)))
+      (then (return (i32.const 0))))
+    (block $done (loop $next
+      (br_if $done (i32.ge_s (local.get $i) (local.get $n)))
+      (if (i32.ne
+            (call $__char_at (local.get $ptr) (i32.add (local.get $start) (local.get $i)))
+            (call $__char_at (local.get $other) (local.get $i)))
+        (then (return (i32.const 0))))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (br $next)))
+    (i32.const 1))`
+
+  // Clamp mirrors __str_substring (negatives floor to 0, swap when start>end).
+  ctx.core.stdlib['__str_substring_eq'] = `(func $__str_substring_eq (param $ptr i64) (param $start i32) (param $end i32) (param $other i64) (result i32)
+    (local $len i32) (local $tmp i32)
+    (local.set $len (call $__str_byteLen (local.get $ptr)))
+    (if (i32.lt_s (local.get $start) (i32.const 0))
+      (then (local.set $start (i32.const 0))))
+    (if (i32.lt_s (local.get $end) (i32.const 0))
+      (then (local.set $end (i32.const 0))))
+    (if (i32.gt_s (local.get $start) (local.get $len))
+      (then (local.set $start (local.get $len))))
+    (if (i32.gt_s (local.get $end) (local.get $len))
+      (then (local.set $end (local.get $len))))
+    (if (i32.gt_s (local.get $start) (local.get $end))
+      (then
+        (local.set $tmp (local.get $start))
+        (local.set $start (local.get $end))
+        (local.set $end (local.get $tmp))))
+    (call $__str_range_eq (local.get $ptr) (local.get $start) (local.get $end) (local.get $other)))`
+
+  // Clamp mirrors __str_slice (negatives count from the end; __str_range_eq
+  // floors a negative span to an empty match).
+  ctx.core.stdlib['__str_slice_eq'] = `(func $__str_slice_eq (param $ptr i64) (param $start i32) (param $end i32) (param $other i64) (result i32)
+    (local $len i32)
+    (local.set $len (call $__str_byteLen (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 $end) (i32.const 0))
+      (then (local.set $end (i32.add (local.get $len) (local.get $end)))))
+    (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.const 0))))
+    (if (i32.gt_s (local.get $end) (local.get $len))
+      (then (local.set $end (local.get $len))))
+    (call $__str_range_eq (local.get $ptr) (local.get $start) (local.get $end) (local.get $other)))`
+
   // Hoist SSO/heap dispatch for hay and ndl out of the inner byte loop. Inner
   // loop becomes (load8_u OR sso byte-extract) per side — no per-byte calls.
   ctx.core.stdlib['__str_indexof'] = `(func $__str_indexof (param $hay i64) (param $ndl i64) (param $from i32) (result i32)
     (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)))
     (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))))
@@ -598,15 +785,41 @@ export default (ctx) => {
   // length too, so this departs from strict JS string immutability for the rare
   // `let b = a; a += x` aliasing case. The fast path can't trigger when other
   // allocations have happened since `a` was created (it's no longer at heap top).
-  // Only emitted for own-memory mode; shared memory falls back to slow path.
-  const concatFast = !ctx.memory.shared ? `
+  // Only emitted for own-memory mode with a $__heap global; shared memory and
+  // alloc:false (which routes the heap pointer through memory[1020]) fall back.
+  // SSO-result fast path: both operands SSO and total ≤ 4 → repack inline,
+  // no alloc, no copy. Combined offset field = a's bytes | (b's bytes shifted
+  // by alen*8). New aux = SSO_BIT | total. Mode-independent (pointer arith
+  // only, no heap); fires whenever the upstream `'+'` couldn't fold at
+  // compile time (one or both operands runtime values). Critical for the
+  // identifier-style `'$' + x` / `prefix + s` patterns hot in parsers.
+  const ssoResultFast = `
+    (if (i32.and
+          (i32.and
+            (i64.ne (i64.and (local.get $a) (i64.const ${SSO_BIT_I64})) (i64.const 0))
+            (i64.ne (i64.and (local.get $b) (i64.const ${SSO_BIT_I64})) (i64.const 0)))
+          (i32.le_u (local.get $total) (i32.const 4)))
+      (then
+        (return (call $__mkptr
+          (i32.const ${PTR.STRING})
+          (i32.or (i32.const ${LAYOUT.SSO_BIT}) (local.get $total))
+          (i32.or
+            (i32.wrap_i64 (i64.and (local.get $a) (i64.const 0xFFFFFFFF)))
+            (i32.shl
+              (i32.wrap_i64 (i64.and (local.get $b) (i64.const 0xFFFFFFFF)))
+              (i32.shl (local.get $alen) (i32.const 3))))))))`
+
+  const concatFast = !ctx.memory.shared && ctx.transform.alloc !== false ? `
     (local.set $ta (i32.wrap_i64 (i64.and (i64.shr_u (local.get $a) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK}))))
     (local.set $aoff (i32.wrap_i64 (i64.and (local.get $a) (i64.const ${LAYOUT.OFFSET_MASK}))))
-    ;; Bump-extend requires heap STRING (not SSO — its offset holds packed bytes).
+    ;; Bump-extend requires an OWN heap STRING — not SSO (offset holds packed bytes)
+    ;; and not a slice/view (bumping would corrupt the parent buffer it points into).
     (if (i32.and
           (i32.and
             (i32.eq (local.get $ta) (i32.const ${PTR.STRING}))
-            (i64.eqz (i64.and (local.get $a) (i64.const ${SSO_BIT_I64}))))
+            (i32.and
+              (i64.eqz (i64.and (local.get $a) (i64.const ${SSO_BIT_I64})))
+              (i64.eqz (i64.and (local.get $a) (i64.const ${SLICE_BIT_I64})))))
           (i32.eq
             (i32.and (i32.add (i32.add (local.get $aoff) (local.get $alen)) (i32.const 7)) (i32.const -8))
             (global.get $__heap)))
@@ -633,12 +846,15 @@ export default (ctx) => {
     (local $newHeap i32) (local $off i32) (local $total i32)
     (local.set $ta (i32.wrap_i64 (i64.and (i64.shr_u (local.get $a) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK}))))
     (local.set $aoff (i32.wrap_i64 (i64.and (local.get $a) (i64.const ${LAYOUT.OFFSET_MASK}))))
-    ;; Heap STRING at heap top: bump-extend by 1 byte (own-memory mode only).
-    ;; Gate on STRING tag AND !SSO_BIT — for SSO, $aoff holds packed bytes (not a heap addr).
-    ${!ctx.memory.shared ? `
+    ;; Heap STRING at heap top: bump-extend by 1 byte (own-memory mode w/ $__heap global only).
+    ;; Gate on STRING tag AND !SSO_BIT ($aoff would hold packed bytes) AND !SLICE_BIT
+    ;; (a view's $aoff points into a parent buffer — bumping it would corrupt the parent).
+    ${!ctx.memory.shared && ctx.transform.alloc !== false ? `
     (if (i32.and
           (i32.eq (local.get $ta) (i32.const ${PTR.STRING}))
-          (i64.eqz (i64.and (local.get $a) (i64.const ${SSO_BIT_I64}))))
+          (i32.and
+            (i64.eqz (i64.and (local.get $a) (i64.const ${SSO_BIT_I64})))
+            (i64.eqz (i64.and (local.get $a) (i64.const ${SLICE_BIT_I64})))))
       (then
         (local.set $alen (i32.load (i32.sub (local.get $aoff) (i32.const 4))))
         (if (i32.eq
@@ -696,6 +912,7 @@ export default (ctx) => {
     (local.set $total (i32.add (local.get $alen) (local.get $blen)))
     (if (i32.eqz (local.get $total))
       (then (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${LAYOUT.SSO_BIT}) (i32.const 0)))))
+    ${ssoResultFast}
     ${concatFast}
     (local.set $off (call $__alloc (i32.add (i32.const 4) (local.get $total))))
     (i32.store (local.get $off) (local.get $total))
@@ -712,6 +929,7 @@ export default (ctx) => {
     (local.set $total (i32.add (local.get $alen) (local.get $blen)))
     (if (i32.eqz (local.get $total))
       (then (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${LAYOUT.SSO_BIT}) (i32.const 0)))))
+    ${ssoResultFast}
     ${concatFast}
     (local.set $off (call $__alloc (i32.add (i32.const 4) (local.get $total))))
     (i32.store (local.get $off) (local.get $total))
@@ -752,12 +970,27 @@ export default (ctx) => {
       (br $next)))
     (f64.reinterpret_i64 (local.get $result)))`
 
+  // Empty separator: per JS spec, split into individual byte-chars
+  // ("abc".split("") -> ["a","b","c"], "".split("") -> []). Without this
+  // guard the main loop advances by plen=0 and spins forever.
   ctx.core.stdlib['__str_split'] = `(func $__str_split (param $str i64) (param $sep i64) (result f64)
     (local $slen i32) (local $plen i32) (local $count i32)
     (local $i i32) (local $j i32) (local $match i32)
     (local $arr i32) (local $piece_start i32) (local $piece_idx i32)
     (local.set $slen (call $__str_byteLen (local.get $str)))
     (local.set $plen (call $__str_byteLen (local.get $sep)))
+    (if (i32.eqz (local.get $plen)) (then
+      (local.set $arr (call $__alloc (i32.add (i32.const 8) (i32.shl (local.get $slen) (i32.const 3)))))
+      (i32.store (local.get $arr) (local.get $slen))
+      (i32.store (i32.add (local.get $arr) (i32.const 4)) (local.get $slen))
+      (local.set $arr (i32.add (local.get $arr) (i32.const 8)))
+      (block $de (loop $le
+        (br_if $de (i32.ge_s (local.get $i) (local.get $slen)))
+        (f64.store (i32.add (local.get $arr) (i32.shl (local.get $i) (i32.const 3)))
+          (call $__str_slice (local.get $str) (local.get $i) (i32.add (local.get $i) (i32.const 1))))
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (br $le)))
+      (return (call $__mkptr (i32.const 1) (i32.const 0) (local.get $arr)))))
     (local.set $count (i32.const 1))
     (local.set $i (i32.const 0))
     (block $d1 (loop $l1
@@ -881,26 +1114,64 @@ export default (ctx) => {
   // override to return the primitive — strings already covered by .string:valueOf.
   ctx.core.emit['.valueOf'] = (val) => asF64(emit(val))
 
-  ctx.core.emit['.string:slice'] = (str, start, end) => {
-    inc('__str_slice')
+  // `.slice` lowering, parametrised on the backing helper: __str_slice copies
+  // bytes; __str_slice_view returns a no-copy SLICE_BIT view — used only when
+  // escape analysis proved the result never outlives its parent buffer (see
+  // scanSliceViews / emitDecl). The `#view` key cannot be produced by method
+  // dispatch (`#` is not a legal identifier char), so the view variant is
+  // reachable only through the explicit emitDecl route.
+  const sliceEmitter = (fn) => (str, start, end) => {
+    inc(fn)
     const startIR = start == null ? ['i32.const', 0] : asI32(emit(start))
-    if (end != null) return typed(['call', '$__str_slice', asI64(emit(str)), startIR, asI32(emit(end))], 'f64')
+    if (end != null) return typed(['call', `$${fn}`, asI64(emit(str)), startIR, asI32(emit(end))], 'f64')
     const t = temp('t')
     return typed(['block', ['result', 'f64'],
       ['local.set', `$${t}`, asF64(emit(str))],
-      ['call', '$__str_slice', ['i64.reinterpret_f64', ['local.get', `$${t}`]], startIR,
+      ['call', `$${fn}`, ['i64.reinterpret_f64', ['local.get', `$${t}`]], startIR,
         ['call', '$__str_byteLen', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]]], 'f64')
   }
+  ctx.core.emit['.string:slice'] = sliceEmitter('__str_slice')
+  ctx.core.emit['.string:slice#view'] = sliceEmitter('__str_slice_view')
+
+  // ToIntegerOrInfinity for a string-method position argument: ToNumber (so
+  // string / boolean / null / undefined positions coerce per spec) then trunc.
+  // trunc_sat maps NaN→0 and ±∞→±maxint — both clamp correctly downstream.
+  // `toNumF64` routes an object position through `valueOf`/`toString`
+  // (ToPrimitive), so a throwing method propagates as an abrupt completion.
+  const posIndex = (node) => {
+    if (node == null) return ['i32.const', 0]
+    return asI32(toNumF64(node, emit(node)))
+  }
+
+  // ToString(searchString) per spec step 3. __str_indexof's internal __to_str
+  // 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(emitBoolStr(search)) :
+    valTypeOf(search) === VAL.OBJECT ? toStrI64(search, emit(search)) : asI64(emit(search))
 
   ctx.core.emit['.string:indexOf'] = (str, search, from) => {
     inc('__str_indexof')
-    return typed(['f64.convert_i32_s', ['call', '$__str_indexof', asI64(emit(str)), asI64(emit(search)), from ? asI32(emit(from)) : ['i32.const', 0]]], 'f64')
+    const hay = asI64(emit(str)), ndl = searchArg(search)
+    return typed(['f64.convert_i32_s', ['call', '$__str_indexof', hay, ndl, posIndex(from)]], 'f64')
   }
 
-  ctx.core.emit['.string:includes'] = (str, search) => {
+  // String.prototype.{includes,startsWith,endsWith} run IsRegExp(searchString)
+  // and throw a TypeError when it is a RegExp. Detect a regex-typed search arg
+  // at compile time and lower to a $__jz_err throw.
+  const regexpSearchGuard = (search) => {
+    if (valTypeOf(search) !== VAL.REGEX) return null
+    ctx.runtime.throws = true
+    return typed(['block', ['result', 'f64'], ['throw', '$__jz_err', ['f64.const', 0]]], 'f64')
+  }
+
+  ctx.core.emit['.string:includes'] = (str, search, from) => {
+    const guard = regexpSearchGuard(search); if (guard) return guard
     inc('__str_indexof')
+    const hay = asI64(emit(str)), ndl = searchArg(search)
     return typed(['f64.convert_i32_s',
-      ['i32.ge_s', ['call', '$__str_indexof', asI64(emit(str)), asI64(emit(search)), ['i32.const', 0]], ['i32.const', 0]]], 'f64')
+      ['i32.ge_s', ['call', '$__str_indexof', hay, ndl, posIndex(from)], ['i32.const', 0]]], 'f64')
   }
 
   // Generic (no collision)
@@ -914,20 +1185,47 @@ export default (ctx) => {
         ['call', '$__str_byteLen', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]]], 'f64')
   }
 
-  // Factory for simple str→call patterns: [emitKey, stdlibName, argCoercions, i32Result?]
-  const coerce = { f: asF64, i: asI32 }
-  const strMethod = (name, args, i32Result) => (str, ...params) => {
-    inc(name)
-    const call = ['call', `$${name}`, asF64(emit(str)), ...params.map((p, i) => coerce[args[i]](emit(p)))]
-    return typed(i32Result ? ['f64.convert_i32_s', call] : call, 'f64')
+  // .substr(start, length) — Annex B / legacy. Equivalent to substring(start, start+length).
+  // __str_substring clamps end to byteLen and start/end to [0, byteLen], so negative
+  // values are floored to 0 (matches v8 for length<0 → empty; for start<0 spec wants
+  // max(0, len+start), which we don't implement — rare in practice).
+  ctx.core.emit['.substr'] = (str, start, length) => {
+    inc('__str_substring')
+    if (length != null) {
+      const s = tempI32('substrS')
+      return typed(['block', ['result', 'f64'],
+        ['local.set', `$${s}`, asI32(emit(start))],
+        ['call', '$__str_substring', asI64(emit(str)),
+          ['local.get', `$${s}`],
+          ['i32.add', ['local.get', `$${s}`], asI32(emit(length))]]
+      ], 'f64')
+    }
+    const t = temp('t')
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${t}`, asF64(emit(str))],
+      ['call', '$__str_substring', ['i64.reinterpret_f64', ['local.get', `$${t}`]], asI32(emit(start)),
+        ['call', '$__str_byteLen', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]]], 'f64')
   }
 
+  // Declarative emitter for regular `(recv, ...args) → call($stdlib, coerced...)` methods.
+  // `coerce` is a per-argument code string ('I' i64 · 'F' f64 · 'i' i32); index 0 is the receiver.
+  // `ret` is the helper's result type — 'f64' is returned directly, 'i32' is widened to the f64 ABI.
+  const CO = { I: asI64, F: asF64, i: asI32 }
+  const method = (stdlib, coerce, ret = 'f64') => emitter([stdlib], (...nodes) => {
+    const c = ['call', `$${stdlib}`, ...nodes.map((n, i) => CO[coerce[i]](emit(n)))]
+    return typed(ret === 'i32' ? ['f64.convert_i32_s', c] : c, 'f64')
+  })
+
   // Search args go through ToString per spec — coerce non-string-typed args
   // via __to_str so the underlying byte-compare receives an actual string.
   const stringSearchMethod = (name) => (str, sfx) => {
+    const guard = regexpSearchGuard(sfx); if (guard) return guard
     inc(name)
-    let sfxArg = asI64(emit(sfx))
-    if (valTypeOf(sfx) !== VAL.STRING) {
+    const esfx = emit(sfx)
+    let sfxArg = asI64(esfx)
+    if (valTypeOf(sfx) === VAL.OBJECT) {
+      sfxArg = toStrI64(sfx, esfx)
+    } else if (valTypeOf(sfx) !== VAL.STRING) {
       inc('__to_str')
       sfxArg = ['call', '$__to_str', sfxArg]
     }
@@ -935,20 +1233,13 @@ export default (ctx) => {
   }
   ctx.core.emit['.startsWith'] = stringSearchMethod('__str_startswith')
   ctx.core.emit['.endsWith'] = stringSearchMethod('__str_endswith')
-  ctx.core.emit['.trim'] = (str) => (inc('__str_trim'),
-    typed(['call', '$__str_trim', asI64(emit(str))], 'f64'))
-  ctx.core.emit['.trimStart'] = (str) => (inc('__str_trimStart'),
-    typed(['call', '$__str_trimStart', asI64(emit(str))], 'f64'))
-  ctx.core.emit['.trimEnd'] = (str) => (inc('__str_trimEnd'),
-    typed(['call', '$__str_trimEnd', asI64(emit(str))], 'f64'))
-  ctx.core.emit['.repeat'] = (str, n) => (inc('__str_repeat'),
-    typed(['call', '$__str_repeat', asI64(emit(str)), asI32(emit(n))], 'f64'))
-  ctx.core.emit['.split'] = (str, sep) => (inc('__str_split'),
-    typed(['call', '$__str_split', asI64(emit(str)), asI64(emit(sep))], 'f64'))
-  ctx.core.emit['.replace'] = (str, search, repl) => (inc('__str_replace'),
-    typed(['call', '$__str_replace', asI64(emit(str)), asI64(emit(search)), asI64(emit(repl))], 'f64'))
-  ctx.core.emit['.replaceAll'] = (str, search, repl) => (inc('__str_replaceall'),
-    typed(['call', '$__str_replaceall', asI64(emit(str)), asI64(emit(search)), asI64(emit(repl))], 'f64'))
+  ctx.core.emit['.trim']       = method('__str_trim',       'I')
+  ctx.core.emit['.trimStart']  = method('__str_trimStart',  'I')
+  ctx.core.emit['.trimEnd']    = method('__str_trimEnd',    'I')
+  ctx.core.emit['.repeat']     = method('__str_repeat',     'Ii')
+  ctx.core.emit['.split']      = method('__str_split',      'II')
+  ctx.core.emit['.replace']    = method('__str_replace',    'III')
+  ctx.core.emit['.replaceAll'] = method('__str_replaceall', 'III')
 
   ctx.core.emit['.toUpperCase'] = (str) => {
     inc('__str_case')
@@ -972,10 +1263,7 @@ export default (ctx) => {
   // the spec exactly; for non-ASCII it follows UTF-8 byte order, which is
   // codepoint order for well-formed strings — close enough for sort-stability
   // use cases, wrong for human-language collation.
-  ctx.core.emit['.localeCompare'] = (str, other) => {
-    inc('__str_cmp')
-    return typed(['f64.convert_i32_s', ['call', '$__str_cmp', asI64(emit(str)), asI64(emit(other))]], 'f64')
-  }
+  ctx.core.emit['.localeCompare'] = method('__str_cmp', 'II', 'i32')
 
   ctx.core.emit['.string:concat'] = (str, ...others) => {
     inc('__str_concat')
@@ -984,10 +1272,15 @@ export default (ctx) => {
     return result
   }
 
+  // A VAL.BOOL part rides the 0/1 carrier, so __to_str would render "1"/"0".
+  // emitBoolStr selects the interned "true"/"false" literal (constant-folded
+  // when the operand is known); every other part goes through __to_str.
+  const partStrI64 = (p) => valTypeOf(p) === VAL.BOOL ? asI64(emitBoolStr(p)) : toStrI64(p, emit(p))
+
   ctx.core.emit['strcat'] = (...parts) => {
     inc('__to_str', '__str_byteLen', '__alloc', '__mkptr', '__str_copy')
     if (!parts.length) return mkPtrIR(PTR.STRING, LAYOUT.SSO_BIT, 0)
-    if (parts.length === 1) return typed(['f64.reinterpret_i64', ['call', '$__to_str', asI64(emit(parts[0]))]], 'f64')
+    if (parts.length === 1) return typed(['f64.reinterpret_i64', partStrI64(parts[0])], 'f64')
 
     const vals = parts.map(() => temp('s'))
     const lens = parts.map(() => tempI32('sl'))
@@ -997,7 +1290,7 @@ export default (ctx) => {
     const ir = []
 
     for (let i = 0; i < parts.length; i++) {
-      ir.push(['local.set', `$${vals[i]}`, ['f64.reinterpret_i64', ['call', '$__to_str', asI64(emit(parts[i]))]]])
+      ir.push(['local.set', `$${vals[i]}`, ['f64.reinterpret_i64', partStrI64(parts[i])]])
       ir.push(['local.set', `$${lens[i]}`, ['call', '$__str_byteLen', ['i64.reinterpret_f64', ['local.get', `$${vals[i]}`]]]])
     }
     ir.push(['local.set', `$${total}`, ['i32.const', 0]])
@@ -1042,35 +1335,47 @@ export default (ctx) => {
       mkPtrIR(PTR.STRING, LAYOUT.SSO_BIT | 1, ['local.get', `$${t}`])], 'f64')
   }
 
-  // .charCodeAt(i) → integer char code (0..255 for ASCII bytes — unsigned, always
-  // representable as i32). Returning i32 directly lets `let c = s.charCodeAt(i)`
-  // stay on the i32 ABI: chained comparisons (`c >= 48 && c <= 57`), bit-ops, and
-  // `c - 48` arithmetic skip the per-iteration f64 widen + i32 trunc round-trip.
-  ctx.core.emit['.charCodeAt'] = (str, idx) => {
-    inc('__char_at')
-    return typed(['call', '$__char_at', asI64(emit(str)), asI32(emit(idx))], 'i32')
-  }
+  // .charCodeAt(i) → JS-spec char code: the UTF-16 code unit at `i`, or NaN
+  // when `i` is out of range (`i < 0 || i >= length`). Result is f64 because
+  // NaN is not representable as i32 — an i32 `0` sentinel for OOB silently
+  // miscompiles any reader that distinguishes 0 from NaN, e.g. the parser hot
+  // loop `while ((cc = s.charCodeAt(i++)) <= 32) {}` would never terminate
+  // (`0 <= 32` is true, `NaN <= 32` is false). The narrower may re-narrow the
+  // result to i32 where it can prove the index in-bounds.
+  ctx.core.emit['.charCodeAt'] = (str, idx) =>
+    typed(ctx.abi.string.ops.charCodeAt(asF64(emit(str)), asI32(emit(idx)), ctx, true), 'f64')
 
   // String.fromCharCode(code) → 1-char SSO string
   ctx.core.emit['String'] = (value) => {
     if (value === undefined) return emit(['str', ''])
     if (valTypeOf(value) === VAL.STRING) return emit(value)
+    if (valTypeOf(value) === VAL.BOOL) return emitBoolStr(value)
     if (valTypeOf(value) === VAL.NUMBER) {
       inc('__ftoa')
       return typed(['call', '$__ftoa', asF64(emit(value)), ['i32.const', 0], ['i32.const', 0]], 'f64')
     }
-    inc('__to_str')
-    return typed(['f64.reinterpret_i64', ['call', '$__to_str', asI64(emit(value))]], 'f64')
+    return typed(['f64.reinterpret_i64', toStrI64(value, emit(value))], 'f64')
   }
 
   ctx.core.emit['String.fromCharCode'] = (code) => {
     if (code === undefined) return emit(['str', ''])
-    return mkPtrIR(PTR.STRING, LAYOUT.SSO_BIT | 1, asI32(emit(code)))
+    // ToUint16(ToNumber(code)): `toNumF64` performs ToPrimitive on an object
+    // argument, so a throwing valueOf/toString propagates per spec.
+    return mkPtrIR(PTR.STRING, LAYOUT.SSO_BIT | 1, asI32(toNumF64(code, emit(code))))
   }
 
-  // String.fromCodePoint(cp) → UTF-8 encoded string
-  ctx.core.stdlib['__fromCodePoint'] = `(func $__fromCodePoint (param $cp i32) (result f64)
-    (local $off i32) (local $len i32)
+  // String.fromCodePoint(cp) → UTF-8 encoded string for one code point.
+  // Param is f64 (already ToNumber-coerced); throws RangeError ($__jz_err) when
+  // the value is not an integer in [0, 0x10FFFF] (22.1.2.2 step 5.d).
+  ctx.core.stdlib['__fromCodePoint'] = `(func $__fromCodePoint (param $cpf f64) (result f64)
+    (local $cp i32) (local $off i32) (local $len i32)
+    (if (i32.or
+          (i32.or
+            (f64.ne (f64.trunc (local.get $cpf)) (local.get $cpf))
+            (f64.lt (local.get $cpf) (f64.const 0)))
+          (f64.gt (local.get $cpf) (f64.const 0x10FFFF)))
+      (then (throw $__jz_err (f64.const 0))))
+    (local.set $cp (i32.trunc_sat_f64_s (local.get $cpf)))
     ;; ASCII: 1 byte SSO
     (if (i32.lt_u (local.get $cp) (i32.const 128))
       (then (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${LAYOUT.SSO_BIT | 1}) (local.get $cp)))))
@@ -1095,10 +1400,164 @@ export default (ctx) => {
         (i32.shl (i32.or (i32.const 0x80) (i32.and (i32.shr_u (local.get $cp) (i32.const 6)) (i32.const 0x3F))) (i32.const 16)))
         (i32.shl (i32.or (i32.const 0x80) (i32.and (local.get $cp) (i32.const 0x3F))) (i32.const 24))))))`
 
-  ctx.core.emit['String.fromCodePoint'] = (code) => {
-    if (code === undefined) return emit(['str', ''])
+  // String.fromCodePoint(...codePoints) — variadic; each arg is ToNumber-coerced
+  // then validated/encoded by __fromCodePoint, results concatenated left to right.
+  ctx.core.emit['String.fromCodePoint'] = (...codes) => {
+    if (codes.length === 0) return emit(['str', ''])
+    ctx.runtime.throws = true
     inc('__fromCodePoint')
-    return typed(['call', '$__fromCodePoint', asI32(emit(code))], 'f64')
+    const one = (node) => typed(['call', '$__fromCodePoint',
+      toNumF64(node, emit(node))], 'f64')
+    let r = one(codes[0])
+    for (let i = 1; i < codes.length; i++) {
+      inc('__str_concat_raw')
+      r = typed(['call', '$__str_concat_raw', asI64(r), asI64(one(codes[i]))], 'f64')
+    }
+    return r
+  }
+
+  ctx.core.stdlib['__encodeURIComponent'] = `(func $__encodeURIComponent (param $val i64) (result f64)
+    (local $str i64) (local $slen i32) (local $base i32) (local $out i32)
+    (local $i i32) (local $j i32) (local $c i32) (local $hi i32) (local $lo i32)
+    (local.set $str (call $__to_str (local.get $val)))
+    (local.set $slen (call $__str_byteLen (local.get $str)))
+    (if (i32.eqz (local.get $slen))
+      (then (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${LAYOUT.SSO_BIT}) (i32.const 0)))))
+    (local.set $base (call $__alloc (i32.add (i32.const 4) (i32.mul (local.get $slen) (i32.const 3)))))
+    (local.set $out (i32.add (local.get $base) (i32.const 4)))
+    (block $done (loop $loop
+      (br_if $done (i32.ge_u (local.get $i) (local.get $slen)))
+      (local.set $c (call $__char_at (local.get $str) (local.get $i)))
+      (if (i32.or
+            (i32.or
+              (i32.or
+                (i32.and (i32.ge_u (local.get $c) (i32.const 65)) (i32.le_u (local.get $c) (i32.const 90)))
+                (i32.and (i32.ge_u (local.get $c) (i32.const 97)) (i32.le_u (local.get $c) (i32.const 122))))
+              (i32.and (i32.ge_u (local.get $c) (i32.const 48)) (i32.le_u (local.get $c) (i32.const 57))))
+            (i32.or
+              (i32.or
+                (i32.or (i32.eq (local.get $c) (i32.const 45)) (i32.eq (local.get $c) (i32.const 95)))
+                (i32.or (i32.eq (local.get $c) (i32.const 46)) (i32.eq (local.get $c) (i32.const 33))))
+              (i32.or
+                (i32.or (i32.eq (local.get $c) (i32.const 126)) (i32.eq (local.get $c) (i32.const 42)))
+                (i32.or
+                  (i32.eq (local.get $c) (i32.const 39))
+                  (i32.or (i32.eq (local.get $c) (i32.const 40)) (i32.eq (local.get $c) (i32.const 41)))))))
+        (then
+          (i32.store8 (i32.add (local.get $out) (local.get $j)) (local.get $c))
+          (local.set $j (i32.add (local.get $j) (i32.const 1))))
+        (else
+          (local.set $hi (i32.shr_u (local.get $c) (i32.const 4)))
+          (local.set $lo (i32.and (local.get $c) (i32.const 15)))
+          (i32.store8 (i32.add (local.get $out) (local.get $j)) (i32.const 37))
+          (i32.store8 (i32.add (local.get $out) (i32.add (local.get $j) (i32.const 1)))
+            (i32.add (local.get $hi) (select (i32.const 55) (i32.const 48) (i32.gt_u (local.get $hi) (i32.const 9)))))
+          (i32.store8 (i32.add (local.get $out) (i32.add (local.get $j) (i32.const 2)))
+            (i32.add (local.get $lo) (select (i32.const 55) (i32.const 48) (i32.gt_u (local.get $lo) (i32.const 9)))))
+          (local.set $j (i32.add (local.get $j) (i32.const 3)))))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (br $loop)))
+    (i32.store (local.get $base) (local.get $j))
+    (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $out)))`
+
+  ctx.core.emit['encodeURIComponent'] = (value) => {
+    inc('__encodeURIComponent')
+    const input = value === undefined ? ['i64.const', UNDEF_NAN] : asI64(emit(value))
+    return typed(['call', '$__encodeURIComponent', input], 'f64')
+  }
+
+  ctx.core.stdlib['__uri_hex'] = `(func $__uri_hex (param $c i32) (result i32)
+    (if (result i32) (i32.and (i32.ge_u (local.get $c) (i32.const 48)) (i32.le_u (local.get $c) (i32.const 57)))
+      (then (i32.sub (local.get $c) (i32.const 48)))
+      (else (if (result i32) (i32.and (i32.ge_u (local.get $c) (i32.const 65)) (i32.le_u (local.get $c) (i32.const 70)))
+        (then (i32.sub (local.get $c) (i32.const 55)))
+        (else (if (result i32) (i32.and (i32.ge_u (local.get $c) (i32.const 97)) (i32.le_u (local.get $c) (i32.const 102)))
+          (then (i32.sub (local.get $c) (i32.const 87)))
+          (else (i32.const -1))))))))`
+
+  ctx.core.stdlib['__decodeURIComponent'] = `(func $__decodeURIComponent (param $v i64) (result f64)
+    (local $s i64) (local $len i32) (local $i i32)
+    (local $base i32) (local $dst i32) (local $outLen i32)
+    (local $c i32) (local $hi i32) (local $lo i32)
+    (local $b i32) (local $n i32) (local $j i32) (local $cp i32) (local $min i32) (local $stored i32)
+    (local.set $s (call $__to_str (local.get $v)))
+    (local.set $len (call $__str_byteLen (local.get $s)))
+    (local.set $base (call $__alloc (i32.add (i32.const 4) (local.get $len))))
+    (local.set $dst (i32.add (local.get $base) (i32.const 4)))
+    (block $done (loop $loop
+      (br_if $done (i32.ge_s (local.get $i) (local.get $len)))
+      (local.set $stored (i32.const 0))
+      (local.set $c (call $__char_at (local.get $s) (local.get $i)))
+      (if (i32.eq (local.get $c) (i32.const 37))
+        (then
+          (if (i32.ge_s (i32.add (local.get $i) (i32.const 2)) (local.get $len))
+            (then (throw $__jz_err (f64.const 0))))
+          (local.set $hi (call $__uri_hex (call $__char_at (local.get $s) (i32.add (local.get $i) (i32.const 1)))))
+          (local.set $lo (call $__uri_hex (call $__char_at (local.get $s) (i32.add (local.get $i) (i32.const 2)))))
+          (if (i32.or (i32.lt_s (local.get $hi) (i32.const 0)) (i32.lt_s (local.get $lo) (i32.const 0)))
+            (then (throw $__jz_err (f64.const 0))))
+          (local.set $c (i32.or (i32.shl (local.get $hi) (i32.const 4)) (local.get $lo)))
+          (local.set $i (i32.add (local.get $i) (i32.const 3)))
+          (if (i32.ge_u (local.get $c) (i32.const 128))
+            (then
+              (if (i32.and (i32.ge_u (local.get $c) (i32.const 0xC2)) (i32.le_u (local.get $c) (i32.const 0xDF)))
+                (then
+                  (local.set $n (i32.const 2))
+                  (local.set $cp (i32.and (local.get $c) (i32.const 0x1F)))
+                  (local.set $min (i32.const 0x80)))
+                (else (if (i32.and (i32.ge_u (local.get $c) (i32.const 0xE0)) (i32.le_u (local.get $c) (i32.const 0xEF)))
+                  (then
+                    (local.set $n (i32.const 3))
+                    (local.set $cp (i32.and (local.get $c) (i32.const 0x0F)))
+                    (local.set $min (i32.const 0x800)))
+                  (else (if (i32.and (i32.ge_u (local.get $c) (i32.const 0xF0)) (i32.le_u (local.get $c) (i32.const 0xF4)))
+                    (then
+                      (local.set $n (i32.const 4))
+                      (local.set $cp (i32.and (local.get $c) (i32.const 0x07)))
+                      (local.set $min (i32.const 0x10000)))
+                    (else (throw $__jz_err (f64.const 0))))))))
+              (i32.store8 (i32.add (local.get $dst) (local.get $outLen)) (local.get $c))
+              (local.set $outLen (i32.add (local.get $outLen) (i32.const 1)))
+              (local.set $j (i32.const 1))
+              (block $seqDone (loop $seq
+                (br_if $seqDone (i32.ge_s (local.get $j) (local.get $n)))
+                (if (i32.ge_s (i32.add (local.get $i) (i32.const 2)) (local.get $len))
+                  (then (throw $__jz_err (f64.const 0))))
+                (if (i32.ne (call $__char_at (local.get $s) (local.get $i)) (i32.const 37))
+                  (then (throw $__jz_err (f64.const 0))))
+                (local.set $hi (call $__uri_hex (call $__char_at (local.get $s) (i32.add (local.get $i) (i32.const 1)))))
+                (local.set $lo (call $__uri_hex (call $__char_at (local.get $s) (i32.add (local.get $i) (i32.const 2)))))
+                (if (i32.or (i32.lt_s (local.get $hi) (i32.const 0)) (i32.lt_s (local.get $lo) (i32.const 0)))
+                  (then (throw $__jz_err (f64.const 0))))
+                (local.set $b (i32.or (i32.shl (local.get $hi) (i32.const 4)) (local.get $lo)))
+                (if (i32.or (i32.lt_u (local.get $b) (i32.const 0x80)) (i32.gt_u (local.get $b) (i32.const 0xBF)))
+                  (then (throw $__jz_err (f64.const 0))))
+                (local.set $cp (i32.or (i32.shl (local.get $cp) (i32.const 6)) (i32.and (local.get $b) (i32.const 0x3F))))
+                (i32.store8 (i32.add (local.get $dst) (local.get $outLen)) (local.get $b))
+                (local.set $outLen (i32.add (local.get $outLen) (i32.const 1)))
+                (local.set $i (i32.add (local.get $i) (i32.const 3)))
+                (local.set $j (i32.add (local.get $j) (i32.const 1)))
+                (br $seq)))
+              (if (i32.or
+                    (i32.or (i32.lt_u (local.get $cp) (local.get $min)) (i32.gt_u (local.get $cp) (i32.const 0x10FFFF)))
+                    (i32.and (i32.ge_u (local.get $cp) (i32.const 0xD800)) (i32.le_u (local.get $cp) (i32.const 0xDFFF))))
+                (then (throw $__jz_err (f64.const 0))))
+              (local.set $stored (i32.const 1)))))
+        (else
+          (local.set $i (i32.add (local.get $i) (i32.const 1)))))
+      (if (i32.eqz (local.get $stored))
+        (then
+          (i32.store8 (i32.add (local.get $dst) (local.get $outLen)) (local.get $c))
+          (local.set $outLen (i32.add (local.get $outLen) (i32.const 1)))))
+      (br $loop)))
+    (i32.store (local.get $base) (local.get $outLen))
+    (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $dst)))`
+
+  ctx.core.emit['decodeURIComponent'] = (value) => {
+    ctx.runtime.throws = true
+    inc('__decodeURIComponent')
+    return typed(['call', '$__decodeURIComponent',
+      value === undefined ? ['i64.const', UNDEF_NAN] : asI64(emit(value))], 'f64')
   }
 
   // .at(i) → charAt with negative index support