jz 0.7.0 → 0.8.1

package/module/string.js

@@ -22,6 +22,38 @@ import { ssoBitI64Hex, sliceBitI64Hex, ptrNanHex, STR_INTERN_BIT } from '../layo
 const SSO_BIT_I64 = ssoBitI64Hex()
 const SLICE_BIT_I64 = sliceBitI64Hex()
 
+// === SSO codec — single source of truth for the inline-string bit layout ===
+// ASCII chars packed at 7 bits each into the NaN-box payload: char i at payload bit
+// i*7  (uniform `(ptr >> i*7) & 0x7f`), length at payload bits 42-44, SSO_BIT at bit 46
+// (SLICE_BIT at 45 stays 0). 6 chars fit (6*7=42, + 3-bit len). ASCII-only — a byte
+// ≥0x80 falls back to a heap string. The 7-bit-uniform layout makes equal short strings
+// content-bit-equal (so `op === 'tag'` is a bare i64.eq) and never touches memory.
+const MAX_SSO = 6
+const SSO_LEN_SHIFT = 10  // length occupies aux bits 10-12 (= payload bits 42-44)
+// JS: ASCII string → { aux, offset }, or null when ineligible (too long / non-ASCII).
+// BigInt-free (i32 ops only) so the self-hosted compiler — which runs this to encode
+// every string literal — stays on jz's numeric core. offset = payload bits 0-31, aux =
+// bits 32-46; char i at bit i*7 (chars 0-3 fit the offset, char 4 straddles, char 5 → aux).
+const ssoEncode = (str) => {
+  if (str.length > MAX_SSO || !/^[\x00-\x7f]*$/.test(str)) return null
+  let offset = 0, auxChars = 0
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charCodeAt(i), bit = i * 7
+    if (bit <= 24) offset |= c << bit                 // chars 0-3 (bits 0-27), wholly in offset
+    else if (bit < 32) { offset |= (c & 0xF) << 28; auxChars |= c >> 4 }  // char 4: bits 28-34 straddle
+    else auxChars |= c << (bit - 32)                  // char 5: bits 35-41 → aux bits 3-9
+  }
+  return { aux: LAYOUT.SSO_BIT | (str.length << SSO_LEN_SHIFT) | auxChars, offset: offset >>> 0 }
+}
+// aux for an SSO string whose chars all fit in the offset (len ≤ 4: 4*7=28 ≤ 32 bits).
+const ssoAux = (len) => LAYOUT.SSO_BIT | (len << SSO_LEN_SHIFT)
+// WAT: char i (i32 expr) of SSO ptr (i64 expr) — 7-bit at payload bit i*7.
+const ssoCharWat = (ptr, i) => `(i32.wrap_i64 (i64.and (i64.shr_u ${ptr} (i64.mul (i64.extend_i32_u ${i}) (i64.const 7))) (i64.const 0x7f)))`
+// WAT: length (i32) of SSO ptr (i64 expr) — payload bits 42-44.
+const ssoLenWat = (ptr) => `(i32.wrap_i64 (i64.and (i64.shr_u ${ptr} (i64.const 42)) (i64.const 7)))`
+// WAT: length (i32) from an already-extracted aux (i32 expr).
+const ssoLenFromAux = (aux) => `(i32.and (i32.shr_u ${aux} (i32.const ${SSO_LEN_SHIFT})) (i32.const 7))`
+
 // 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
@@ -43,26 +75,28 @@ const heapLenExpr = (ptrLocal, offLocal) => `(if (result i32)
 // bit-equal (SSO content IS the bits). Bails to the caller's heap path on a
 // non-ASCII byte (SSO is ASCII-only). Locals: $sb scratch byte, $sp packed.
 const sliceSsoPackWat = () => `
-    (if (i32.le_u (local.get $nlen) (i32.const 4))
+    (if (i32.le_u (local.get $nlen) (i32.const ${MAX_SSO}))
       (then (block $heap8
         (local.set $srcOff (i32.wrap_i64 (i64.and (local.get $ptr) (i64.const ${LAYOUT.OFFSET_MASK}))))
         (local.set $isSso (i32.wrap_i64 (i64.shr_u
           (i64.and (local.get $ptr) (i64.const ${SSO_BIT_I64}))
           (i64.const ${LAYOUT.AUX_SHIFT}))))
-        (local.set $i (i32.const 0)) (local.set $sp (i32.const 0))
-        (loop $pk8
+        (local.set $i (i32.const 0)) (local.set $sp64 (i64.const 0))
+        (loop $pk7
           (if (i32.lt_u (local.get $i) (local.get $nlen))
             (then
               (local.set $sb (if (result i32) (local.get $isSso)
-                (then (i32.and
-                  (i32.shr_u (local.get $srcOff) (i32.shl (i32.add (local.get $start) (local.get $i)) (i32.const 3)))
-                  (i32.const 0xFF)))
+                (then ${ssoCharWat('(local.get $ptr)', '(i32.add (local.get $start) (local.get $i))')})
                 (else (i32.load8_u (i32.add (i32.add (local.get $srcOff) (local.get $start)) (local.get $i))))))
               (br_if $heap8 (i32.ge_u (local.get $sb) (i32.const 0x80)))
-              (local.set $sp (i32.or (local.get $sp) (i32.shl (local.get $sb) (i32.shl (local.get $i) (i32.const 3)))))
+              (local.set $sp64 (i64.or (local.get $sp64)
+                (i64.shl (i64.extend_i32_u (local.get $sb)) (i64.mul (i64.extend_i32_u (local.get $i)) (i64.const 7)))))
               (local.set $i (i32.add (local.get $i) (i32.const 1)))
-              (br $pk8))))
-        (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.or (i32.const ${LAYOUT.SSO_BIT}) (local.get $nlen)) (local.get $sp))))))`
+              (br $pk7))))
+        (return (f64.reinterpret_i64 (i64.or (i64.or
+          (i64.const ${ptrNanHex(PTR.STRING, LAYOUT.SSO_BIT)})
+          (i64.shl (i64.extend_i32_u (local.get $nlen)) (i64.const 42)))
+          (local.get $sp64)))))))`
 
 // Probe the static intern index (buildInternTable, compile/index.js): a 5..32
 // byte slice whose content equals a static literal returns the CANONICAL
@@ -110,10 +144,17 @@ export default (ctx) => {
   deps({
     __str_concat: ['__to_str', '__str_byteLen', '__alloc', '__memgrow', '__mkptr', '__str_copy'],
     __str_concat_raw: ['__str_byteLen', '__alloc', '__memgrow', '__mkptr', '__str_copy'],
+    __str_concat_fresh: ['__to_str', '__str_byteLen', '__alloc', '__mkptr', '__str_copy'],
+    __str_concat_raw_fresh: ['__str_byteLen', '__alloc', '__mkptr', '__str_copy'],
     __str_append_byte: ['__str_byteLen', '__alloc', '__memgrow', '__mkptr', '__str_copy'],
     __str_copy: [],
-    __str_slice: ['__str_byteLen', '__alloc'],
-    __str_slice_view: ['__str_byteLen', '__mkptr', '__str_slice'],
+    // __str_slice/_view are FUNCTION templates: resolveIncludes' auto-dep scan realizes the
+    // factory (v()) to discover body calls, but that realization DIVERGES under self-host
+    // (jz.wasm) — so a body-called helper not also listed here is dropped from the kernel
+    // ("Unknown func $__clamp_idx" on `str.slice`). FN templates must declare body deps
+    // manually; pinned by test/selfhost-includes.js.
+    __str_slice: ['__str_byteLen', '__alloc', '__clamp_idx', '__mkptr'],
+    __str_slice_view: ['__str_byteLen', '__mkptr', '__str_slice', '__clamp_idx'],
     __str_indexof: ['__str_byteLen'],
     __str_lastindexof: ['__str_byteLen'],
     __wrap1: ['__alloc', '__mkptr'],
@@ -128,15 +169,15 @@ export default (ctx) => {
     __str_replace: ['__str_indexof', '__str_slice', '__str_concat'],
     __str_replaceall: ['__str_indexof', '__str_slice', '__str_concat'],
     __str_split: ['__str_slice', '__str_byteLen', '__char_at', '__alloc'],
-    __str_idx: [],
+    __str_idx: ['__char1byte'],
     __str_eq: ['__str_eq_cold'],
     __str_eq_cold: ['__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_slice_eq: ['__str_byteLen', '__str_range_eq', '__clamp_idx'],  // body-calls __clamp_idx; declare it (self-host auto-scan unreliable — test/selfhost-includes.js)
     __str_pad: ['__str_byteLen', '__str_copy', '__alloc'],
-    __str_join: ['__str_concat', '__to_str', '__str_byteLen', '__len', '__ptr_offset'],
+    __str_join: ['__str_concat', '__to_str', '__str_byteLen', '__len', '__ptr_offset', '__mkptr'],  // FN template: __mkptr body-called, must be manual (self-host auto-scan diverges)
     __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'],
@@ -162,11 +203,9 @@ export default (ctx) => {
   // === String literal: "abc" → SSO if ≤4 ASCII, else static data ===
 
   bind('str', (str) => {
-    const MAX_SSO = 4
-    if (ctx.features.sso && str.length <= MAX_SSO && /^[\x00-\x7f]*$/.test(str)) {
-      let packed = 0
-      for (let i = 0; i < str.length; i++) packed |= str.charCodeAt(i) << (i * 8)
-      return mkPtrIR(PTR.STRING, LAYOUT.SSO_BIT | str.length, packed)
+    if (ctx.features.sso) {
+      const sso = ssoEncode(str)
+      if (sso) return mkPtrIR(PTR.STRING, sso.aux, sso.offset)
     }
     const bytes = new TextEncoder().encode(str)
     const len = bytes.length
@@ -223,11 +262,7 @@ export default (ctx) => {
   // SSO/STRING ptrs never have forwarding pointers (only ARRAY does), so we extract
   // the raw offset directly instead of paying the __ptr_offset function-call overhead.
   wat('__sso_char', `(func $__sso_char (param $ptr i64) (param $i i32) (result i32)
-    (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)))`)
+    ${ssoCharWat('(local.get $ptr)', '(local.get $i)')})`)
 
   wat('__str_char', `(func $__str_char (param $ptr i64) (param $i i32) (result i32)
     (i32.load8_u (i32.add
@@ -254,16 +289,9 @@ export default (ctx) => {
       (i64.ne (i64.and (local.get $ptr) (i64.const ${SSO_BIT_I64})) (i64.const 0))
       (then
         (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})))
+          (i32.ge_u (local.get $i) ${ssoLenWat('(local.get $ptr)')})
           (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 ${ssoCharWat('(local.get $ptr)', '(local.get $i)')})))
       (else
         (if (result i32)
           (i32.ge_u (local.get $i)
@@ -301,9 +329,7 @@ export default (ctx) => {
       (i32.const ${LAYOUT.SSO_BIT})))
     (local.set $len
       (if (result i32) (local.get $isSso)
-        (then (i32.and
-          (i32.wrap_i64 (i64.shr_u (local.get $ptr) (i64.const ${LAYOUT.AUX_SHIFT})))
-          (i32.const ${LAYOUT.SSO_BIT - 1})))
+        (then ${ssoLenWat('(local.get $ptr)')})
         (else
           (if (result i32)
             (i64.ne (i64.and (local.get $ptr) (i64.const ${SLICE_BIT_I64})) (i64.const 0))
@@ -318,14 +344,15 @@ export default (ctx) => {
       (i32.or (i32.lt_s (local.get $i) (i32.const 0)) (i32.ge_u (local.get $i) (local.get $len)))
       (then (f64.const nan:${UNDEF_NAN}))
       (else
-        (f64.reinterpret_i64
-          (i64.or
-            ;; mkptr(STRING, SSO_BIT|1, 0) = NAN_PREFIX | (STRING<<TAG_SHIFT) | ((SSO_BIT|1)<<AUX_SHIFT)
-            (i64.const ${ptrNanHex(PTR.STRING, LAYOUT.SSO_BIT | 1)})
-            (i64.extend_i32_u
-              (if (result i32) (local.get $isSso)
-                (then (i32.and (i32.shr_u (local.get $off) (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 f64) (local.get $isSso)
+          ;; SSO source: chars are ASCII (<0x80) → inline 1-char SSO (hot path, no branch).
+          (then (f64.reinterpret_i64
+            (i64.or
+              (i64.const ${ptrNanHex(PTR.STRING, ssoAux(1))})
+              (i64.extend_i32_u ${ssoCharWat('(local.get $ptr)', '(local.get $i)')}))))
+          ;; Heap source: the byte may be ≥0x80 (non-ASCII), which can't be a 7-bit SSO,
+          ;; so __char1byte routes those to a heap 1-byte string.
+          (else (call $__char1byte (i32.load8_u (i32.add (local.get $off) (local.get $i)))))))))`)
 
   // Hot: ~53M calls in watr self-host. Bit-eq covers identity. SSO/SSO with !bit-eq
   // guarantees content differs (high 32 bits encode type+len; both equal → low 32 differs
@@ -372,9 +399,12 @@ export default (ctx) => {
     (local $ta i32) (local $tb i32)
     (local $offA i32) (local $offB i32)
     (local $ssoA i32) (local $ssoB i32)
-    (local $axA i32) (local $axB i32)
-    (if (i64.eq (local.get $a) (local.get $b))
-      (then (return (i32.const 1))))
+    ;; Sole caller is __str_eq, which already returned for bit-equal pointers, both-SSO
+    ;; (bit-ne ⇒ content-ne), both-canonical-interned (bit-ne ⇒ content-ne) and both-plain-
+    ;; heap length mismatch. Re-testing them here is dead work on every cold call — skip to
+    ;; the byte walk. (__str_eq/__str_eq_cold are ~14% of self-host runtime; this trims the
+    ;; per-call fixed cost.) The heap/mixed paths below still decide every case correctly
+    ;; on their own, so this stays correct even if a future caller skips the prelude.
     (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 $tb (i32.wrap_i64 (i64.and (i64.shr_u (local.get $b) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK}))))
     (local.set $offA (i32.wrap_i64 (i64.and (local.get $a) (i64.const ${LAYOUT.OFFSET_MASK}))))
@@ -385,22 +415,6 @@ export default (ctx) => {
     (local.set $ssoB (i32.and
       (i32.wrap_i64 (i64.shr_u (local.get $b) (i64.const ${LAYOUT.AUX_SHIFT})))
       (i32.const ${LAYOUT.SSO_BIT})))
-    ;; Both SSO with !bit-eq ⇒ content differs (high 32 bits hold tag+aux; both equal here).
-    (if (i32.and (local.get $ssoA) (local.get $ssoB))
-      (then (return (i32.const 0))))
-    ;; Both CANONICAL interned heap strings (STR_INTERN_BIT, SSO/SLICE clear):
-    ;; canonicals are deduped, so bit-ne ⇒ content-ne — the V8 pointer-compare
-    ;; equivalent. This is the dominant unequal case in tag-dispatch chains
-    ;; (op === 'literal' ladders over static literals).
-    (local.set $axA (i32.wrap_i64 (i64.shr_u (local.get $a) (i64.const ${LAYOUT.AUX_SHIFT}))))
-    (local.set $axB (i32.wrap_i64 (i64.shr_u (local.get $b) (i64.const ${LAYOUT.AUX_SHIFT}))))
-    (if (i32.and
-          (i32.and (i32.eq (local.get $ta) (i32.const ${PTR.STRING}))
-                   (i32.eq (local.get $tb) (i32.const ${PTR.STRING})))
-          (i32.and
-            (i32.eq (i32.and (local.get $axA) (i32.const ${LAYOUT.SSO_BIT | LAYOUT.SLICE_BIT | STR_INTERN_BIT})) (i32.const ${STR_INTERN_BIT}))
-            (i32.eq (i32.and (local.get $axB) (i32.const ${LAYOUT.SSO_BIT | LAYOUT.SLICE_BIT | STR_INTERN_BIT})) (i32.const ${STR_INTERN_BIT}))))
-      (then (return (i32.const 0))))
     ;; Both heap STRING fast path: inline len from header. Chunk by 4 bytes via unaligned
     ;; i32.load (wasm guarantees unaligned-OK), then byte-tail. Most string comparisons fail
     ;; early on the first 4-byte word, so this collapses the per-byte branch overhead into a
@@ -489,7 +503,7 @@ export default (ctx) => {
           (i32.wrap_i64 (i64.shr_u (local.get $ptr) (i64.const ${LAYOUT.AUX_SHIFT})))
           (i32.const ${LAYOUT.AUX_MASK})))
         (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})))
+          (then ${ssoLenFromAux('(local.get $aux)')})
           (else
             (if (result i32) (i32.and (local.get $aux) (i32.const ${LAYOUT.SLICE_BIT}))
               ;; view: length lives in aux[12:0], not a header.
@@ -507,21 +521,11 @@ export default (ctx) => {
   // (single bulk op instead of nlen × __char_at).
   wat('__str_slice', () => `(func $__str_slice (param $ptr i64) (param $start i32) (param $end i32) (result f64)
     (local $len i32) (local $nlen i32) (local $off i32) (local $i i32)
-    (local $srcOff i32) (local $isSso i32) (local $sb i32) (local $sp i32)
+    (local $srcOff i32) (local $isSso i32) (local $sb i32) (local $sp i32) (local $sp64 i64)
     (local $ip i32) (local $h i32) (local $j i32) (local $slot i32) (local $cand i32) (local $k 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))))
+    (local.set $start (call $__clamp_idx (local.get $start) (local.get $len)))
+    (local.set $end (call $__clamp_idx (local.get $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)))
@@ -560,18 +564,8 @@ export default (ctx) => {
     (local $len i32) (local $nlen i32) (local $srcOff i32) (local $tag i32)
     (local $ip i32) (local $h i32) (local $j i32) (local $slot i32) (local $cand i32) (local $k 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))))
+    (local.set $start (call $__clamp_idx (local.get $start) (local.get $len)))
+    (local.set $end (call $__clamp_idx (local.get $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)))
@@ -676,31 +670,33 @@ export default (ctx) => {
   wat('__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))))
+    (local.set $start (call $__clamp_idx (local.get $start) (local.get $len)))
+    (local.set $end (call $__clamp_idx (local.get $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.
+  // Needle byte j, SSO-aware (packed-bits extract vs heap load) — lets the SIMD
+  // haystack scan serve SSO needles too (the common short "," / "://" needle),
+  // not just heap×heap. `$nsso` is loop-invariant so the branch predicts away.
+  const nByte = (j) => `(if (result i32) (local.get $nsso)
+    (then ${ssoCharWat('(local.get $ndl)', j)})
+    (else (i32.load8_u (i32.add (local.get $noff) ${j}))))`
   wat('__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)
+    (local $splat v128) (local $mask i32) (local $scanEnd i32)
     ;; 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))))
+    ;; Empty needle matches at clamp(from, 0, hlen) — per 21.1.3.9 step 6 (Min(Max(pos,0),len)).
+    (if (i32.eqz (local.get $nlen))
+      (then (return (select
+        (select (local.get $from) (local.get $hlen) (i32.lt_s (local.get $from) (local.get $hlen)))
+        (i32.const 0)
+        (i32.ge_s (local.get $from) (i32.const 0))))))
     (if (i32.gt_s (local.get $nlen) (local.get $hlen)) (then (return (i32.const -1))))
     (local.set $hoff (i32.wrap_i64 (i64.and (local.get $hay) (i64.const ${LAYOUT.OFFSET_MASK}))))
     (local.set $noff (i32.wrap_i64 (i64.and (local.get $ndl) (i64.const ${LAYOUT.OFFSET_MASK}))))
@@ -711,6 +707,83 @@ export default (ctx) => {
       (i32.wrap_i64 (i64.shr_u (local.get $ndl) (i64.const ${LAYOUT.AUX_SHIFT})))
       (i32.const ${LAYOUT.SSO_BIT})))
     (local.set $i (if (result i32) (i32.gt_s (local.get $from) (i32.const 0)) (then (local.get $from)) (else (i32.const 0))))
+    ;; Single-byte needle (the common s.indexOf('/') / s.includes(' ')): scan for one byte without
+    ;; the per-position match/j/k bookkeeping. Heap haystack gets a branchless load8_u loop (no
+    ;; per-byte SSO test); a 16-wide SIMD scan here would only add splat/window setup that short
+    ;; strings — the bulk of single-char searches — never amortize, so the scalar scan stays.
+    (if (i32.eq (local.get $nlen) (i32.const 1))
+      (then
+        (local.set $nb ${nByte('(i32.const 0)')})
+        (if (i32.eqz (local.get $hsso))
+          (then
+            (block $sd (loop $ss
+              (br_if $sd (i32.ge_s (local.get $i) (local.get $hlen)))
+              (if (i32.eq (i32.load8_u (i32.add (local.get $hoff) (local.get $i))) (local.get $nb))
+                (then (return (local.get $i))))
+              (local.set $i (i32.add (local.get $i) (i32.const 1)))
+              (br $ss)))
+            (return (i32.const -1)))
+          (else
+            (block $sd2 (loop $ss2
+              (br_if $sd2 (i32.ge_s (local.get $i) (local.get $hlen)))
+              (if (i32.eq ${ssoCharWat('(local.get $hay)', '(local.get $i)')} (local.get $nb))
+                (then (return (local.get $i))))
+              (local.set $i (i32.add (local.get $i) (i32.const 1)))
+              (br $ss2)))
+            (return (i32.const -1))))))
+    ;; Multi-byte needle, HEAP haystack (needle SSO or heap): a SIMD first-byte memchr — broadcast
+    ;; needle[0] across 16 lanes, i8x16.eq a 16-byte haystack window, and read the match-bitmask.
+    ;; Only positions whose first byte matches reach the branchless verify; the rare match (V8's own
+    ;; StringIndexOf is SIMD here) is what the scalar path lost on. The SIMD load only touches the
+    ;; haystack, so an SSO needle (the common short "," / "://" / "TARGET") rides this path too —
+    ;; its bytes are fetched SSO-aware via nByte(). scanEnd = hlen-nlen is the last viable start; the
+    ;; window stops at hlen-16 (a full 16-byte load stays inside the string), a scalar tail covers
+    ;; the rest. Only an SSO haystack (≤ MAX_SSO bytes — too short to scan 16-wide) falls through.
+    (if (i32.eqz (local.get $hsso))
+      (then
+        (local.set $nb ${nByte('(i32.const 0)')})
+        (local.set $scanEnd (i32.sub (local.get $hlen) (local.get $nlen)))
+        (local.set $splat (i8x16.splat (local.get $nb)))
+        (block $vd (loop $vo
+          (br_if $vd (i32.gt_s (local.get $i) (i32.sub (local.get $hlen) (i32.const 16))))
+          (local.set $mask (i8x16.bitmask
+            (i8x16.eq (v128.load (i32.add (local.get $hoff) (local.get $i))) (local.get $splat))))
+          (block $bd (loop $bo
+            (br_if $bd (i32.eqz (local.get $mask)))
+            (local.set $k (i32.add (local.get $i) (i32.ctz (local.get $mask))))   ;; candidate start
+            (br_if $bd (i32.gt_s (local.get $k) (local.get $scanEnd)))            ;; positions only grow
+            (local.set $match (i32.const 1))
+            (local.set $j (i32.const 1))
+            (block $mn (loop $mi
+              (br_if $mn (i32.ge_s (local.get $j) (local.get $nlen)))
+              (if (i32.ne (i32.load8_u (i32.add (i32.add (local.get $hoff) (local.get $k)) (local.get $j)))
+                          ${nByte('(local.get $j)')})
+                (then (local.set $match (i32.const 0)) (br $mn)))
+              (local.set $j (i32.add (local.get $j) (i32.const 1)))
+              (br $mi)))
+            (if (local.get $match) (then (return (local.get $k))))
+            (local.set $mask (i32.and (local.get $mask) (i32.sub (local.get $mask) (i32.const 1))))  ;; clear lowest match
+            (br $bo)))
+          (local.set $i (i32.add (local.get $i) (i32.const 16)))
+          (br $vo)))
+        ;; scalar tail: positions [i, scanEnd] the SIMD window couldn't cover
+        (block $md (loop $mo
+          (br_if $md (i32.gt_s (local.get $i) (local.get $scanEnd)))
+          (if (i32.eq (i32.load8_u (i32.add (local.get $hoff) (local.get $i))) (local.get $nb))
+            (then
+              (local.set $match (i32.const 1))
+              (local.set $j (i32.const 1))
+              (block $mn2 (loop $mi2
+                (br_if $mn2 (i32.ge_s (local.get $j) (local.get $nlen)))
+                (if (i32.ne (i32.load8_u (i32.add (i32.add (local.get $hoff) (local.get $i)) (local.get $j)))
+                            ${nByte('(local.get $j)')})
+                  (then (local.set $match (i32.const 0)) (br $mn2)))
+                (local.set $j (i32.add (local.get $j) (i32.const 1)))
+                (br $mi2)))
+              (if (local.get $match) (then (return (local.get $i))))))
+          (local.set $i (i32.add (local.get $i) (i32.const 1)))
+          (br $mo)))
+        (return (i32.const -1))))
     (block $done (loop $outer
       (br_if $done (i32.gt_s (local.get $i) (i32.sub (local.get $hlen) (local.get $nlen))))
       (local.set $match (i32.const 1))
@@ -719,10 +792,10 @@ export default (ctx) => {
         (br_if $nomatch (i32.ge_s (local.get $j) (local.get $nlen)))
         (local.set $k (i32.add (local.get $i) (local.get $j)))
         (local.set $hb (if (result i32) (local.get $hsso)
-          (then (i32.and (i32.shr_u (local.get $hoff) (i32.shl (local.get $k) (i32.const 3))) (i32.const 0xFF)))
+          (then ${ssoCharWat('(local.get $hay)', '(local.get $k)')})
           (else (i32.load8_u (i32.add (local.get $hoff) (local.get $k))))))
         (local.set $nb (if (result i32) (local.get $nsso)
-          (then (i32.and (i32.shr_u (local.get $noff) (i32.shl (local.get $j) (i32.const 3))) (i32.const 0xFF)))
+          (then ${ssoCharWat('(local.get $ndl)', '(local.get $j)')})
           (else (i32.load8_u (i32.add (local.get $noff) (local.get $j))))))
         (if (i32.ne (local.get $hb) (local.get $nb))
           (then (local.set $match (i32.const 0)) (br $nomatch)))
@@ -771,10 +844,10 @@ export default (ctx) => {
         (br_if $nomatch (i32.ge_s (local.get $j) (local.get $nlen)))
         (local.set $k (i32.add (local.get $i) (local.get $j)))
         (local.set $hb (if (result i32) (local.get $hsso)
-          (then (i32.and (i32.shr_u (local.get $hoff) (i32.shl (local.get $k) (i32.const 3))) (i32.const 0xFF)))
+          (then ${ssoCharWat('(local.get $hay)', '(local.get $k)')})
           (else (i32.load8_u (i32.add (local.get $hoff) (local.get $k))))))
         (local.set $nb (if (result i32) (local.get $nsso)
-          (then (i32.and (i32.shr_u (local.get $noff) (i32.shl (local.get $j) (i32.const 3))) (i32.const 0xFF)))
+          (then ${ssoCharWat('(local.get $ndl)', '(local.get $j)')})
           (else (i32.load8_u (i32.add (local.get $noff) (local.get $j))))))
         (if (i32.ne (local.get $hb) (local.get $nb))
           (then (local.set $match (i32.const 0)) (br $nomatch)))
@@ -804,10 +877,10 @@ export default (ctx) => {
       (br_if $done (i32.ge_s (local.get $i) (local.get $plen)))
       (if (i32.ne
             (if (result i32) (local.get $ssso)
-              (then (i32.and (i32.shr_u (local.get $soff) (i32.shl (local.get $i) (i32.const 3))) (i32.const 0xFF)))
+              (then ${ssoCharWat('(local.get $str)', '(local.get $i)')})
               (else (i32.load8_u (i32.add (local.get $soff) (local.get $i)))))
             (if (result i32) (local.get $psso)
-              (then (i32.and (i32.shr_u (local.get $poff) (i32.shl (local.get $i) (i32.const 3))) (i32.const 0xFF)))
+              (then ${ssoCharWat('(local.get $pfx)', '(local.get $i)')})
               (else (i32.load8_u (i32.add (local.get $poff) (local.get $i))))))
         (then (return (i32.const 0))))
       (local.set $i (i32.add (local.get $i) (i32.const 1)))
@@ -835,10 +908,10 @@ export default (ctx) => {
       (local.set $k (i32.add (local.get $off) (local.get $i)))
       (if (i32.ne
             (if (result i32) (local.get $ssso)
-              (then (i32.and (i32.shr_u (local.get $soff) (i32.shl (local.get $k) (i32.const 3))) (i32.const 0xFF)))
+              (then ${ssoCharWat('(local.get $str)', '(local.get $k)')})
               (else (i32.load8_u (i32.add (local.get $soff) (local.get $k)))))
             (if (result i32) (local.get $fsso)
-              (then (i32.and (i32.shr_u (local.get $foff) (i32.shl (local.get $i) (i32.const 3))) (i32.const 0xFF)))
+              (then ${ssoCharWat('(local.get $sfx)', '(local.get $i)')})
               (else (i32.load8_u (i32.add (local.get $foff) (local.get $i))))))
         (then (return (i32.const 0))))
       (local.set $i (i32.add (local.get $i) (i32.const 1)))
@@ -860,9 +933,7 @@ export default (ctx) => {
       (then
         (block $dsso (loop $lsso
           (br_if $dsso (i32.ge_s (local.get $i) (local.get $len)))
-          (local.set $c (i32.and
-            (i32.shr_u (local.get $srcOff) (i32.shl (local.get $i) (i32.const 3)))
-            (i32.const 0xFF)))
+          (local.set $c ${ssoCharWat('(local.get $ptr)', '(local.get $i)')})
           (if (i32.and (i32.ge_u (local.get $c) (local.get $lo)) (i32.le_u (local.get $c) (local.get $hi)))
             (then (local.set $c (i32.add (local.get $c) (local.get $delta)))))
           (i32.store8 (i32.add (local.get $off) (local.get $i)) (local.get $c))
@@ -964,7 +1035,7 @@ export default (ctx) => {
     ;; Array (type=1) → join(",") like JS Array.toString()
     (if (i32.eq (local.get $type) (i32.const ${PTR.ARRAY}))
       (then (return (i64.reinterpret_f64 (call $__str_join (local.get $val)
-        (i64.reinterpret_f64 (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${LAYOUT.SSO_BIT | 1}) (i32.const 44))))))))
+        (i64.reinterpret_f64 (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${ssoAux(1)}) (i32.const 44))))))))
     (local.get $val))`)
 
   // Copy bytes of a string (SSO or heap) into memory at dst. Uses memory.copy for
@@ -973,18 +1044,15 @@ export default (ctx) => {
     (local $w i32)
     (if (i64.ne (i64.and (local.get $src) (i64.const ${SSO_BIT_I64})) (i64.const 0))
       (then
-        ;; SSO: up to 4 chars packed in low 32 bits (LE byte order). Unroll: write 1/2/3/4 bytes
-        ;; depending on len. (len > 4 is rare/disallowed in practice — fallback handles up to 4.)
-        (local.set $w (i32.wrap_i64 (local.get $src)))
-        (if (i32.ge_u (local.get $len) (i32.const 4))
-          (then (i32.store (local.get $dst) (local.get $w)))
-          (else
-            (if (i32.eq (local.get $len) (i32.const 0)) (then (return)))
-            (i32.store8 (local.get $dst) (local.get $w))
-            (if (i32.eq (local.get $len) (i32.const 1)) (then (return)))
-            (i32.store8 offset=1 (local.get $dst) (i32.shr_u (local.get $w) (i32.const 8)))
-            (if (i32.eq (local.get $len) (i32.const 2)) (then (return)))
-            (i32.store8 offset=2 (local.get $dst) (i32.shr_u (local.get $w) (i32.const 16))))))
+        ;; SSO: write $len ASCII chars, each 7-bit-packed at payload bit i*7 (chars 4-5
+        ;; span into aux, so read via the 7-bit codec, not the low 32 bits). $w = index.
+        (local.set $w (i32.const 0))
+        (loop $ssocp
+          (if (i32.lt_u (local.get $w) (local.get $len))
+            (then
+              (i32.store8 (i32.add (local.get $dst) (local.get $w)) ${ssoCharWat('(local.get $src)', '(local.get $w)')})
+              (local.set $w (i32.add (local.get $w) (i32.const 1)))
+              (br $ssocp)))))
       (else
         ;; Heap STRING: memory.copy directly from string data
         (memory.copy (local.get $dst)
@@ -1016,12 +1084,12 @@ export default (ctx) => {
       (then
         (return (call $__mkptr
           (i32.const ${PTR.STRING})
-          (i32.or (i32.const ${LAYOUT.SSO_BIT}) (local.get $total))
+          (i32.or (i32.const ${LAYOUT.SSO_BIT}) (i32.shl (local.get $total) (i32.const ${SSO_LEN_SHIFT})))
           (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))))))))`
+              (i32.mul (local.get $alen) (i32.const 7))))))))`
 
   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}))))
@@ -1048,6 +1116,18 @@ export default (ctx) => {
         (global.set $__heap (local.get $newHeap))
         (return (f64.reinterpret_i64 (local.get $a)))))` : ''
 
+  // Always-fresh tail: allocate a new buffer and copy both operands. Shared by the
+  // bump-extend concats (reached when `a` is NOT heap-top) and the `_fresh` variants
+  // (which never bump-extend at all — emit routes a NON-self-accumulating `t = s + x`
+  // here so it can't mutate the live `s` the way the heap-top extend would).
+  const allocCopyTail = `
+    (local.set $off (call $__alloc (i32.add (i32.const 4) (local.get $total))))
+    (i32.store (local.get $off) (local.get $total))
+    (local.set $off (i32.add (local.get $off) (i32.const 4)))
+    (call $__str_copy (local.get $a) (local.get $off) (local.get $alen))
+    (call $__str_copy (local.get $b) (i32.add (local.get $off) (local.get $alen)) (local.get $blen))
+    (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $off)))`
+
   // Fused single-byte append: `buf += str[i]` lowers to this when both sides are
   // VAL.STRING and the rhs is a string-index. Skips __str_idx's 1-char SSO
   // construction and __str_concat's type-dispatch — byte goes directly from
@@ -1086,19 +1166,17 @@ export default (ctx) => {
             (i32.wrap_i64 (i64.shr_u (local.get $a) (i64.const ${LAYOUT.AUX_SHIFT})))
             (i32.const ${LAYOUT.SSO_BIT})))
       (then
-        (local.set $alen (i32.and
-          (i32.wrap_i64 (i64.shr_u (local.get $a) (i64.const ${LAYOUT.AUX_SHIFT})))
-          (i32.const ${LAYOUT.SSO_BIT - 1})))
+        (local.set $alen ${ssoLenWat('(local.get $a)')})
         (if (i32.and
               (i32.lt_u (local.get $alen) (i32.const 4))
               (i32.lt_u (local.get $byte) (i32.const 0x80)))
           (then
             (return (call $__mkptr
               (i32.const ${PTR.STRING})
-              (i32.or (i32.const ${LAYOUT.SSO_BIT}) (i32.add (local.get $alen) (i32.const 1)))
+              (i32.or (i32.const ${LAYOUT.SSO_BIT}) (i32.shl (i32.add (local.get $alen) (i32.const 1)) (i32.const ${SSO_LEN_SHIFT})))
               (i32.or
                 (local.get $aoff)
-                (i32.shl (local.get $byte) (i32.shl (local.get $alen) (i32.const 3))))))))))
+                (i32.shl (local.get $byte) (i32.mul (local.get $alen) (i32.const 7))))))))))
     ;; Slow path: allocate new heap STRING with original bytes + 1 new byte
     (local.set $alen (call $__str_byteLen (local.get $a)))
     (local.set $total (i32.add (local.get $alen) (i32.const 1)))
@@ -1109,6 +1187,10 @@ export default (ctx) => {
     (i32.store8 (i32.add (local.get $off) (local.get $alen)) (local.get $byte))
     (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $off)))`)
 
+  // __str_concat / __str_concat_raw bump-EXTEND `a` in place when it is the heap-top own string
+  // (the O(N) accumulator path). Emit calls these ONLY when the source is a self-accumulation
+  // `x = x + …` (so the mutated `a` is dead-after-reassign) or when `a` is a provably-fresh
+  // module-internal temporary; a plain `t = s + x` over a live `s` routes to the _fresh twins.
   wat('__str_concat', `(func $__str_concat (param $a i64) (param $b i64) (result f64)
     (local $alen i32) (local $blen i32) (local $total i32) (local $off i32)
     (local $ta i32) (local $aoff i32) (local $newHeap i32)
@@ -1121,13 +1203,7 @@ export default (ctx) => {
     (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))
-    (local.set $off (i32.add (local.get $off) (i32.const 4)))
-    (call $__str_copy (local.get $a) (local.get $off) (local.get $alen))
-    (call $__str_copy (local.get $b) (i32.add (local.get $off) (local.get $alen)) (local.get $blen))
-    (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $off)))`)
+    ${concatFast}${allocCopyTail}`)
 
   wat('__str_concat_raw', `(func $__str_concat_raw (param $a i64) (param $b i64) (result f64)
     (local $alen i32) (local $blen i32) (local $total i32) (local $off i32)
@@ -1138,13 +1214,30 @@ export default (ctx) => {
     (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))
-    (local.set $off (i32.add (local.get $off) (i32.const 4)))
-    (call $__str_copy (local.get $a) (local.get $off) (local.get $alen))
-    (call $__str_copy (local.get $b) (i32.add (local.get $off) (local.get $alen)) (local.get $blen))
-    (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $off)))`)
+    ${concatFast}${allocCopyTail}`)
+
+  // Non-mutating twins: same SSO-pair fast path, but NEVER bump-extend — always alloc+copy a fresh
+  // buffer, leaving `a` untouched. The default for emit's user-level `+` (any `t = s + x` where the
+  // result is not assigned straight back to `s`), so string immutability holds for live operands.
+  wat('__str_concat_fresh', `(func $__str_concat_fresh (param $a i64) (param $b i64) (result f64)
+    (local $alen i32) (local $blen i32) (local $total i32) (local $off i32)
+    (local.set $a (call $__to_str (local.get $a)))
+    (local.set $b (call $__to_str (local.get $b)))
+    (local.set $alen (call $__str_byteLen (local.get $a)))
+    (local.set $blen (call $__str_byteLen (local.get $b)))
+    (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}${allocCopyTail}`)
+
+  wat('__str_concat_raw_fresh', `(func $__str_concat_raw_fresh (param $a i64) (param $b i64) (result f64)
+    (local $alen i32) (local $blen i32) (local $total i32) (local $off i32)
+    (local.set $alen (call $__str_byteLen (local.get $a)))
+    (local.set $blen (call $__str_byteLen (local.get $b)))
+    (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}${allocCopyTail}`)
 
   wat('__str_replace', `(func $__str_replace (param $str i64) (param $search i64) (param $repl i64) (result f64)
     (local $idx i32) (local $slen i32)
@@ -1379,11 +1472,11 @@ export default (ctx) => {
               (then
                 (local.set $sb (i32.load8_u (i32.add (local.get $off) (local.get $i))))
                 (br_if $heap (i32.ge_u (local.get $sb) (i32.const 0x80)))
-                (local.set $sp (i32.or (local.get $sp) (i32.shl (local.get $sb) (i32.shl (local.get $i) (i32.const 3)))))
+                (local.set $sp (i32.or (local.get $sp) (i32.shl (local.get $sb) (i32.mul (local.get $i) (i32.const 7)))))
                 (local.set $i (i32.add (local.get $i) (i32.const 1)))
                 (br $pk))))
           (global.set $__heap (i32.sub (local.get $off) (i32.const 4)))
-          (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.or (i32.const ${LAYOUT.SSO_BIT}) (local.get $target)) (local.get $sp))))))` : ''}
+          (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.or (i32.const ${LAYOUT.SSO_BIT}) (i32.shl (local.get $target) (i32.const 10))) (local.get $sp))))))` : ''}
     (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $off)))`)
 
   // Base helpers (__sso_char/__str_char/__char_at/__str_byteLen) are referenced
@@ -1621,7 +1714,7 @@ export default (ctx) => {
 
   const padMethod = (start) => (str, len, pad) => {
     inc('__str_pad')
-    const vpad = pad != null ? asI64(emit(pad)) : ['i64.reinterpret_f64', mkPtrIR(PTR.STRING, LAYOUT.SSO_BIT | 1, 32)]
+    const vpad = pad != null ? asI64(emit(pad)) : ['i64.reinterpret_f64', mkPtrIR(PTR.STRING, ssoAux(1), 32)]
     return typed(['call', '$__str_pad', asI64(emit(str)), asI32(emit(len)), vpad, ['i32.const', start]], 'f64')
   }
   bind('.padStart', padMethod(1))
@@ -1688,14 +1781,17 @@ export default (ctx) => {
   // index; otherwise `oobIR`. Without the bounds check `__char_at` returns 0 for an
   // out-of-range index, which would wrap to a bogus `"\x00"` string (charAt → "",
   // at → undefined). `sLocal` is the receiver as an f64 local.
-  const charAtOr = (sLocal, iLocal, lenIR, oobIR) =>
+  const charAtOr = (sLocal, iLocal, lenIR, oobIR) => (
+    inc('__char1byte'),
     ['if', ['result', 'f64'],
       ['i32.and',
         ['i32.ge_s', ['local.get', iLocal], ['i32.const', 0]],
         ['i32.lt_s', ['local.get', iLocal], lenIR]],
-      ['then', mkPtrIR(PTR.STRING, LAYOUT.SSO_BIT | 1,
-        ['call', '$__char_at', ['i64.reinterpret_f64', ['local.get', sLocal]], ['local.get', iLocal]])],
-      ['else', oobIR]]
+      // __char_at yields a raw byte (≥0x80 for non-ASCII heap strings) → __char1byte
+      // builds an SSO byte when ASCII, else a heap 1-byte string.
+      ['then', ['call', '$__char1byte',
+        ['call', '$__char_at', ['i64.reinterpret_f64', ['local.get', sLocal]], ['local.get', iLocal]]]],
+      ['else', oobIR]])
   const emptyStr = mkPtrIR(PTR.STRING, LAYOUT.SSO_BIT, 0)
 
   // .charAt(i) → 1-char string at index i, or "" when out of range (JS spec: no
@@ -1742,13 +1838,27 @@ export default (ctx) => {
     return typed(['f64.reinterpret_i64', toStrI64(value, emit(value))], 'f64')
   })
 
+  // 1-byte string from a raw byte: SSO when ASCII (<0x80, fits the 7-bit codec),
+  // else a heap 1-byte string (the 7-bit SSO can't represent bytes ≥0x80).
+  wat('__char1byte', `(func $__char1byte (param $b i32) (result f64)
+    (local $off i32)
+    (local.set $b (i32.and (local.get $b) (i32.const 0xFF)))
+    (if (result f64) (i32.lt_u (local.get $b) (i32.const 0x80))
+      (then (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${ssoAux(1)}) (local.get $b)))
+      (else
+        (local.set $off (call $__alloc (i32.const 8)))
+        (i32.store (local.get $off) (i32.const 1))
+        (i32.store8 (i32.add (local.get $off) (i32.const 4)) (local.get $b))
+        (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (i32.add (local.get $off) (i32.const 4))))))`)
+
   // String.fromCharCode(...codes) — variadic; each arg is ToUint16(ToNumber(code))
   // → a 1-byte string, concatenated left to right (mirrors String.fromCodePoint).
   bind('String.fromCharCode', (...codes) => {
     if (codes.length === 0) return emit(['str', ''])
     // ToUint16(ToNumber(code)): `toNumF64` performs ToPrimitive on an object
-    // argument, so a throwing valueOf/toString propagates per spec.
-    const one = (node) => mkPtrIR(PTR.STRING, LAYOUT.SSO_BIT | 1, asI32(toNumF64(node, emit(node))))
+    // argument, so a throwing valueOf/toString propagates per spec. A byte ≥0x80
+    // can't be a 7-bit-ASCII SSO, so __char1byte routes it to a heap 1-byte string.
+    const one = (node) => { inc('__char1byte'); return typed(['call', '$__char1byte', asI32(toNumF64(node, emit(node)))], 'f64') }
     let r = one(codes[0])
     for (let i = 1; i < codes.length; i++) {
       inc('__str_concat_raw')
@@ -1771,27 +1881,41 @@ export default (ctx) => {
     (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)))))
-    ;; 2-byte: 0x80-0x7FF → SSO
+      (then (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${ssoAux(1)}) (local.get $cp)))))
+    ;; multi-byte (cp ≥ 0x80): UTF-8 bytes are ≥0x80 → can't be 7-bit ASCII SSO, so
+    ;; build a heap STRING (len header at $off, bytes at $off+4). Over-alloc to 8 so the
+    ;; i32.store of the packed bytes never runs past the buffer; the len word bounds reads.
+    ;; 2-byte: 0x80-0x7FF
     (if (i32.lt_u (local.get $cp) (i32.const 0x800))
-      (then (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${LAYOUT.SSO_BIT | 2})
-        (i32.or
-          (i32.or (i32.const 0xC0) (i32.shr_u (local.get $cp) (i32.const 6)))
-          (i32.shl (i32.or (i32.const 0x80) (i32.and (local.get $cp) (i32.const 0x3F))) (i32.const 8)))))))
-    ;; 3-byte: 0x800-0xFFFF → SSO (3 bytes fits)
+      (then
+        (local.set $off (call $__alloc (i32.const 8)))
+        (i32.store (local.get $off) (i32.const 2))
+        (i32.store (i32.add (local.get $off) (i32.const 4))
+          (i32.or
+            (i32.or (i32.const 0xC0) (i32.shr_u (local.get $cp) (i32.const 6)))
+            (i32.shl (i32.or (i32.const 0x80) (i32.and (local.get $cp) (i32.const 0x3F))) (i32.const 8))))
+        (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (i32.add (local.get $off) (i32.const 4))))))
+    ;; 3-byte: 0x800-0xFFFF
     (if (i32.lt_u (local.get $cp) (i32.const 0x10000))
-      (then (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${LAYOUT.SSO_BIT | 3})
-        (i32.or (i32.or
-          (i32.or (i32.const 0xE0) (i32.shr_u (local.get $cp) (i32.const 12)))
-          (i32.shl (i32.or (i32.const 0x80) (i32.and (i32.shr_u (local.get $cp) (i32.const 6)) (i32.const 0x3F))) (i32.const 8)))
-          (i32.shl (i32.or (i32.const 0x80) (i32.and (local.get $cp) (i32.const 0x3F))) (i32.const 16)))))))
-    ;; 4-byte: 0x10000-0x10FFFF → SSO (4 bytes fits)
-    (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const ${LAYOUT.SSO_BIT | 4})
+      (then
+        (local.set $off (call $__alloc (i32.const 8)))
+        (i32.store (local.get $off) (i32.const 3))
+        (i32.store (i32.add (local.get $off) (i32.const 4))
+          (i32.or (i32.or
+            (i32.or (i32.const 0xE0) (i32.shr_u (local.get $cp) (i32.const 12)))
+            (i32.shl (i32.or (i32.const 0x80) (i32.and (i32.shr_u (local.get $cp) (i32.const 6)) (i32.const 0x3F))) (i32.const 8)))
+            (i32.shl (i32.or (i32.const 0x80) (i32.and (local.get $cp) (i32.const 0x3F))) (i32.const 16))))
+        (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (i32.add (local.get $off) (i32.const 4))))))
+    ;; 4-byte: 0x10000-0x10FFFF
+    (local.set $off (call $__alloc (i32.const 8)))
+    (i32.store (local.get $off) (i32.const 4))
+    (i32.store (i32.add (local.get $off) (i32.const 4))
       (i32.or (i32.or (i32.or
         (i32.or (i32.const 0xF0) (i32.shr_u (local.get $cp) (i32.const 18)))
         (i32.shl (i32.or (i32.const 0x80) (i32.and (i32.shr_u (local.get $cp) (i32.const 12)) (i32.const 0x3F))) (i32.const 8)))
         (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))))))`)
+        (i32.shl (i32.or (i32.const 0x80) (i32.and (local.get $cp) (i32.const 0x3F))) (i32.const 24))))
+    (return (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (i32.add (local.get $off) (i32.const 4)))))`)
 
   // String.fromCodePoint(...codePoints) — variadic; each arg is ToNumber-coerced
   // then validated/encoded by __fromCodePoint, results concatenated left to right.