@sproutboat/runtime 0.13.2 → 0.13.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @sproutboat/runtime
 
+## 0.13.3
+
+### Patch Changes
+
+- 733bd9e: Outbound `fetch()` and service-binding responses keep binary bodies intact (baronunread/sproutboat#232). `arrayBuffer()` and `bytes()` on a fetched response used to go through Porffor's `text()`, which the runtime overrides to decode UTF-8, so binary bodies collapsed; they now read the raw bytes. Through the broker, `fetch` and `service.fetch` sent over a v1 frame now get the upstream body as raw bytes in the frame's binary section instead of `TextDecoder` output. v0 frames, which already-deployed sprouts use, are unchanged, and a new sprout talking to an older broker falls back to the previous text behaviour.
+
 ## 0.13.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.13.2",
+  "version": "0.13.3",
   "license": "MIT",
   "type": "module",
   "repository": {

package/src/native-fetch-prelude.js

@@ -655,6 +655,12 @@ function __sbRawBodyResponse(body, init) {
       return decoded;
     };
     resp.json = () => JSON.parse(resp.text());
+    // #232 — Porffor's arrayBuffer() goes through text(), which decodes UTF-8
+    // above and so collapsed a binary body's multi-byte runs. The body already
+    // is the bytes, one char per byte. blob() stays text-based: Porffor's Blob
+    // only holds text and has no arrayBuffer() to read bytes back out of.
+    resp.arrayBuffer = () => __sbBufFrom(body);
+    resp.bytes = () => new Uint8Array(__sbBufFrom(body));
   }
   return resp;
 }
@@ -1584,7 +1590,7 @@ globalThis.__sbInstallBindings = function (target, bindings) {
           if (__sbIsFn(opts.headers.forEach)) opts.headers.forEach((v, k) => headers.push([k, v]));
           else for (const k in opts.headers) headers.push([k, opts.headers[k]]);
         }
-        const r = __sbRpc("service.fetch", {
+        const r = globalThis.__sbFetchUpstream("service.fetch", {
           binding,
           url,
           method: opts.method || "GET",
@@ -1611,7 +1617,7 @@ globalThis.__sbInstallBindings = function (target, bindings) {
         if (__sbIsFn(opts.headers.forEach)) opts.headers.forEach((v, k) => headers.push([k, v]));
         else for (const k in opts.headers) headers.push([k, opts.headers[k]]);
       }
-      const r = __sbRpc("fetch", {
+      const r = globalThis.__sbFetchUpstream("fetch", {
         url,
         method: opts.method || "GET",
         headers,

package/src/r2-object.test.js

@@ -12,7 +12,8 @@ import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
 const src = readFileSync(fileURLToPath(new URL("./native-fetch-prelude.js", import.meta.url)), "utf8");
-const utf8Start = src.indexOf("function __sbFromUtf8(");
+// From __sbBufFrom (raw-body arrayBuffer, #232) through __sbFromUtf8.
+const utf8Start = src.indexOf("function __sbBufFrom(");
 const rawStart = src.indexOf("function __sbRawBodyResponse(");
 const utf8End = rawStart;
 const rawEnd = src.indexOf("function __sbEqCt(");

package/src/transport-broker.js

@@ -391,6 +391,22 @@ globalThis.__sbR2MultipartPut = function (bucket, key, uploadId, partNumber, bod
   return reply;
 };
 
+/**
+ * #232 — outbound / service fetch over a v1 frame, so the body arrives as the
+ * upstream's raw bytes (one char per byte) instead of UTF-8-decoded text. A
+ * broker that predates this answers v1 fetch with the body still in its JSON:
+ * re-encode that to bytes so it matches today's behaviour rather than breaking.
+ */
+globalThis.__sbFetchUpstream = function (op, msg) {
+  const req = { v: 1, id: ++__sbReqId, token: __sbEnv("SB_BROKER_TOKEN"), op };
+  for (const k in msg) req[k] = msg[k];
+  const reply = JSON.parse(__sbCallBin(JSON.stringify(req), ""));
+  if (reply.ok === false) throw new Error("sproutboat " + op + ": " + (reply.error || "failed"));
+  const bytes = __sbTakeBin();
+  reply.body = reply.body != null ? __sbToBytes(reply.body) : bytes;
+  return reply;
+};
+
 /** Static asset metadata stays JSON; the response body uses the v1 byte tail. */
 globalThis.__sbAssetsGet = function (path) {
   const token = __sbEnv("SB_BROKER_TOKEN");

package/src/transport-embedded.js

@@ -2603,6 +2603,11 @@ globalThis.__sbR2MultipartPut = function (bucket, key, uploadId, partNumber, bod
   return { ok: true, part: { partNumber, etag: reply.etag } };
 };
 
+// #232 — the C HTTP client already hands back raw bytes, one char per byte.
+globalThis.__sbFetchUpstream = function (op, msg) {
+  return __sbRpc(op, msg);
+};
+
 globalThis.__sbAssetsGet = function (path) {
   return __sbEmbeddedDispatch({ op: "assets.get", path });
 };