@sproutboat/runtime 0.13.2 → 0.13.4

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @sproutboat/runtime
 
+## 0.13.4
+
+### Patch Changes
+
+- 5bf4ea6: The handler bundle runs in its own function scope inside the generated module (part of baronunread/sproutboat#238). It used to be spliced into the prelude's top level, and Porffor resolves top-level names module-wide, so a bundle with its own top-level `const URL = ...` (uuid exports one) replaced the `URL` class the prelude extends and the binary died at startup with `Cannot get property of null`. Static imports from a direct-ESM handler stay at module top level.
+
+## 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.4",
   "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 });
 };

package/src/wrap.ts

@@ -228,11 +228,21 @@ export function wrapNativeFetchHandler(
     ? `__sbStartLocalTriggers(__sbHandlers, ${JSON.stringify(bindings)});\n`
     : "";
 
+  // baronunread/sproutboat#238: the handler runs in its own function scope.
+  // Spliced in at the prelude's top level, a bundle's own top-level
+  // `const URL = ...` (uuid exports one) replaced the URL class for the whole
+  // module, prelude included, and the binary died at startup. Porffor resolves
+  // a top-level name module-wide, so a block is not enough; a function is.
+  // Static imports (a direct-ESM handler, no bundler in front) are only legal
+  // at module top level, so they stay outside the function.
+  const importPattern = /^import\s(?:[\s\S]*?\sfrom\s*)?["'][^"'\n]+["'];?[ \t]*$/gm;
+  const imports = (neutralised.match(importPattern) ?? []).join("\n");
+  const body = neutralised.replace(importPattern, "");
   return (
     `${prelude}\n${nativeTransferAbi}${compat}${env}${versionMetadataLine}${wire}` +
-    `${neutralised}\n` +
-    `${registerDO}${triggers}` +
-    `export default {\n  port: ${port},\n  fetch(request) { return __sbEntry(__sbHandlers, request); }\n};\n`
+    `${imports ? `${imports}\n` : ""}const __sbUserHandlers = (() => {\n${body}\n` +
+    `${registerDO}${triggers}return __sbHandlers;\n})();\n` +
+    `export default {\n  port: ${port},\n  fetch(request) { return __sbEntry(__sbUserHandlers, request); }\n};\n`
   );
 }
 

package/test/native-utf8.ts

@@ -12,7 +12,10 @@ import { EMPTY_BINDINGS, preludePath, TRANSPORT_MARKER, transportPath, wrapNativ
 // two hot paths (KV, D1) and a non-ASCII SQLite error message.
 const text = "/café/日本/😀/x";
 
+// #238: the handler's own top-level \`URL\` (uuid exports one) must not replace
+// the URL class the prelude extends; the handler runs in its own scope.
 const handler = `
+const URL = "shadowed";
 export default {
   async fetch() {
     await env.KV.put("k", ${JSON.stringify(text)});
@@ -22,7 +25,7 @@ export default {
     const d1 = (await env.DB.prepare("SELECT v FROM t").first()).v;
     let error = "";
     try { await env.DB.prepare("SELECT * FROM tabellà").first(); } catch (e) { error = String(e.message); }
-    return Response.json({ kv, kvLength: kv.length, d1, d1Length: d1.length, error });
+    return Response.json({ kv, kvLength: kv.length, d1, d1Length: d1.length, error, url: URL });
   },
 };
 `;
@@ -96,13 +99,21 @@ try {
   assert.equal(response.status, 200);
   // SAFETY: the handler above is the only producer of this body and always
   // returns exactly these five fields; deepEqual below checks every one.
-  const body = (await response.json()) as { kv: string; kvLength: number; d1: string; d1Length: number; error: string };
+  const body = (await response.json()) as {
+    kv: string;
+    kvLength: number;
+    d1: string;
+    d1Length: number;
+    error: string;
+    url: string;
+  };
   assert.deepEqual(
     { kv: body.kv, kvLength: body.kvLength, d1: body.d1, d1Length: body.d1Length },
     { kv: text, kvLength: text.length, d1: text, d1Length: text.length },
   );
   assert.match(body.error, /tabellà/);
-  console.log("Non-ASCII KV, D1 and error text round-trip through the broker");
+  assert.equal(body.url, "shadowed");
+  console.log("Non-ASCII KV, D1 and error text round-trip through the broker; a handler-level URL stays scoped");
 } finally {
   if (server) {
     server.kill(9);