@sproutboat/runtime 0.7.0 → 0.7.1

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @sproutboat/runtime
 
+## 0.7.1
+
+### Patch Changes
+
+- b0c5bbd: Fix #177: `new Response(obj.body)` on an `R2Object` UTF-8-re-encoded raw
+  bytes, corrupting any binary content (each byte 0x80-0xFF doubled on the
+  wire). Added `R2Object.toResponse(init?)`, which serves the bytes
+  unmodified via the same `x-sb-raw-body` marker `__sbRawBodyResponse` already
+  uses for assets/fetch/service-binding responses. Defaults `content-type`
+  from `httpMetadata` and `etag` from `httpEtag` when not set in `init`.
+
 ## 0.7.0
 
 ### Minor Changes

package/package.json

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

package/src/native-fetch-prelude.js

@@ -1117,6 +1117,21 @@ function __sbR2Object(meta, body) {
     obj.json = function () {
       return JSON.parse(obj.text());
     };
+    // #177 — `new Response(obj.body)` UTF-8-re-encodes the raw bytes (they're
+    // a bytestring, same ambiguity #172/#176 exist to resolve): any byte
+    // 0x80-0xFF doubles into two bytes, corrupting binary content on the way
+    // out. `toResponse()` is the fix already used for assets/fetch/service
+    // bindings (`__sbRawBodyResponse`, below) — same reserved x-sb-raw-body
+    // marker, applied here too.
+    obj.toResponse = function (init) {
+      const opts = init || {};
+      const headers = new Headers(opts.headers || {});
+      headers.set("x-sb-raw-body", "1");
+      if (!headers.has("content-type") && obj.httpMetadata.contentType)
+        headers.set("content-type", obj.httpMetadata.contentType);
+      if (!headers.has("etag")) headers.set("etag", obj.httpEtag);
+      return __sbRawBodyResponse(body, { status: opts.status, headers });
+    };
   }
   return obj;
 }

package/src/r2-object.test.js

@@ -0,0 +1,65 @@
+// sproutboat #177 — `new Response(obj.body)` UTF-8-re-encodes an R2 object's
+// raw bytes (they're a bytestring, indistinguishable from Latin-1 text at
+// that layer). `obj.toResponse()` is the fix: same reserved x-sb-raw-body
+// marker __sbRawBodyResponse already uses for assets/fetch/service bindings.
+// The prelude is prepended as text and cannot be imported, so this test lifts
+// the relevant functions out and exercises them directly, against real
+// Response/Headers (both are Bun globals). If any of these move or their
+// boundary markers change, this fails loudly rather than silently testing
+// nothing.
+import { expect, test } from "bun:test";
+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(");
+const rawStart = src.indexOf("function __sbRawBodyResponse(");
+const utf8End = rawStart;
+const rawEnd = src.indexOf("function __sbEqCt(");
+const r2Start = src.indexOf("function __sbR2Object(");
+const r2End = src.indexOf("// Installed only when the project declares bindings.");
+if (utf8Start === -1 || utf8End === -1) throw new Error("__sbFromUtf8 block not found in prelude");
+if (rawStart === -1 || rawEnd === -1) throw new Error("__sbRawBodyResponse block not found in prelude");
+if (r2Start === -1 || r2End === -1 || r2End < r2Start) throw new Error("__sbR2Object block not found in prelude");
+
+// oxlint-disable-next-line no-function-constructor -- lifting pure blocks out of the text-only prelude for test
+const load = new Function(
+  `${src.slice(utf8Start, utf8End)}\n${src.slice(rawStart, rawEnd)}\n${src.slice(r2Start, r2End)}\nreturn { __sbR2Object };`,
+);
+const { __sbR2Object } = load();
+
+const meta = { key: "f.bin", size: 3, etag: "abc123", uploaded: "2026-09-14T00:00:00.000Z" };
+
+// The byte-for-byte round trip itself happens in the compiled runtime's
+// write_response_value (#176's C-side scan, packages/toolchain/src/patch.ts) --
+// a plain-JS Response, Bun's included, re-encodes a bytestring the same way
+// Porffor's does, so this pure-JS test can only prove toResponse() sets the
+// marker that steers that C-side read; the actual byte preservation was
+// verified manually against a real compiled standalone binary (#177).
+test("toResponse() tags the response with the runtime's raw-body marker", () => {
+  const bytes = [0x80, 0x81, 0xff].map((b) => String.fromCharCode(b)).join("");
+  const obj = __sbR2Object(meta, bytes);
+  const fixed = obj.toResponse();
+  expect(fixed.headers.get("x-sb-raw-body")).toBe("1");
+});
+
+test("toResponse() defaults content-type from httpMetadata and etag from httpEtag", () => {
+  const obj = __sbR2Object({ ...meta, httpMetadata: { contentType: "image/png" } }, "x");
+  const resp = obj.toResponse();
+  expect(resp.headers.get("content-type")).toBe("image/png");
+  expect(resp.headers.get("etag")).toBe(obj.httpEtag);
+});
+
+test("toResponse() lets caller-supplied headers/status override the defaults", () => {
+  const obj = __sbR2Object({ ...meta, httpMetadata: { contentType: "image/png" } }, "x");
+  const resp = obj.toResponse({ status: 206, headers: { "content-type": "application/octet-stream" } });
+  expect(resp.status).toBe(206);
+  expect(resp.headers.get("content-type")).toBe("application/octet-stream");
+});
+
+test("toResponse() on an empty body still returns bytes, not the string \"\"", async () => {
+  const obj = __sbR2Object(meta, "");
+  const resp = obj.toResponse();
+  const buf = new Uint8Array(await resp.arrayBuffer());
+  expect(buf.length).toBe(0);
+});