@mentra/crust 3.4.0-dev.960 → 3.4.0-dev.965

package/android/build.gradle

@@ -149,6 +149,15 @@ dependencies {
 dependencies {
   testImplementation 'junit:junit:4.13.2'
   testImplementation 'org.robolectric:robolectric:4.11.1'
+  // Local HTTP server for the miniapp fetch bridge tests; matches okhttp above.
+  testImplementation 'com.squareup.okhttp3:mockwebserver:4.12.0'
+}
+
+// Robolectric loads classes, and so QuickJS's JNI library, in its own sandbox
+// class loader. Plain JUnit QuickJS tests in the same JVM then crash inside
+// JNI, so every test class runs in a fresh JVM.
+tasks.withType(Test).configureEach {
+  forkEvery = 1
 }
 
 // A desktop JVM cannot load the Android QuickJS library, so local unit tests

package/android/src/main/java/com/mentra/crust/jsc/JSCPolyfillBridge.kt

@@ -2,6 +2,8 @@ package com.mentra.crust.jsc
 
 import android.util.Log
 import java.io.IOException
+import java.nio.ByteBuffer
+import java.nio.charset.CharacterCodingException
 import okhttp3.MediaType.Companion.toMediaTypeOrNull
 import okhttp3.OkHttpClient
 import okhttp3.Request
@@ -12,6 +14,7 @@ import okhttp3.Callback
 import okhttp3.WebSocket
 import okhttp3.WebSocketListener
 import okio.ByteString
+import okio.ByteString.Companion.decodeBase64
 import okio.ByteString.Companion.toByteString
 import org.json.JSONObject
 import org.json.JSONArray
@@ -46,15 +49,23 @@ object JSCPolyfillBridge {
     }
 
     /** Keep host HTTP and miniapp fetch body semantics identical, including empty POSTs. */
-    internal fun buildHttpRequest(method: String, url: String, headers: Map<String, String>, bodyString: String?): Request {
+    internal fun buildHttpRequest(
+        method: String,
+        url: String,
+        headers: Map<String, String>,
+        bodyString: String?,
+        bodyBytes: ByteString? = null,
+    ): Request {
         val builder = Request.Builder().url(url)
         for ((name, value) in headers) builder.header(name, value)
         val contentType = headers.entries
             .firstOrNull { (name, _) -> name.equals("content-type", ignoreCase = true) }
             ?.value
+        val mediaType = (contentType ?: "application/octet-stream").toMediaTypeOrNull()
         val upperMethod = method.uppercase()
         val requestBody = when {
-            bodyString != null -> bodyString.toRequestBody((contentType ?: "application/octet-stream").toMediaTypeOrNull())
+            bodyBytes != null -> bodyBytes.toRequestBody(mediaType)
+            bodyString != null -> bodyString.toRequestBody(mediaType)
             upperMethod == "POST" || upperMethod == "PUT" || upperMethod == "PATCH" -> "".toRequestBody(null)
             else -> null
         }
@@ -62,6 +73,49 @@ object JSCPolyfillBridge {
         return builder.build()
     }
 
+    /**
+     * The `result` of a `fetch.request` response envelope. The body is sent
+     * as the string `body` only when its bytes are exactly that string's
+     * UTF-8 encoding, and as `bodyBase64` otherwise, so binary bodies keep
+     * every byte. The JS polyfill decodes base64 bodies and applies UTF-8 rules.
+     */
+    internal fun fetchResult(response: Response): JSONObject {
+        val headerMap = mutableMapOf<String, String>()
+        for (name in response.headers.names()) {
+            headerMap[name.lowercase()] = response.headers.values(name).joinToString(", ")
+        }
+        val body = try {
+            response.body?.bytes() ?: ByteArray(0)
+        } catch (e: Throwable) {
+            Log.w(TAG, "fetch read body threw: ${e.message}")
+            ByteArray(0)
+        }
+        val text = exactUtf8(body)
+        return JSONObject().apply {
+            put("status", response.code)
+            put("statusText", response.message)
+            put("headers", JSONObject(headerMap as Map<*, *>))
+            if (text != null) {
+                put("body", text)
+            } else {
+                put("bodyBase64", body.toByteString().base64())
+            }
+            put("ok", response.code in 200..299)
+        }
+    }
+
+    /** [bytes] as a String when they are exactly its UTF-8 encoding, else null. */
+    private fun exactUtf8(bytes: ByteArray): String? {
+        // A new decoder reports malformed input, so binary fails at its first invalid byte.
+        val text = try {
+            Charsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString()
+        } catch (_: CharacterCodingException) {
+            return null
+        }
+        // Re-encoding proves the round trip even if a decoder lets an unpaired surrogate through.
+        return text.takeIf { it.toByteArray(Charsets.UTF_8).contentEquals(bytes) }
+    }
+
     /** Idempotent. Call once on host boot, after the dispatcher is created. */
     fun install(runtime: JSCRuntime) {
         installFetch(runtime)
@@ -201,8 +255,12 @@ object JSCPolyfillBridge {
                 ks to vs
             }?.toMap() ?: emptyMap()
             val bodyString = req["body"] as? String
+            val bodyBytes = (req["bodyBase64"] as? String)?.let { encoded ->
+                encoded.decodeBase64()
+                    ?: return@register JSCDispatchOutcome.Error("INVALID_ARGS", "fetch.request: bodyBase64 is not base64")
+            }
 
-            val request = buildHttpRequest(method, url, headers, bodyString)
+            val request = buildHttpRequest(method, url, headers, bodyString, bodyBytes)
 
             httpClient.newCall(request).enqueue(object : Callback {
                 override fun onFailure(call: Call, e: IOException) {
@@ -210,33 +268,14 @@ object JSCPolyfillBridge {
                 }
 
                 override fun onResponse(call: Call, response: Response) {
-                    response.use { r ->
-                        val status = r.code
-                        val statusText = r.message
-                        val headerMap = mutableMapOf<String, String>()
-                        for (name in r.headers.names()) {
-                            headerMap[name.lowercase()] = r.headers.values(name).joinToString(", ")
-                        }
-                        val bodyStr = try {
-                            r.body?.string() ?: ""
-                        } catch (e: Throwable) {
-                            Log.w(TAG, "fetch read body threw: ${e.message}")
-                            ""
-                        }
-                        val envelope = JSONObject().apply {
-                            put("kind", "response")
-                            put("reqId", reqId)
-                            put("ok", true)
-                            put("result", JSONObject().apply {
-                                put("status", status)
-                                put("statusText", statusText)
-                                put("headers", JSONObject(headerMap as Map<*, *>))
-                                put("body", bodyStr)
-                                put("ok", status in 200..299)
-                            })
-                        }
-                        runtime.dispatchToJs(packageName, envelope.toString())
+                    val result = response.use { fetchResult(it) }
+                    val envelope = JSONObject().apply {
+                        put("kind", "response")
+                        put("reqId", reqId)
+                        put("ok", true)
+                        put("result", result)
                     }
+                    runtime.dispatchToJs(packageName, envelope.toString())
                 }
             })
             JSCDispatchOutcome.Async

package/android/src/test/java/com/mentra/crust/jsc/FetchBridgeTest.kt

@@ -0,0 +1,199 @@
+package com.mentra.crust.jsc
+
+import java.io.File
+import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.TimeUnit
+import kotlin.math.PI
+import kotlin.math.roundToInt
+import kotlin.math.sin
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.Protocol
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.ResponseBody.Companion.toResponseBody
+import okhttp3.mockwebserver.Dispatcher
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.RecordedRequest
+import okio.Buffer
+import okio.ByteString.Companion.decodeBase64
+import org.junit.After
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+
+/**
+ * Miniapp `fetch` end to end on Android's real stack: the shipped startup.js
+ * polyfill in QuickJS, [JSCRuntime]'s dispatcher and `__deliver` path, this
+ * bridge, and OkHttp against a local server. Each miniapp script reports
+ * through a `test` dispatch, which the runtime forwards to `onOutbound`.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [28], manifest = Config.NONE)
+class FetchBridgeTest {
+    private val packageName = "com.mentra.fetchtest"
+    private val results = LinkedBlockingQueue<Map<*, *>>()
+    private lateinit var server: MockWebServer
+    private lateinit var runtime: JSCRuntime
+
+    /** A 24 kHz 16-bit sine followed by every byte value: mostly not valid UTF-8. */
+    private val pcm = ByteArray(4800 * 2 + 256).also { out ->
+        for (i in 0 until 4800) {
+            val sample = (sin(2 * PI * 220 * i / 24000) * 20000).roundToInt()
+            out[2 * i] = sample.toByte()
+            out[2 * i + 1] = (sample shr 8).toByte()
+        }
+        for (value in 0 until 256) out[9600 + value] = value.toByte()
+    }
+
+    /** Valid UTF-8 that is still binary data: a BOM, NUL and DEL must all survive. */
+    private val utf8Bytes = byteArrayOf(0xEF.toByte(), 0xBB.toByte(), 0xBF.toByte()) +
+        "{\"a\":\"é😀\"}".toByteArray(Charsets.UTF_8) + byteArrayOf(0x00, 0x7F)
+
+    // crust's build.gradle ships this file as the runtime's startup.js asset.
+    private val polyfill: String by lazy { File("../../jspolyfill/assets/startup.js").readText() }
+
+    @Before fun setUp() {
+        server = MockWebServer().apply {
+            dispatcher = object : Dispatcher() {
+                override fun dispatch(request: RecordedRequest): MockResponse = when (request.path) {
+                    "/reply.pcm" -> response("application/octet-stream").setBody(Buffer().write(pcm))
+                    "/utf8.bin" -> response("application/octet-stream").setBody(Buffer().write(utf8Bytes))
+                    "/data.json" -> response("application/json").setBody("{\"message\":\"héllo 😀 中文\"}")
+                    "/upload" -> response("text/plain").setBody("ok")
+                    else -> MockResponse().setResponseCode(404)
+                }
+            }
+            start()
+        }
+        runtime = JSCRuntime.shared(RuntimeEnvironment.getApplication())
+        JSCPolyfillBridge.install(runtime)
+        runtime.onOutbound = { message ->
+            if (message.payload["iface"] == "test") {
+                results.add((message.payload["args"] as List<*>).first() as Map<*, *>)
+            }
+        }
+    }
+
+    @After fun tearDown() {
+        runtime.kill(packageName)
+        runtime.onOutbound = null
+        server.shutdown()
+    }
+
+    @Test fun `arrayBuffer returns the exact bytes of a binary response`() {
+        val result = runMiniapp(
+            """
+            const response = await fetch(BASE + "/reply.pcm")
+            const bytes = new Uint8Array(await response.arrayBuffer())
+            return {status: response.status, type: response.headers.get("content-type"), bytes: Array.from(bytes)}
+            """,
+        )
+        assertEquals(200, result["status"])
+        assertEquals("application/octet-stream", result["type"])
+        assertArrayEquals(pcm, bytes(result["bytes"]))
+    }
+
+    @Test fun `arrayBuffer returns the exact bytes of a body that is valid UTF-8`() {
+        val result = runMiniapp(
+            """
+            const response = await fetch(BASE + "/utf8.bin")
+            return {bytes: Array.from(new Uint8Array(await response.arrayBuffer()))}
+            """,
+        )
+        assertArrayEquals(utf8Bytes, bytes(result["bytes"]))
+    }
+
+    @Test fun `responses are sent as text only when that text re-encodes to the same bytes`() {
+        val text = JSCPolyfillBridge.fetchResult(responseWith(utf8Bytes))
+        assertEquals(String(utf8Bytes, Charsets.UTF_8), text.getString("body"))
+        assertFalse(text.has("bodyBase64"))
+
+        val empty = JSCPolyfillBridge.fetchResult(responseWith(ByteArray(0)))
+        assertEquals("", empty.getString("body"))
+
+        // Truncated, overlong, surrogate and out-of-range sequences, then raw PCM.
+        for (binary in listOf(byteArrayOf(0x41, 0xE2.toByte(), 0x82.toByte()), byteArrayOf(0xC0.toByte(), 0x80.toByte()),
+            byteArrayOf(0xED.toByte(), 0xA0.toByte(), 0x80.toByte()), byteArrayOf(0xF4.toByte(), 0x90.toByte(), 0x80.toByte(), 0x80.toByte()), pcm)) {
+            val result = JSCPolyfillBridge.fetchResult(responseWith(binary))
+            assertFalse(result.has("body"))
+            assertArrayEquals(binary, result.getString("bodyBase64").decodeBase64()!!.toByteArray())
+        }
+    }
+
+    @Test fun `text and json decode a UTF-8 response`() {
+        val result = runMiniapp(
+            """
+            const text = await (await fetch(BASE + "/data.json")).text()
+            const json = await (await fetch(BASE + "/data.json")).json()
+            return {text, message: json.message}
+            """,
+        )
+        assertEquals("{\"message\":\"héllo 😀 中文\"}", result["text"])
+        assertEquals("héllo 😀 中文", result["message"])
+    }
+
+    @Test fun `binary request bodies reach the server byte for byte`() {
+        val result = runMiniapp(
+            """
+            const backing = Uint8Array.from({length: 600}, (_, i) => (i * 37 + 11) & 255)
+            const response = await fetch(BASE + "/upload", {
+              method: "POST",
+              headers: {"Content-Type": "audio/L16; rate=24000"},
+              body: backing.subarray(44),
+            })
+            return {status: response.status, text: await response.text()}
+            """,
+        )
+        assertEquals(200, result["status"])
+        assertEquals("ok", result["text"])
+        val upload = server.takeRequest()
+        val expected = ByteArray(600) { ((it * 37 + 11) and 255).toByte() }.copyOfRange(44, 600)
+        assertArrayEquals(expected, upload.body.readByteArray())
+        assertEquals("audio/L16; rate=24000", upload.getHeader("Content-Type"))
+    }
+
+    @Test fun `string request bodies keep their UTF-8 text and content type`() {
+        runMiniapp(
+            """
+            await fetch(BASE + "/upload", {method: "POST", headers: {"Content-Type": "application/json"}, body: '{"t":"é😀"}'})
+            return {}
+            """,
+        )
+        val upload = server.takeRequest()
+        assertEquals("{\"t\":\"é😀\"}", upload.body.readUtf8())
+        assertEquals("application/json; charset=utf-8", upload.getHeader("Content-Type"))
+    }
+
+    private fun runMiniapp(body: String): Map<*, *> {
+        val script =
+            """
+            const BASE = "${server.url("/").toString().removeSuffix("/")}"
+            const report = (value) => __mentraSendOneShot("test", "result", [value])
+            ;(async () => {
+              $body
+            })().then(report, (error) => report({error: String(error && (error.message || error))}))
+            """.trimIndent()
+        assertTrue("spawn failed", runtime.spawn(packageName, polyfill, script))
+        val result = results.poll(15, TimeUnit.SECONDS) ?: throw AssertionError("miniapp did not report a result")
+        assertNull("miniapp script threw", result["error"])
+        return result
+    }
+
+    private fun bytes(value: Any?): ByteArray =
+        (value as List<*>).map { (it as Number).toInt().toByte() }.toByteArray()
+
+    private fun response(contentType: String) = MockResponse().setHeader("Content-Type", contentType)
+
+    private fun responseWith(body: ByteArray): Response = Response.Builder()
+        .request(Request.Builder().url("https://example.com/body").build())
+        .protocol(Protocol.HTTP_1_1)
+        .code(200)
+        .message("OK")
+        .body(body.toResponseBody("application/octet-stream".toMediaType()))
+        .build()
+}

package/ios/Resources/startup.js

@@ -436,6 +436,140 @@
     }
     ;
     g.crypto = cryptoNs;
+    const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    const BASE64_VALUES = new Uint8Array(128).fill(255);
+    for (let i = 0; i < BASE64_ALPHABET.length; i++) BASE64_VALUES[BASE64_ALPHABET.charCodeAt(i)] = i;
+    const CHARS_PER_CHUNK = 8192;
+    function bytesOf(data) {
+      return data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    function bytesToBase64(bytes) {
+      const parts = [];
+      const chars = [];
+      for (let i = 0; i < bytes.length; i += 3) {
+        const b1 = bytes[i];
+        const b2 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+        const b3 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+        chars.push(
+          BASE64_ALPHABET.charCodeAt(b1 >> 2),
+          BASE64_ALPHABET.charCodeAt((b1 & 3) << 4 | b2 >> 4),
+          i + 1 < bytes.length ? BASE64_ALPHABET.charCodeAt((b2 & 15) << 2 | b3 >> 6) : 61,
+          i + 2 < bytes.length ? BASE64_ALPHABET.charCodeAt(b3 & 63) : 61
+        );
+        if (chars.length >= CHARS_PER_CHUNK) {
+          parts.push(String.fromCharCode.apply(null, chars));
+          chars.length = 0;
+        }
+      }
+      parts.push(String.fromCharCode.apply(null, chars));
+      return parts.join("");
+    }
+    function base64ToBytes(base64) {
+      const length = base64.length;
+      if (length % 4 !== 0) throw new TypeError("Invalid base64 from the native bridge");
+      const padding = length === 0 || base64.charCodeAt(length - 1) !== 61 ? 0 : base64.charCodeAt(length - 2) === 61 ? 2 : 1;
+      const out = new Uint8Array(length / 4 * 3 - padding);
+      const unpadded = padding === 0 ? length : length - 4;
+      let codes = 0;
+      let values = 0;
+      let o = 0;
+      for (let i = 0; i < unpadded; i += 4) {
+        const c1 = base64.charCodeAt(i);
+        const c2 = base64.charCodeAt(i + 1);
+        const c3 = base64.charCodeAt(i + 2);
+        const c4 = base64.charCodeAt(i + 3);
+        const v1 = BASE64_VALUES[c1 & 127];
+        const v2 = BASE64_VALUES[c2 & 127];
+        const v3 = BASE64_VALUES[c3 & 127];
+        const v4 = BASE64_VALUES[c4 & 127];
+        codes |= c1 | c2 | c3 | c4;
+        values |= v1 | v2 | v3 | v4;
+        out[o++] = v1 << 2 | v2 >> 4;
+        out[o++] = (v2 & 15) << 4 | v3 >> 2;
+        out[o++] = (v3 & 3) << 6 | v4;
+      }
+      if (padding > 0) {
+        const c1 = base64.charCodeAt(unpadded);
+        const c2 = base64.charCodeAt(unpadded + 1);
+        const c3 = padding === 1 ? base64.charCodeAt(unpadded + 2) : 65;
+        const v1 = BASE64_VALUES[c1 & 127];
+        const v2 = BASE64_VALUES[c2 & 127];
+        const v3 = BASE64_VALUES[c3 & 127];
+        codes |= c1 | c2 | c3;
+        values |= v1 | v2 | v3;
+        out[o++] = v1 << 2 | v2 >> 4;
+        if (padding === 1) out[o++] = (v2 & 15) << 4 | v3 >> 2;
+      }
+      if (codes > 127 || values > 63) throw new TypeError("Invalid base64 from the native bridge");
+      return out;
+    }
+    function decodeUtf8(bytes, fatal, ignoreBOM) {
+      const length = bytes.length;
+      const parts = [];
+      const units = [];
+      let i = !ignoreBOM && length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191 ? 3 : 0;
+      while (i < length) {
+        const asciiStart = i;
+        while (i < length && bytes[i] < 128) i++;
+        if (i > asciiStart) {
+          if (units.length > 0) {
+            parts.push(String.fromCharCode.apply(null, units));
+            units.length = 0;
+          }
+          for (let start = asciiStart; start < i; start += CHARS_PER_CHUNK) {
+            const chunk = bytes.subarray(start, Math.min(i, start + CHARS_PER_CHUNK));
+            parts.push(String.fromCharCode.apply(null, chunk));
+          }
+          if (i >= length) break;
+        }
+        const lead = bytes[i++];
+        let codePoint;
+        let needed;
+        let lower = 128;
+        let upper = 191;
+        if (lead >= 194 && lead <= 223) {
+          needed = 1;
+          codePoint = lead & 31;
+        } else if (lead >= 224 && lead <= 239) {
+          if (lead === 224) lower = 160;
+          if (lead === 237) upper = 159;
+          needed = 2;
+          codePoint = lead & 15;
+        } else if (lead >= 240 && lead <= 244) {
+          if (lead === 240) lower = 144;
+          if (lead === 244) upper = 143;
+          needed = 3;
+          codePoint = lead & 7;
+        } else {
+          needed = -1;
+          codePoint = 0;
+        }
+        while (needed > 0) {
+          const next = i < length ? bytes[i] : -1;
+          if (next < lower || next > upper) break;
+          codePoint = codePoint << 6 | next & 63;
+          lower = 128;
+          upper = 191;
+          needed--;
+          i++;
+        }
+        if (needed !== 0) {
+          if (fatal) throw new TypeError("The encoded data was not valid utf-8");
+          units.push(65533);
+        } else if (codePoint > 65535) {
+          codePoint -= 65536;
+          units.push(55296 + (codePoint >> 10), 56320 + (codePoint & 1023));
+        } else {
+          units.push(codePoint);
+        }
+        if (units.length >= CHARS_PER_CHUNK) {
+          parts.push(String.fromCharCode.apply(null, units));
+          units.length = 0;
+        }
+      }
+      if (units.length > 0) parts.push(String.fromCharCode.apply(null, units));
+      return parts.join("");
+    }
     if (typeof g.TextEncoder !== "function") {
       class TextEncoderPolyfill {
         constructor() {
@@ -476,36 +610,14 @@
     }
     if (typeof g.TextDecoder !== "function") {
       class TextDecoderPolyfill {
-        constructor(encoding = "utf-8") {
+        constructor(encoding = "utf-8", options) {
           this.encoding = encoding;
+          this.fatal = options?.fatal === true;
+          this.ignoreBOM = options?.ignoreBOM === true;
         }
         decode(buffer) {
           if (!buffer) return "";
-          const bytes = buffer instanceof Uint8Array ? buffer : buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-          let out = "";
-          let i = 0;
-          while (i < bytes.length) {
-            const b1 = bytes[i++];
-            let code;
-            if (b1 < 128) {
-              code = b1;
-            } else if (b1 < 192) {
-              code = 65533;
-            } else if (b1 < 224) {
-              code = (b1 & 31) << 6 | bytes[i++] & 63;
-            } else if (b1 < 240) {
-              code = (b1 & 15) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63;
-            } else {
-              code = (b1 & 7) << 18 | (bytes[i++] & 63) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63;
-            }
-            if (code > 65535) {
-              code -= 65536;
-              out += String.fromCharCode(55296 + (code >> 10), 56320 + (code & 1023));
-            } else {
-              out += String.fromCharCode(code);
-            }
-          }
-          return out;
+          return decodeUtf8(bytesOf(buffer), this.fatal, this.ignoreBOM);
         }
       }
       ;
@@ -552,9 +664,12 @@
         const url = typeof input === "string" ? input : input.toString();
         const method = (init?.method ?? "GET").toUpperCase();
         let bodyString = null;
+        let bodyBase64;
         const reqBody = init?.body;
         if (typeof reqBody === "string") {
           bodyString = reqBody;
+        } else if (reqBody instanceof ArrayBuffer || ArrayBuffer.isView(reqBody)) {
+          bodyBase64 = bytesToBase64(bytesOf(reqBody));
         } else if (reqBody && typeof reqBody.toString === "function") {
           bodyString = reqBody.toString();
         }
@@ -578,9 +693,10 @@
         }
         const sendRequest = g.__mentraSendRequest;
         const result = await sendRequest("fetch", "request", [
-          { url, method, headers, body: bodyString }
+          bodyBase64 === void 0 ? { url, method, headers, body: bodyString } : { url, method, headers, bodyBase64 }
         ]);
-        const bodyText = typeof result.body === "string" ? result.body : "";
+        const responseText = typeof result.body === "string" ? result.body : null;
+        const responseBase64 = typeof result.bodyBase64 === "string" ? result.bodyBase64 : "";
         const responseHeaders = new Map(Object.entries(result.headers ?? {}));
         class ResponseLike {
           constructor() {
@@ -597,11 +713,13 @@
             };
           }
           async text() {
-            return bodyText;
+            if (responseText === null) return decodeUtf8(base64ToBytes(responseBase64), false, false);
+            return responseText.charCodeAt(0) === 65279 ? responseText.slice(1) : responseText;
           }
           async json() {
+            const text = await this.text();
             try {
-              return JSON.parse(bodyText);
+              return JSON.parse(text);
             } catch (e) {
               const err = new Error(
                 `Failed to parse JSON response from ${url}: ${e instanceof Error ? e.message : String(e)}`
@@ -611,52 +729,21 @@
             }
           }
           async arrayBuffer() {
+            if (responseText === null) return base64ToBytes(responseBase64).buffer;
             const enc = new g.TextEncoder();
-            return enc.encode(bodyText).buffer;
+            return enc.encode(responseText).buffer;
           }
         }
         return new ResponseLike();
       };
     }
     if (typeof g.WebSocket !== "function") {
-      let bytesToBase642 = function(bytes) {
-        const b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-        let out = "";
-        let i = 0;
-        while (i < bytes.length) {
-          const c1 = bytes[i++];
-          const c2 = i < bytes.length ? bytes[i++] : NaN;
-          const c3 = i < bytes.length ? bytes[i++] : NaN;
-          const e1 = c1 >> 2;
-          const e2 = (c1 & 3) << 4 | (Number.isNaN(c2) ? 0 : c2 >> 4);
-          const e3 = Number.isNaN(c2) ? 64 : (c2 & 15) << 2 | (Number.isNaN(c3) ? 0 : c3 >> 6);
-          const e4 = Number.isNaN(c3) ? 64 : c3 & 63;
-          out += b64[e1] + b64[e2] + (e3 === 64 ? "=" : b64[e3]) + (e4 === 64 ? "=" : b64[e4]);
-        }
-        return out;
-      }, base64ToBytes2 = function(s) {
-        const b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-        const clean = s.replace(/=+$/, "");
-        const out = [];
-        let buf = 0;
-        let bits = 0;
-        for (let i = 0; i < clean.length; i++) {
-          const idx = b64.indexOf(clean[i]);
-          if (idx < 0) continue;
-          buf = buf << 6 | idx;
-          bits += 6;
-          if (bits >= 8) {
-            bits -= 8;
-            out.push(buf >> bits & 255);
-          }
-        }
-        return new Uint8Array(out);
-      }, queueMicrotaskSafe2 = function(fn) {
+      let queueMicrotaskSafe2 = function(fn) {
         const q = g.queueMicrotask;
         if (typeof q === "function") q(fn);
         else g.Promise.resolve().then(fn);
       };
-      var bytesToBase64 = bytesToBase642, base64ToBytes = base64ToBytes2, queueMicrotaskSafe = queueMicrotaskSafe2;
+      var queueMicrotaskSafe = queueMicrotaskSafe2;
       const sockets = /* @__PURE__ */ new Map();
       g.__mentraDeliverWebSocketEvent = (sid, type, payload) => {
         const sock = sockets.get(sid);
@@ -718,8 +805,7 @@
             payload = data;
           } else {
             kind = "binary";
-            const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-            payload = bytesToBase642(bytes);
+            payload = bytesToBase64(bytesOf(data));
           }
           try {
             __dispatch("ws", "send", JSON.stringify([{ sid: this.sid, kind, payload }]));
@@ -752,7 +838,7 @@
           }
           const synth = { type, target: this, ...ev };
           if (type === "message" && ev.kind === "binary" && typeof ev.data === "string") {
-            synth.data = base64ToBytes2(ev.data).buffer;
+            synth.data = base64ToBytes(ev.data).buffer;
           } else if (type === "message" && ev.kind === "text") {
             synth.data = ev.data;
           }

package/ios/Source/JSCPolyfillBridge.swift

@@ -106,7 +106,15 @@ public enum JSCPolyfillBridge {
                     urlRequest.setValue(String(describing: v), forHTTPHeaderField: k)
                 }
             }
-            if let body = req["body"] as? String, !body.isEmpty {
+            // ArrayBuffer and typed-array bodies arrive as base64 of their bytes.
+            if let encoded = req["bodyBase64"] as? String {
+                guard let data = Data(base64Encoded: encoded) else {
+                    return .error(code: "INVALID_ARGS", message: "fetch.request: bodyBase64 is not base64")
+                }
+                if !data.isEmpty {
+                    urlRequest.httpBody = data
+                }
+            } else if let body = req["body"] as? String, !body.isEmpty {
                 urlRequest.httpBody = body.data(using: .utf8)
             }
 
@@ -141,21 +149,27 @@ public enum JSCPolyfillBridge {
                     }
                     return out
                 }()
-                let bodyStr: String = {
-                    guard let data else { return "" }
-                    return String(data: data, encoding: .utf8) ?? ""
-                }()
+                var result: [String: Any] = [
+                    "status": status,
+                    "statusText": HTTPURLResponse.localizedString(forStatusCode: status),
+                    "headers": headersDict,
+                    "ok": (200..<300).contains(status),
+                ]
+                // The string `body` only when the bytes are exactly its UTF-8
+                // encoding; otherwise every byte as base64. The decode fails
+                // on invalid UTF-8, and the round trip also catches a dropped
+                // byte order mark.
+                let body = data ?? Data()
+                if let text = String(data: body, encoding: .utf8), Data(text.utf8) == body {
+                    result["body"] = text
+                } else {
+                    result["bodyBase64"] = body.base64EncodedString()
+                }
                 let payload: [String: Any] = [
                     "kind": "response",
                     "reqId": reqId,
                     "ok": true,
-                    "result": [
-                        "status": status,
-                        "statusText": HTTPURLResponse.localizedString(forStatusCode: status),
-                        "headers": headersDict,
-                        "body": bodyStr,
-                        "ok": (200..<300).contains(status),
-                    ] as [String: Any],
+                    "result": result,
                 ]
                 JSCRuntime.shared.dispatchToJs(packageName: packageName, envelope: payload)
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/crust",
-  "version": "3.4.0-dev.960",
+  "version": "3.4.0-dev.965",
   "description": "Mentra Native Module",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -35,7 +35,7 @@
   "license": "Apache-2.0",
   "homepage": "https://github.com/Mentra-Community/MentraOS/tree/dev/mobile/modules/crust#readme",
   "dependencies": {
-    "@mentra/jspolyfill": "3.4.0-dev.960"
+    "@mentra/jspolyfill": "3.4.0-dev.965"
   },
   "devDependencies": {
     "@expo/config-plugins": ">=8.0.0",