jz 0.9.1 → 0.9.2

package/module/string.js

@@ -186,7 +186,7 @@ export default (ctx) => {
     __str_split: ['__str_slice', '__str_byteLen', '__char_at', '__alloc'],
     __str_idx: ['__char1byte'],
     __sso_norm: [],
-    __bytes_decode: ['__ptr_offset', '__len', '__alloc', '__mkptr', '__sso_norm'],
+    __bytes_decode: ['__typed_data', '__len', '__alloc', '__mkptr', '__sso_norm'],
     __str_eq: ['__str_eq_cold'],
     __str_eq_cold: ['__char_at', '__str_byteLen'],
     __str_cmp: ['__char_at', '__str_byteLen'],
@@ -198,7 +198,22 @@ export default (ctx) => {
     __str_encode: ['__str_byteLen', '__str_copy'],
     __encodeURIComponent: ['__to_str', '__str_byteLen', '__char_at', '__alloc', '__mkptr', '__sso_norm'],
     __decodeURIComponent: ['__to_str', '__str_byteLen', '__char_at', '__alloc', '__mkptr', '__uri_hex', '__sso_norm'],
+    __encodeURI: ['__to_str', '__str_byteLen', '__char_at', '__alloc', '__mkptr', '__sso_norm'],
+    __decodeURI: ['__to_str', '__str_byteLen', '__char_at', '__alloc', '__mkptr', '__uri_hex', '__sso_norm'],
     __uri_hex: [],
+    // base64/hex codec family (Uint8Array.fromBase64/toBase64/…, atob/btoa)
+    __b64_enc: ['__alloc', '__mkptr', '__sso_norm'],
+    __b64_dec_raw: ['__str_byteLen', '__char_at'],
+    __btoa: ['__to_str', '__str_byteLen', '__str_copy', '__alloc', '__b64_enc'],
+    __atob: ['__to_str', '__str_byteLen', '__alloc', '__b64_dec_raw', '__mkptr', '__sso_norm'],
+    __b64_from: ['__to_str', '__str_byteLen', '__alloc', '__b64_dec_raw', '__mkptr'],
+    __b64_set: ['__b64_dec_raw', '__u8_data', '__len'],
+    __hex_enc: ['__alloc', '__mkptr', '__sso_norm'],
+    __hex_dec_raw: ['__str_byteLen', '__char_at', '__uri_hex'],
+    __hex_from: ['__to_str', '__str_byteLen', '__alloc', '__hex_dec_raw', '__mkptr'],
+    __hex_set: ['__hex_dec_raw', '__u8_data', '__len'],
+    __u8_data: ['__ptr_type', '__ptr_aux', '__typed_data'],
+    __str_encode_into: ['__str_byteLen', '__char_at', '__str_copy', '__len', '__typed_data', '__ptr_type', '__ptr_aux'],
     __to_str: ['__ftoa', '__static_str', '__str_join', '__mkptr'],
     __str_byteLen: ['__ptr_type', '__ptr_aux', '__str_len'],
   })
@@ -2147,19 +2162,18 @@ export default (ctx) => {
     return r
   })
 
-  wat('__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
+  // Percent-codec char classes (ECMA-262 19.2.2–19.2.5). Both encoders share one
+  // loop shape and differ only in the always-unescaped set: encodeURIComponent
+  // passes only the unreserved marks; encodeURI additionally leaves the URI
+  // reserved set `; / ? : @ & = + $ , #` intact. Same split decoding: decode-
+  // URIComponent decodes every escape, decodeURI copies the original `%XX`
+  // triplet through for reserved bytes (case-preserving). Generated kernels —
+  // the unused variant dead-strips like any stdlib body.
+  const URI_RESERVED = [59, 47, 63, 58, 64, 38, 61, 43, 36, 44, 35] // ; / ? : @ & = + $ , #
+  const uriReservedTest = URI_RESERVED
+    .map(c => `(i32.eq (local.get $c) (i32.const ${c}))`)
+    .reduce((a, b) => `(i32.or ${a} ${b})`)
+  const uriSafeTest = `(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)))
@@ -2173,7 +2187,21 @@ export default (ctx) => {
                 (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)))))))
+                  (i32.or (i32.eq (local.get $c) (i32.const 40)) (i32.eq (local.get $c) (i32.const 41)))))))`
+
+  const uriEncodeKernel = (name, keepReserved) => `(func $${name} (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 ${keepReserved ? `(i32.or ${uriSafeTest} ${uriReservedTest})` : uriSafeTest}
         (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))))
@@ -2189,13 +2217,18 @@ export default (ctx) => {
       (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (br $loop)))
     (i32.store (local.get $base) (local.get $j))
-    (call $__sso_norm (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $out))))`)
+    (call $__sso_norm (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $out))))`
+
+  wat('__encodeURIComponent', uriEncodeKernel('__encodeURIComponent', false))
+  wat('__encodeURI', uriEncodeKernel('__encodeURI', true))
 
-  bind('encodeURIComponent', (value) => {
-    inc('__encodeURIComponent')
+  const uriEncodeBind = (kernel) => (value) => {
+    inc(kernel)
     const input = value === undefined ? ['i64.const', UNDEF_NAN] : asI64(emit(value))
-    return typed(['call', '$__encodeURIComponent', input], 'f64')
-  })
+    return typed(['call', `$${kernel}`, input], 'f64')
+  }
+  bind('encodeURIComponent', uriEncodeBind('__encodeURIComponent'))
+  bind('encodeURI', uriEncodeBind('__encodeURI'))
 
   wat('__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)))
@@ -2206,7 +2239,19 @@ export default (ctx) => {
           (then (i32.sub (local.get $c) (i32.const 87)))
           (else (i32.const -1))))))))`)
 
-  wat('__decodeURIComponent', `(func $__decodeURIComponent (param $v i64) (result f64)
+  // Reserved-byte passthrough for decodeURI: at this point $i still sits on the
+  // `%`, the two hex chars are validated, and $c < 128 for every reserved code —
+  // copy the ORIGINAL triplet (case-preserving per spec) and skip the store.
+  const uriKeepReserved = `(if ${uriReservedTest} (then
+            (i32.store8 (i32.add (local.get $dst) (local.get $outLen)) (i32.const 37))
+            (i32.store8 (i32.add (local.get $dst) (i32.add (local.get $outLen) (i32.const 1)))
+              (call $__char_at (local.get $s) (i32.add (local.get $i) (i32.const 1))))
+            (i32.store8 (i32.add (local.get $dst) (i32.add (local.get $outLen) (i32.const 2)))
+              (call $__char_at (local.get $s) (i32.add (local.get $i) (i32.const 2))))
+            (local.set $outLen (i32.add (local.get $outLen) (i32.const 3)))
+            (local.set $stored (i32.const 1))))`
+
+  const uriDecodeKernel = (name, keepReserved) => `(func $${name} (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)
@@ -2228,6 +2273,7 @@ export default (ctx) => {
           (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)))
+          ${keepReserved ? uriKeepReserved : ''}
           (local.set $i (i32.add (local.get $i) (i32.const 3)))
           (if (i32.ge_u (local.get $c) (i32.const 128))
             (then
@@ -2282,14 +2328,19 @@ export default (ctx) => {
           (local.set $outLen (i32.add (local.get $outLen) (i32.const 1)))))
       (br $loop)))
     (i32.store (local.get $base) (local.get $outLen))
-    (call $__sso_norm (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $dst))))`)
+    (call $__sso_norm (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $dst))))`
+
+  wat('__decodeURIComponent', uriDecodeKernel('__decodeURIComponent', false))
+  wat('__decodeURI', uriDecodeKernel('__decodeURI', true))
 
-  bind('decodeURIComponent', (value) => {
+  const uriDecodeBind = (kernel) => (value) => {
     ctx.runtime.throws = true
-    inc('__decodeURIComponent')
-    return typed(['call', '$__decodeURIComponent',
+    inc(kernel)
+    return typed(['call', `$${kernel}`,
       value === undefined ? ['i64.const', UNDEF_NAN] : asI64(emit(value))], 'f64')
-  })
+  }
+  bind('decodeURIComponent', uriDecodeBind('__decodeURIComponent'))
+  bind('decodeURI', uriDecodeBind('__decodeURI'))
 
   // .at(i) → 1-char string at index i with negative-index support, or undefined
   // when out of range (JS spec: `i += length` for negative, then OOB → undefined).
@@ -2344,8 +2395,26 @@ export default (ctx) => {
     (call $__mkptr (i32.const 1) (i32.const 0) (i32.add (local.get $ptr) (i32.const 8))))`)
 
   // TextEncoder() / TextDecoder() → dummy values (methods do the work)
+  // UTF-8 is the only encoding jz ships (encoding tables are the same
+  // multi-KB cost Intl was refused for) — any other label would silently
+  // decode UTF-8, so reject it at compile time.
+  const decoderLabel = (label) => {
+    if (label == null) return  // no arg (a no-arg call pads a null slot)
+    const lit = Array.isArray(label) && label[0] === 'str' ? String(label[1]).trim().toLowerCase() : null
+    if (lit == null) err(`TextDecoder label must be a literal string — jz resolves encodings at compile time`)
+    else if (lit !== 'utf-8' && lit !== 'utf8' && lit !== 'unicode-1-1-utf-8')
+      err(`TextDecoder: only 'utf-8' is supported — other encodings need tables jz doesn't ship`)
+  }
+  // A chained receiver (`new TextDecoder(l).decode(x)`) is never emitted — the
+  // methods ignore the dummy value — so validate the label at the receiver too.
+  const decoderRecvCheck = (node) => {
+    if (Array.isArray(node) && node[0] === '()' && node[1] === 'TextDecoder') decoderLabel(node[2])
+  }
   bind('TextEncoder', () => typed(['f64.const', 1], 'f64'))
-  bind('TextDecoder', () => typed(['f64.const', 2], 'f64'))
+  bind('TextDecoder', (label) => {
+    decoderLabel(label)
+    return typed(['f64.const', 2], 'f64')
+  })
 
   // .encode(str) → Uint8Array of string's UTF-8 bytes
   // Copies bytes from string (SSO or heap) into a new Uint8Array
@@ -2372,7 +2441,9 @@ export default (ctx) => {
   // .decode(uint8arr) → string from byte data
   wat('__bytes_decode', `(func $__bytes_decode (param $arr i64) (result f64)
     (local $off i32) (local $len i32) (local $dst i32)
-    (local.set $off (call $__ptr_offset (local.get $arr)))
+    ;; __typed_data, not __ptr_offset — a VIEW's offset is its descriptor, and
+    ;; decoding it read the descriptor bytes as text (silent garbage)
+    (local.set $off (call $__typed_data (local.get $arr)))
     (local.set $len (call $__len (local.get $arr)))
     (local.set $dst (call $__alloc (i32.add (i32.const 4) (local.get $len))))
     (i32.store (local.get $dst) (local.get $len))
@@ -2384,7 +2455,341 @@ export default (ctx) => {
     (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $dst)))`)
 
   bind('.decode', (obj, arr) => {
+    decoderRecvCheck(obj)
     inc('__bytes_decode')
     return typed(['call', '$__bytes_decode', asI64(emit(arr))], 'f64')
   })
+
+  // .encodeInto(str, u8) → { read, written }. jz strings are UTF-8 bytes, so
+  // read counts bytes (== written), not UTF-16 units — same divergence class as
+  // `"中".length`. Never splits a multi-byte sequence: a truncated copy backs
+  // off past continuation bytes to the previous boundary (spec: whole code
+  // points only). Result is a dictionary object (HASH) — a one-shot small
+  // record, not a hot-path value.
+  wat('__str_encode_into', `(func $__str_encode_into (param $s i64) (param $dst i64) (result i32)
+    (local $slen i32) (local $n i32)
+    ;; receiver must be a Uint8Array — anything else is a TypeError in JS
+    (if (i32.or
+          (i32.ne (call $__ptr_type (local.get $dst)) (i32.const ${PTR.TYPED}))
+          (i32.ne (i32.and (call $__ptr_aux (local.get $dst)) (i32.const 7)) (i32.const 1)))
+      (then (throw $__jz_err (f64.const 0))))
+    (local.set $slen (call $__str_byteLen (local.get $s)))
+    (local.set $n (call $__len (local.get $dst)))
+    (if (i32.ge_s (local.get $n) (local.get $slen))
+      (then (local.set $n (local.get $slen)))
+      (else ;; truncated: back off to a UTF-8 boundary (exclude the split sequence)
+        (block $b (loop $l
+          (br_if $b (i32.eqz (local.get $n)))
+          (br_if $b (i32.ne
+            (i32.and (call $__char_at (local.get $s) (local.get $n)) (i32.const 0xC0))
+            (i32.const 0x80)))
+          (local.set $n (i32.sub (local.get $n) (i32.const 1)))
+          (br $l)))))
+    (call $__str_copy (local.get $s) (call $__typed_data (local.get $dst)) (local.get $n))
+    (local.get $n))`)
+
+  bind('.encodeInto', (obj, str, dst) => {
+    ctx.runtime.throws = true
+    ctx.features.typedarray = true
+    inc('__str_encode_into', '__hash_new', '__hash_set')
+    const n = tempI32('ein'), h = temp('eih')
+    const hI64 = ['i64.reinterpret_f64', ['local.get', `$${h}`]]
+    const nVal = ['i64.reinterpret_f64', ['f64.convert_i32_s', ['local.get', `$${n}`]]]
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${n}`, ['call', '$__str_encode_into', asI64(emit(str)), asI64(emit(dst))]],
+      ['local.set', `$${h}`, ['call', '$__hash_new']],
+      ['local.set', `$${h}`, ['f64.reinterpret_i64',
+        ['call', '$__hash_set', hI64, asI64(emit(['str', 'read'])), nVal]]],
+      ['local.set', `$${h}`, ['f64.reinterpret_i64',
+        ['call', '$__hash_set', hI64, asI64(emit(['str', 'written'])), nVal]]],
+      ['local.get', `$${h}`]], 'f64')
+  })
+
+  // === base64 / hex codecs ===
+  // One encode loop and one decode loop serve the whole family: the ES2026
+  // Uint8Array.fromBase64/toBase64/fromHex/toHex/setFrom* methods (emitters in
+  // module/typedarray.js) and the legacy atob/btoa pair. Decode follows WHATWG
+  // forgiving-base64 == TC39 lastChunkHandling:'loose': ASCII whitespace
+  // skipped, padding optional but validated when present, len%4==1 rejected,
+  // extra trailing bits ignored. Alphabet (std/url) and padding ride as i32
+  // flags — resolved compile-time from literal options, so no per-call parsing.
+
+  // put one 6-bit value ($v pre-masked) as a base64 char at $out+$j
+  const b64put = (bits) => `(local.set $v (i32.and ${bits} (i32.const 63)))
+      (i32.store8 (i32.add (local.get $out) (local.get $j))
+        (select (i32.add (local.get $v) (i32.const 65))
+          (select (i32.add (local.get $v) (i32.const 71))
+            (select (i32.add (local.get $v) (i32.const -4))
+              (select (select (i32.const 45) (i32.const 43) (local.get $url))
+                      (select (i32.const 95) (i32.const 47) (local.get $url))
+                      (i32.eq (local.get $v) (i32.const 62)))
+              (i32.lt_u (local.get $v) (i32.const 62)))
+            (i32.lt_u (local.get $v) (i32.const 52)))
+          (i32.lt_u (local.get $v) (i32.const 26))))
+      (local.set $j (i32.add (local.get $j) (i32.const 1)))`
+
+  wat('__b64_enc', `(func $__b64_enc (param $src i32) (param $len i32) (param $url i32) (param $pad i32) (result f64)
+    (local $g3 i32) (local $rem i32) (local $outLen i32) (local $base i32) (local $out i32)
+    (local $i i32) (local $j i32) (local $w i32) (local $v i32)
+    (local.set $g3 (i32.mul (i32.div_u (local.get $len) (i32.const 3)) (i32.const 3)))
+    (local.set $rem (i32.sub (local.get $len) (local.get $g3)))
+    (local.set $outLen (i32.mul (i32.div_u (local.get $len) (i32.const 3)) (i32.const 4)))
+    (if (local.get $rem)
+      (then (local.set $outLen (i32.add (local.get $outLen)
+        (select (i32.const 4) (i32.add (local.get $rem) (i32.const 1)) (local.get $pad))))))
+    (local.set $base (call $__alloc (i32.add (i32.const 4) (local.get $outLen))))
+    (local.set $out (i32.add (local.get $base) (i32.const 4)))
+    (block $gdone (loop $gloop
+      (br_if $gdone (i32.ge_u (local.get $i) (local.get $g3)))
+      (local.set $w (i32.or (i32.or
+        (i32.shl (i32.load8_u (i32.add (local.get $src) (local.get $i))) (i32.const 16))
+        (i32.shl (i32.load8_u (i32.add (local.get $src) (i32.add (local.get $i) (i32.const 1)))) (i32.const 8)))
+        (i32.load8_u (i32.add (local.get $src) (i32.add (local.get $i) (i32.const 2))))))
+      ${b64put('(i32.shr_u (local.get $w) (i32.const 18))')}
+      ${b64put('(i32.shr_u (local.get $w) (i32.const 12))')}
+      ${b64put('(i32.shr_u (local.get $w) (i32.const 6))')}
+      ${b64put('(local.get $w)')}
+      (local.set $i (i32.add (local.get $i) (i32.const 3)))
+      (br $gloop)))
+    (if (i32.eq (local.get $rem) (i32.const 1))
+      (then
+        (local.set $w (i32.shl (i32.load8_u (i32.add (local.get $src) (local.get $i))) (i32.const 16)))
+        ${b64put('(i32.shr_u (local.get $w) (i32.const 18))')}
+        ${b64put('(i32.shr_u (local.get $w) (i32.const 12))')}
+        (if (local.get $pad) (then
+          (i32.store8 (i32.add (local.get $out) (local.get $j)) (i32.const 61))
+          (i32.store8 (i32.add (local.get $out) (i32.add (local.get $j) (i32.const 1))) (i32.const 61))
+          (local.set $j (i32.add (local.get $j) (i32.const 2)))))))
+    (if (i32.eq (local.get $rem) (i32.const 2))
+      (then
+        (local.set $w (i32.or
+          (i32.shl (i32.load8_u (i32.add (local.get $src) (local.get $i))) (i32.const 16))
+          (i32.shl (i32.load8_u (i32.add (local.get $src) (i32.add (local.get $i) (i32.const 1)))) (i32.const 8))))
+        ${b64put('(i32.shr_u (local.get $w) (i32.const 18))')}
+        ${b64put('(i32.shr_u (local.get $w) (i32.const 12))')}
+        ${b64put('(i32.shr_u (local.get $w) (i32.const 6))')}
+        (if (local.get $pad) (then
+          (i32.store8 (i32.add (local.get $out) (local.get $j)) (i32.const 61))
+          (local.set $j (i32.add (local.get $j) (i32.const 1)))))))
+    (i32.store (local.get $base) (local.get $j))
+    (call $__sso_norm (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $out))))`)
+
+  // Forgiving decode. Returns (read << 32) | written; read = chars consumed
+  // (== full length unless the $cap byte budget stopped a chunk; then the
+  // stopped chunk's start). Throws on: a non-alphabet char, len%4==1,
+  // misplaced/unterminated padding, content after complete padding.
+  wat('__b64_dec_raw', `(func $__b64_dec_raw (param $s i64) (param $dst i32) (param $cap i32) (param $url i32) (result i64)
+    (local $slen i32) (local $i i32) (local $c i32) (local $v i32)
+    (local $acc i32) (local $cnt i32) (local $pads i32) (local $done i32)
+    (local $mark i32) (local $written i32) (local $stopped i32) (local $n i32)
+    (local.set $slen (call $__str_byteLen (local.get $s)))
+    (block $stop (loop $loop
+      (br_if $stop (i32.ge_s (local.get $i) (local.get $slen)))
+      (local.set $c (call $__char_at (local.get $s) (local.get $i)))
+      ;; ASCII whitespace (tab LF FF CR space) skipped everywhere
+      (if (i32.or
+            (i32.or (i32.eq (local.get $c) (i32.const 9)) (i32.eq (local.get $c) (i32.const 10)))
+            (i32.or
+              (i32.or (i32.eq (local.get $c) (i32.const 12)) (i32.eq (local.get $c) (i32.const 13)))
+              (i32.eq (local.get $c) (i32.const 32))))
+        (then
+          (local.set $i (i32.add (local.get $i) (i32.const 1)))
+          (br $loop)))
+      ;; after complete padding only whitespace may follow
+      (if (local.get $done) (then (throw $__jz_err (f64.const 0))))
+      (if (i32.eq (local.get $c) (i32.const 61)) ;; '='
+        (then
+          (if (i32.lt_s (local.get $cnt) (i32.const 2)) (then (throw $__jz_err (f64.const 0))))
+          (local.set $pads (i32.add (local.get $pads) (i32.const 1)))
+          (if (i32.eq (i32.add (local.get $cnt) (local.get $pads)) (i32.const 4))
+            (then ;; flush the padded partial chunk: 2 chars → 1 byte, 3 → 2
+              (local.set $n (i32.sub (local.get $cnt) (i32.const 1)))
+              (if (i32.gt_s (i32.add (local.get $written) (local.get $n)) (local.get $cap))
+                (then (local.set $stopped (i32.const 1)) (br $stop)))
+              (i32.store8 (i32.add (local.get $dst) (local.get $written))
+                (i32.and (i32.shr_u (local.get $acc)
+                  (select (i32.const 10) (i32.const 4) (i32.eq (local.get $cnt) (i32.const 3)))) (i32.const 255)))
+              (if (i32.eq (local.get $cnt) (i32.const 3))
+                (then (i32.store8 (i32.add (local.get $dst) (i32.add (local.get $written) (i32.const 1)))
+                  (i32.and (i32.shr_u (local.get $acc) (i32.const 2)) (i32.const 255)))))
+              (local.set $written (i32.add (local.get $written) (local.get $n)))
+              (local.set $mark (i32.add (local.get $i) (i32.const 1)))
+              (local.set $cnt (i32.const 0))
+              (local.set $acc (i32.const 0))
+              (local.set $done (i32.const 1)))))
+        (else
+          ;; a value char while padding is open ("AB=C") is malformed
+          (if (local.get $pads) (then (throw $__jz_err (f64.const 0))))
+          (local.set $v (i32.const -1))
+          (if (i32.and (i32.ge_u (local.get $c) (i32.const 65)) (i32.le_u (local.get $c) (i32.const 90)))
+            (then (local.set $v (i32.sub (local.get $c) (i32.const 65)))))
+          (if (i32.and (i32.ge_u (local.get $c) (i32.const 97)) (i32.le_u (local.get $c) (i32.const 122)))
+            (then (local.set $v (i32.sub (local.get $c) (i32.const 71)))))
+          (if (i32.and (i32.ge_u (local.get $c) (i32.const 48)) (i32.le_u (local.get $c) (i32.const 57)))
+            (then (local.set $v (i32.add (local.get $c) (i32.const 4)))))
+          (if (local.get $url)
+            (then
+              (if (i32.eq (local.get $c) (i32.const 45)) (then (local.set $v (i32.const 62))))
+              (if (i32.eq (local.get $c) (i32.const 95)) (then (local.set $v (i32.const 63)))))
+            (else
+              (if (i32.eq (local.get $c) (i32.const 43)) (then (local.set $v (i32.const 62))))
+              (if (i32.eq (local.get $c) (i32.const 47)) (then (local.set $v (i32.const 63))))))
+          (if (i32.lt_s (local.get $v) (i32.const 0)) (then (throw $__jz_err (f64.const 0))))
+          (local.set $acc (i32.or (i32.shl (local.get $acc) (i32.const 6)) (local.get $v)))
+          (local.set $cnt (i32.add (local.get $cnt) (i32.const 1)))
+          (if (i32.eq (local.get $cnt) (i32.const 4))
+            (then
+              (if (i32.gt_s (i32.add (local.get $written) (i32.const 3)) (local.get $cap))
+                (then (local.set $stopped (i32.const 1)) (br $stop)))
+              (i32.store8 (i32.add (local.get $dst) (local.get $written))
+                (i32.shr_u (local.get $acc) (i32.const 16)))
+              (i32.store8 (i32.add (local.get $dst) (i32.add (local.get $written) (i32.const 1)))
+                (i32.and (i32.shr_u (local.get $acc) (i32.const 8)) (i32.const 255)))
+              (i32.store8 (i32.add (local.get $dst) (i32.add (local.get $written) (i32.const 2)))
+                (i32.and (local.get $acc) (i32.const 255)))
+              (local.set $written (i32.add (local.get $written) (i32.const 3)))
+              (local.set $mark (i32.add (local.get $i) (i32.const 1)))
+              (local.set $cnt (i32.const 0))
+              (local.set $acc (i32.const 0))))))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (br $loop)))
+    ;; EOF: unterminated padding ("AA=") is malformed; a padless partial chunk
+    ;; is the loose case — 1 leftover char is len%4==1 (malformed), 2 → 1 byte,
+    ;; 3 → 2 bytes, extra bits ignored.
+    (if (i32.eqz (local.get $stopped))
+      (then
+        (if (i32.and (i32.ne (local.get $pads) (i32.const 0)) (i32.eqz (local.get $done)))
+          (then (throw $__jz_err (f64.const 0))))
+        (if (i32.eq (local.get $cnt) (i32.const 1)) (then (throw $__jz_err (f64.const 0))))
+        (if (i32.gt_s (local.get $cnt) (i32.const 1))
+          (then
+            (local.set $n (i32.sub (local.get $cnt) (i32.const 1)))
+            (if (i32.gt_s (i32.add (local.get $written) (local.get $n)) (local.get $cap))
+              (then (local.set $stopped (i32.const 1)))
+              (else
+                (i32.store8 (i32.add (local.get $dst) (local.get $written))
+                  (i32.and (i32.shr_u (local.get $acc)
+                    (select (i32.const 10) (i32.const 4) (i32.eq (local.get $cnt) (i32.const 3)))) (i32.const 255)))
+                (if (i32.eq (local.get $cnt) (i32.const 3))
+                  (then (i32.store8 (i32.add (local.get $dst) (i32.add (local.get $written) (i32.const 1)))
+                    (i32.and (i32.shr_u (local.get $acc) (i32.const 2)) (i32.const 255)))))
+                (local.set $written (i32.add (local.get $written) (local.get $n)))
+                (local.set $mark (local.get $slen))))))))
+    (i64.or
+      (i64.shl (i64.extend_i32_u (select (local.get $mark) (local.get $slen) (local.get $stopped))) (i64.const 32))
+      (i64.extend_i32_u (local.get $written))))`)
+
+  // Uint8Array receiver guard → data offset. u8-only per spec (TypeError otherwise).
+  wat('__u8_data', `(func $__u8_data (param $ptr i64) (result i32)
+    (if (i32.or
+          (i32.ne (call $__ptr_type (local.get $ptr)) (i32.const ${PTR.TYPED}))
+          (i32.ne (i32.and (call $__ptr_aux (local.get $ptr)) (i32.const 7)) (i32.const 1)))
+      (then (throw $__jz_err (f64.const 0))))
+    (call $__typed_data (local.get $ptr)))`)
+
+  wat('__btoa', `(func $__btoa (param $v i64) (result f64)
+    (local $s i64) (local $len i32) (local $buf i32)
+    (local.set $s (call $__to_str (local.get $v)))
+    (local.set $len (call $__str_byteLen (local.get $s)))
+    (local.set $buf (call $__alloc (local.get $len)))
+    (call $__str_copy (local.get $s) (local.get $buf) (local.get $len))
+    (call $__b64_enc (local.get $buf) (local.get $len) (i32.const 0) (i32.const 1)))`)
+
+  wat('__atob', `(func $__atob (param $v i64) (result f64)
+    (local $s i64) (local $max i32) (local $base i32) (local $rw i64)
+    (local.set $s (call $__to_str (local.get $v)))
+    (local.set $max (i32.add (i32.mul (i32.add (i32.shr_u (call $__str_byteLen (local.get $s)) (i32.const 2)) (i32.const 1)) (i32.const 3)) (i32.const 3)))
+    (local.set $base (call $__alloc (i32.add (i32.const 4) (local.get $max))))
+    (local.set $rw (call $__b64_dec_raw (local.get $s) (i32.add (local.get $base) (i32.const 4)) (i32.const 2147483647) (i32.const 0)))
+    (i32.store (local.get $base) (i32.wrap_i64 (local.get $rw)))
+    (call $__sso_norm (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (i32.add (local.get $base) (i32.const 4)))))`)
+
+  wat('__b64_from', `(func $__b64_from (param $v i64) (param $url i32) (result f64)
+    (local $s i64) (local $max i32) (local $base i32) (local $rw i64) (local $n i32)
+    (local.set $s (call $__to_str (local.get $v)))
+    (local.set $max (i32.add (i32.mul (i32.add (i32.shr_u (call $__str_byteLen (local.get $s)) (i32.const 2)) (i32.const 1)) (i32.const 3)) (i32.const 3)))
+    (local.set $base (call $__alloc (i32.add (i32.const 8) (local.get $max))))
+    (local.set $rw (call $__b64_dec_raw (local.get $s) (i32.add (local.get $base) (i32.const 8)) (i32.const 2147483647) (local.get $url)))
+    (local.set $n (i32.wrap_i64 (local.get $rw)))
+    (i32.store (local.get $base) (local.get $n))
+    (i32.store (i32.add (local.get $base) (i32.const 4)) (local.get $n))
+    (call $__mkptr (i32.const ${PTR.TYPED}) (i32.const 1) (i32.add (local.get $base) (i32.const 8))))`)
+
+  wat('__b64_set', `(func $__b64_set (param $dst i64) (param $s i64) (param $url i32) (result i64)
+    (call $__b64_dec_raw (local.get $s)
+      (call $__u8_data (local.get $dst))
+      (call $__len (local.get $dst))
+      (local.get $url)))`)
+
+  wat('__hex_enc', `(func $__hex_enc (param $src i32) (param $len i32) (result f64)
+    (local $base i32) (local $out i32) (local $i i32) (local $b i32) (local $n i32)
+    (local.set $base (call $__alloc (i32.add (i32.const 4) (i32.shl (local.get $len) (i32.const 1)))))
+    (local.set $out (i32.add (local.get $base) (i32.const 4)))
+    (block $d (loop $l
+      (br_if $d (i32.ge_u (local.get $i) (local.get $len)))
+      (local.set $b (i32.load8_u (i32.add (local.get $src) (local.get $i))))
+      (local.set $n (i32.shr_u (local.get $b) (i32.const 4)))
+      (i32.store8 (i32.add (local.get $out) (i32.shl (local.get $i) (i32.const 1)))
+        (select (i32.add (local.get $n) (i32.const 87)) (i32.add (local.get $n) (i32.const 48)) (i32.gt_u (local.get $n) (i32.const 9))))
+      (local.set $n (i32.and (local.get $b) (i32.const 15)))
+      (i32.store8 (i32.add (i32.add (local.get $out) (i32.shl (local.get $i) (i32.const 1))) (i32.const 1))
+        (select (i32.add (local.get $n) (i32.const 87)) (i32.add (local.get $n) (i32.const 48)) (i32.gt_u (local.get $n) (i32.const 9))))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (br $l)))
+    (i32.store (local.get $base) (i32.shl (local.get $len) (i32.const 1)))
+    (call $__sso_norm (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $out))))`)
+
+  // Hex decode: strict per spec — no whitespace, both nibble cases, odd length
+  // or a non-hex char throw. Stops at $cap whole bytes (setFromHex).
+  wat('__hex_dec_raw', `(func $__hex_dec_raw (param $s i64) (param $dst i32) (param $cap i32) (result i64)
+    (local $slen i32) (local $i i32) (local $hi i32) (local $lo i32) (local $written i32)
+    (local.set $slen (call $__str_byteLen (local.get $s)))
+    (if (i32.and (local.get $slen) (i32.const 1)) (then (throw $__jz_err (f64.const 0))))
+    (block $stop (loop $l
+      (br_if $stop (i32.ge_s (local.get $i) (local.get $slen)))
+      (br_if $stop (i32.ge_s (local.get $written) (local.get $cap)))
+      (local.set $hi (call $__uri_hex (call $__char_at (local.get $s) (local.get $i))))
+      (local.set $lo (call $__uri_hex (call $__char_at (local.get $s) (i32.add (local.get $i) (i32.const 1)))))
+      (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))))
+      (i32.store8 (i32.add (local.get $dst) (local.get $written))
+        (i32.or (i32.shl (local.get $hi) (i32.const 4)) (local.get $lo)))
+      (local.set $written (i32.add (local.get $written) (i32.const 1)))
+      (local.set $i (i32.add (local.get $i) (i32.const 2)))
+      (br $l)))
+    (i64.or (i64.shl (i64.extend_i32_u (local.get $i)) (i64.const 32))
+      (i64.extend_i32_u (local.get $written))))`)
+
+  wat('__hex_from', `(func $__hex_from (param $v i64) (result f64)
+    (local $s i64) (local $base i32) (local $rw i64) (local $n i32)
+    (local.set $s (call $__to_str (local.get $v)))
+    (local.set $base (call $__alloc (i32.add (i32.const 8) (i32.shr_u (call $__str_byteLen (local.get $s)) (i32.const 1)))))
+    (local.set $rw (call $__hex_dec_raw (local.get $s) (i32.add (local.get $base) (i32.const 8)) (i32.const 2147483647)))
+    (local.set $n (i32.wrap_i64 (local.get $rw)))
+    (i32.store (local.get $base) (local.get $n))
+    (i32.store (i32.add (local.get $base) (i32.const 4)) (local.get $n))
+    (call $__mkptr (i32.const ${PTR.TYPED}) (i32.const 1) (i32.add (local.get $base) (i32.const 8))))`)
+
+  wat('__hex_set', `(func $__hex_set (param $dst i64) (param $s i64) (result i64)
+    (call $__hex_dec_raw (local.get $s)
+      (call $__u8_data (local.get $dst))
+      (call $__len (local.get $dst))))`)
+
+  // btoa(s): base64 of the string's bytes. jz strings ARE bytes, so every char
+  // qualifies — JS's InvalidCharacterError for >0xFF code units cannot arise;
+  // non-ASCII text encodes its UTF-8 bytes (documented byte-string divergence).
+  bind('btoa', (value) => {
+    inc('__btoa')
+    return typed(['call', '$__btoa',
+      value === undefined ? ['i64.const', UNDEF_NAN] : asI64(emit(value))], 'f64')
+  })
+
+  // atob(b64): decoded bytes as a byte-string — charCodeAt(i) reads the byte,
+  // exactly what JS binary-string consumers observe.
+  bind('atob', (value) => {
+    ctx.runtime.throws = true
+    inc('__atob')
+    return typed(['call', '$__atob',
+      value === undefined ? ['i64.const', UNDEF_NAN] : asI64(emit(value))], 'f64')
+  })
 }

package/module/timer.js

@@ -28,7 +28,7 @@
 
 import { typed, asF64, asI64, UNDEF_NAN, MAX_CLOSURE_ARITY, temp, tempI64 } from '../src/ir.js'
 import { emit, deps, hostImport } from '../src/bridge.js'
-import { inc, PTR, LAYOUT, declGlobal } from '../src/ctx.js'
+import { inc, err, PTR, LAYOUT, declGlobal } from '../src/ctx.js'
 
 const MAX_TIMERS = 64
 const ENTRY_SIZE = 40
@@ -46,6 +46,19 @@ const invokeClosureFn = (exported) => `(func $__invoke_closure${exported ? ' (ex
       (i64.shr_u (local.get $clos) (i64.const ${LAYOUT.AUX_SHIFT}))
       (i64.const ${LAYOUT.AUX_MASK})))))`
 
+// One-arg variant: first $ftN slot carries a real f64 (the rAF timestamp),
+// the rest pad UNDEF_NAN. Exported so the host frame loop can pass the
+// DOMHighResTimeStamp through to the callback.
+const invokeClosure1Fn = (exported) => `(func $__invoke_closure1${exported ? ' (export "__invoke_closure1")' : ''} (param $clos i64) (param $a0 f64) (result f64)
+  (call_indirect (type \$ftN)
+    (f64.reinterpret_i64 (local.get $clos))
+    (i32.const 0)
+    (local.get $a0)
+    ${Array.from({length: MAX_CLOSURE_ARITY - 1}, () => `(f64.const nan:${UNDEF_NAN})`).join('\n    ')}
+    (i32.wrap_i64 (i64.and
+      (i64.shr_u (local.get $clos) (i64.const ${LAYOUT.AUX_SHIFT}))
+      (i64.const ${LAYOUT.AUX_MASK})))))`
+
 const setupWasi = (ctx) => {
   // Always include init + tick + loop when timer module loads (structural, not per-emitter)
   inc('__timer_init', '__timer_tick', '__timer_loop')
@@ -263,6 +276,14 @@ const setupWasi = (ctx) => {
     inc('__timer_cancel')
     return typed(['call', '$__timer_cancel', asF64(emit(idExpr))], 'f64')
   }
+
+  // rAF is a display-loop service — it has no WASI meaning (and warning +
+  // declaring env.* here would break the one-import-namespace shape). Reject
+  // with the architecture that DOES work standalone: the embedder owns the
+  // frame loop and calls an exported step per frame.
+  const noWasiRaf = () => err(`requestAnimationFrame needs a JS host (host:'js') — under wasi export a per-frame function and drive it from the embedder's loop`)
+  ctx.core.emit['requestAnimationFrame'] = noWasiRaf
+  ctx.core.emit['cancelAnimationFrame'] = noWasiRaf
 }
 
 const setupJsHost = (ctx) => {
@@ -298,6 +319,26 @@ const setupJsHost = (ctx) => {
   }
   ctx.core.emit['clearTimeout'] = emitClear
   ctx.core.emit['clearInterval'] = emitClear
+
+  // requestAnimationFrame(cb) / cancelAnimationFrame(id) — the same env-service
+  // shape as setTimeout: the host schedules (real rAF in browsers, a 16 ms
+  // timer fallback elsewhere — interop.js) and fires the callback through the
+  // exported __invoke_closure1 trampoline with the frame timestamp.
+  const needRaf = () => hostImport('env', 'requestAnimationFrame',
+    ['func', '$__raf', ['param', 'i64'], ['result', 'f64']])
+  const needCancelRaf = () => hostImport('env', 'cancelAnimationFrame',
+    ['func', '$__craf', ['param', 'f64'], ['result', 'f64']])
+  ctx.core.stdlib['__invoke_closure1'] = invokeClosure1Fn(true)
+
+  ctx.core.emit['requestAnimationFrame'] = (cbExpr) => {
+    needRaf()
+    inc('__invoke_closure1')
+    return typed(['call', '$__raf', ['i64.reinterpret_f64', asF64(emit(cbExpr))]], 'f64')
+  }
+  ctx.core.emit['cancelAnimationFrame'] = (idExpr) => {
+    needCancelRaf()
+    return typed(['call', '$__craf', asF64(emit(idExpr))], 'f64')
+  }
 }
 
 export default (ctx) => {