@sproutboat/runtime 0.13.1 → 0.13.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @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
+
+- dc6539c: Log uncaught handler exceptions to stderr before answering 500, as `Uncaught (in fetch) Error: ...` (and `scheduled` / `alarm` for those triggers). A thrown or rejected handler used to produce a bare 500 with nothing logged, which hid baronunread/sproutboat#168 entirely.
+
 ## 0.13.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.13.1",
+  "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,
@@ -1993,27 +1999,43 @@ async function __sbFetchWithDrain(res, tasks) {
   let r;
   try {
     r = res && __sbIsFn(res.then) ? await res : res;
-  } catch {
+  } catch (error) {
     // #179 — a rejected handler promise must not take the process down with it.
-    r = __sbErrorResponse();
+    r = __sbErrorResponse(error);
   }
   await __sbDrainWaitUntil(tasks);
   return r;
 }
 
 // #179 — turn an uncaught handler exception into a 500 instead of letting it
-// propagate past __sbEntry and crash the whole server.
-function __sbErrorResponse() {
+// propagate past __sbEntry and crash the whole server. Logged first, the way a
+// Worker logs "Uncaught Error: ...": a swallowed exception left a 500 with
+// nothing on stderr, which hid #168 entirely.
+function __sbErrorResponse(error) {
+  __sbLogUncaught("fetch", error);
   return new Response("Internal Server Error", { status: 500 });
 }
 
+function __sbLogUncaught(where, error) {
+  try {
+    let text = "";
+    if (error && error.stack) text = String(error.stack);
+    else if (error && error.message != null) text = (error.name || "Error") + ": " + error.message;
+    else text = String(error);
+    console.error("Uncaught (in " + where + ") " + text);
+  } catch {
+    /* logging must never turn a handled error into a crash */
+  }
+}
+
 // Shared by alarm and scheduled: both reply with an empty 204 once their
 // handler (and anything it queued via `waitUntil`) has settled.
 async function __sb204WithDrain(res, tasks) {
   try {
     if (res && __sbIsFn(res.then)) await res;
-  } catch {
+  } catch (error) {
     // #179 — same rule as fetch: a rejected scheduled/alarm promise must not crash the process.
+    __sbLogUncaught("scheduled/alarm", error);
   }
   await __sbDrainWaitUntil(tasks);
   return new Response("", { status: 204 });
@@ -2082,10 +2104,10 @@ globalThis.__sbEntry = function (handlers, request) {
       __res = globalThis.__sbCompat >= "2026-09-28"
         ? handlers.fetch(request, globalThis.env, ctx)
         : handlers.fetch(request, ctx);
-    } catch {
+    } catch (error) {
       // #179 — a synchronous throw anywhere in the handler must not take the
       // whole process (and every other in-flight request) down with it.
-      return __sbErrorResponse();
+      return __sbErrorResponse(error);
     }
     // Same promise-identity rule as above applies to `__sbFetchWithDrain`'s
     // own return, which is why it's tail-called rather than chained on here.
@@ -2112,8 +2134,9 @@ globalThis.__sbEntry = function (handlers, request) {
       __sres = globalThis.__sbCompat >= "2026-09-28"
         ? handlers.scheduled(event, globalThis.env, ctx)
         : handlers.scheduled(event, ctx);
-    } catch {
+    } catch (error) {
       // #179 — same rule as fetch: don't let a throw here crash the process.
+      __sbLogUncaught("scheduled", error);
       return new Response("", { status: 204 });
     }
     if (__sbTasks.length || (__sres && __sbIsFn(__sres.then))) return __sb204WithDrain(__sres, __sbTasks);
@@ -2146,8 +2169,9 @@ globalThis.__sbEntry = function (handlers, request) {
     let __ares;
     try {
       __ares = inst.alarm();
-    } catch {
+    } catch (error) {
       // #179 — same rule as fetch: don't let a throw here crash the process.
+      __sbLogUncaught("alarm", error);
       return new Response("", { status: 204 });
     }
     // Was fire-and-forget before: an async `alarm()` and any `state.waitUntil()`

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 });
 };