@sproutboat/runtime 0.19.1 → 0.20.0

package/CHANGELOG.md

@@ -1,5 +1,75 @@
 # @sproutboat/runtime
 
+## 0.20.0
+
+### Minor Changes
+
+- 85aa74d: Service-binding calls and outbound `fetch()` no longer block a deployed sprout. In a deployed sprout, each call runs off the event loop on one I/O thread, so the sprout keeps answering other requests while a call is in flight. Concurrent calls overlap: eight 500 ms calls finish in about 510 ms, where they used to queue for about 4 s. A deployment can also call itself through a binding, to any depth, where this used to deadlock. The toolchain installs the loop hook the runtime uses for this; with an older runtime it does nothing.
+  
+  `env.SERVICE.fetch()` now always returns a promise, as in Workers, and reads its arguments as `fetch()` does:
+  
+  - a `URL` object works as input;
+  - `fetch(request, init)` keeps the request's body when `init` sets no body of its own;
+  - a `ReadableStream` body is sent whole, where it used to arrive as the text `[object ReadableStream]`.
+  
+  Responses from bindings and from `fetch()` keep every `Set-Cookie` header, where they used to keep only the last one.
+  
+  A broker exchange is now resent only when the broker cannot have acted on it: the request never fully left, or the connection had gone stale. A `fetch` or service call that the broker may already have run is no longer repeated.
+- f2d2b72: Service-binding calls behave as in workerd in two more ways, on a platform edge that vouches for them:
+  
+  - **The callee sees the caller's URL.** `request.url` is the URL the caller passed (`https://peer/path`), where it used to be the callee deployment's own hostname.
+  - **A callee that throws makes the caller throw.** The caller's `fetch()` rejects with the callee's error, keeping its class for standard errors and its message, where it used to get a plain 500 response.
+  
+  How the platform vouches for a call:
+  
+  1. The broker sends each service call with the edge's secret (`SB_EDGE_SECRET`, which the edge gives only to brokers) and the caller's URL.
+  2. The edge forwards the call to the callee with that sprout's own token (`SB_EDGE_TOKEN`).
+  3. The callee trusts a call only when the token matches.
+  
+  A client can forge none of this. The edge removes its headers from every other request, and the error marker never reaches a client.
+  
+  A vouched call also no longer shows the broker's loopback address as `x-sb-remote-addr`. The edge's internal headers are removed before any handler sees a request.
+  
+  In `@sproutboat/wire`, the broker reads `SB_EDGE_SECRET` and takes an `edgeSecret` option.
+- b287117: `fetch()` and service bindings honour an abort signal, set as `init.signal` or a `Request`'s `signal`:
+  
+  - A signal that is already aborted rejects the call at once.
+  - Aborting it later, by hand or through `AbortSignal.timeout()`, rejects the pending call with the signal's reason.
+  
+  In a deployed sprout the abort also stops the work. The sprout closes the call's broker connection, the broker aborts its upstream request when a sprout's connection closes, and the platform's edge stops the callee's request in turn. Before, an abandoned call ran to the end anyway.
+  
+  In sproutd the request still runs to the end, and its late reply is dropped.
+  
+  In `@sproutboat/wire`, `Broker.handleFrame` takes an optional `AbortSignal`, which the broker server aborts when the connection closes.
+- 9773e45: From compatibility date `2026-10-22`, `fetch()` and service bindings follow redirects as Fetch does:
+  
+  - Under `redirect: "follow"`, the default, the request goes again to the new location, up to 20 times. Each outbound hop is checked against the egress rules like the first.
+  - A 303 turns the request into a GET with no body, and so does a 301 or 302 that answers a POST.
+  - A hop to another origin drops `Authorization`.
+  - A service binding follows through the same binding, as in workerd.
+  - `redirect: "error"` rejects with a `TypeError`.
+  - `redirect: "manual"` returns the 3xx as it is.
+  
+  Before this date, a 3xx came back to the handler whatever the mode, and still does for apps with an earlier `compatibility_date`.
+  
+  A response from `fetch()` or a service binding that has no `Content-Type` no longer gains `text/plain;charset=UTF-8`.
+- 3798994: Responses to `fetch()` and service-binding calls stream. In a deployed sprout with compatibility date `2026-10-21` or later, the call resolves as soon as the status and headers arrive. `response.body` is then a `ReadableStream` that receives each chunk as the upstream sends it.
+  
+  Before, the whole body had to arrive first. A response streamed over several seconds, such as server-sent events or a long download, reached the caller only at the end.
+  
+  The 32 MiB `SB_FETCH_MAX_BYTES` cap still applies to the total. Cancelling the body, or aborting the call's signal, stops the upstream request.
+  
+  In `@sproutboat/wire`:
+  - the broker streams a `fetch` or `service.fetch` that asks for it (`stream: true`), sending the head and each chunk as `FRAME_V1_MORE` frames through the new `emit` argument of `handleFrame`;
+  - the final frame ends the response;
+  - a request that doesn't ask is answered whole, as before.
+
+## 0.19.2
+
+### Patch Changes
+
+- bc3fd25: `Response.body` and `Request.body` are `ReadableStream`s only from compatibility date `2026-10-21`. 0.19.0 changed this for every app, which broke handlers that read `request.body` as a string, such as `JSON.parse(request.body)` in the CLI's own D1 example. An app with an earlier `compatibility_date` keeps the raw body, as before. To opt in, move `compatibility_date` to `2026-10-21` or later and rebuild.
+
 ## 0.19.1
 
 ### Patch Changes

package/WEB_STREAMS.md

@@ -20,8 +20,10 @@ runtime links no zlib. Compression writes one fixed-Huffman block per chunk as i
 (close to zlib on text: 252 bytes against 221 for 22.5 KB); decompression inflates all
 block types once the input ends and checks the CRC-32 or Adler-32. Response and Request
 bodies that are ReadableStreams are read by text(), json(), arrayBuffer() and blob(), and
-their chunks must be bytes, as in workerd. `body` is a ReadableStream for every body type,
-as in Fetch: a stream body itself, otherwise a stream made once over the bytes.
+their chunks must be bytes, as in workerd. From compatibility date 2026-10-21, `body` is a
+ReadableStream for every body type, as in Fetch: a stream body itself, otherwise a stream made
+once over the bytes. Before that date it is the value as given, as apps written for earlier
+releases read it (`JSON.parse(request.body)`).
 BYOB buffer detachment requires transfer support from the underlying engine;
 the polyfill cannot supply that engine primitive. Full Web Platform Tests
 conformance has not been established for Porffor.

package/package.json

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

package/src/native-fetch-prelude.js

@@ -5183,86 +5183,261 @@ globalThis.__sbInstallBindings = function (target, bindings) {
 
   // #48 — worker-to-worker. Same wire shape as outbound fetch, but the broker
   // resolves the target itself and forwards it internally, so this is not
-  // egress and is not subject to the private-address block.
+  // egress and is not subject to the private-address block. Always a promise, as
+  // in Workers; on an async host the caller keeps serving while the call runs,
+  // which is also what lets a deployment call itself without deadlocking.
   for (let i = 0; i < (bindings.services || []).length; i++) {
     const binding = bindings.services[i].binding;
     target[binding] = {
-      fetch(input, init) {
-        const url = __sbIsStr(input) ? input : String((input && input.url) || "https://service/");
-        const opts = init || (!__sbIsStr(input) && input) || {};
-        const headers = [];
-        if (opts.headers) {
-          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 = globalThis.__sbFetchUpstream("service.fetch", {
-          binding,
-          url,
-          method: opts.method || "GET",
-          headers,
-          ...__sbRequestBody(opts instanceof Request ? __sbRawBody(opts) : opts.body),
-        });
-        const respHeaders = new Headers();
-        for (let j = 0; j < (r.headers || []).length; j++) respHeaders.set(r.headers[j][0], r.headers[j][1]);
-        // #176: wire bytes from another deployment, not a string this handler
-        // built -- must not be re-encoded if the handler proxies it straight
-        // through (see the assets binding for the same reasoning).
-        if (r.body != null) respHeaders.set("x-sb-raw-body", "1");
-        return __sbRawBodyResponse(r.body, { status: r.status || 502, headers: respHeaders });
+      async fetch(input, init) {
+        const parts = __sbFetchParts(input, init);
+        if (parts.signal) parts.signal.throwIfAborted();
+        // A stream body is read to the end first: the wire carries a whole body.
+        let body = __sbUnwrapBody(parts.body);
+        if (body instanceof ReadableStream) body = await __sbCollectBody(body);
+        const msg = { binding, url: parts.url, method: parts.method, headers: parts.headers, ...__sbRequestBody(body) };
+        const response = await __sbFetchFollowing("service.fetch", msg, "sproutboat service " + binding, parts.redirect, parts.signal);
+        // The callee threw: as in workerd, its error is thrown here.
+        const uncaught = response.headers.get("x-sb-uncaught");
+        if (uncaught != null) throw __sbRemoteError(uncaught);
+        return response;
       },
     };
   }
 
 };
 
-// fetch() reaches any public address; the transport refuses private and
-// reserved ones at connect (baronunread/sproutboat#174). No config, like a
-// Worker's fetch. Installed by the generated module (wrap.ts), not here: the
-// prelude must not replace fetch just by being evaluated.
-globalThis.__sbInstallFetch = function () {
-  globalThis.fetch = function (input, init) {
-    // A Request's method, headers and body apply unless init overrides them; a URL
-    // object stands for its href.
-    const req = input != null && !__sbIsStr(input) && input.url != null ? input : null;
-    const url = req ? String(req.url) : input != null && input.href != null ? String(input.href) : String(input);
-    const opts = init || {};
-    const source = opts.headers != null ? opts.headers : req ? req.headers : null;
-    const headers = [];
-    if (source) {
-      if (__sbIsFn(source.forEach)) source.forEach((v, k) => headers.push([k, v]));
-      else for (const k in source) headers.push([k, source[k]]);
-    }
-    const body = opts.body !== undefined && !(opts instanceof Request) ? opts.body : req && __sbRawBody(req) !== "" ? __sbRawBody(req) : null;
-    const method = opts.method || (req && req.method) || "GET";
-    const msg = { url, method, headers, ...__sbRequestBody(body) };
-    const respond = (r) => {
-      const respHeaders = new Headers();
-      for (let j = 0; j < (r.headers || []).length; j++) respHeaders.set(r.headers[j][0], r.headers[j][1]);
-      // #176: bytes from an outbound HTTP response, not a string this handler
-      // built -- must not be re-encoded if the handler proxies it straight
-      // through (see the assets binding for the same reasoning).
-      if (r.body != null) respHeaders.set("x-sb-raw-body", "1");
-      return __sbRawBodyResponse(r.body, { status: r.status || 502, headers: respHeaders });
+// The error a service-binding callee threw, from its x-sb-uncaught marker: the same
+// standard class where there is one, else an Error with the original name.
+function __sbRemoteError(marker) {
+  let name = "Error";
+  let message = "";
+  try {
+    const parsed = JSON.parse(decodeURIComponent(marker));
+    name = String(parsed.name || "Error");
+    message = String(parsed.message == null ? "" : parsed.message);
+  } catch {
+    /* a marker we cannot read still means the callee threw */
+  }
+  const error =
+    name === "TypeError" ? new TypeError(message)
+    : name === "RangeError" ? new RangeError(message)
+    : name === "SyntaxError" ? new SyntaxError(message)
+    : name === "ReferenceError" ? new ReferenceError(message)
+    : new Error(message);
+  if (error.name !== name) error.name = name;
+  return error;
+}
+
+// fetch(input, init) as Fetch reads it: a Request's method, headers, body, redirect mode
+// and signal apply unless init overrides them; a URL object stands for its href.
+function __sbFetchParts(input, init) {
+  const req = input != null && !__sbIsStr(input) && input.url != null ? input : null;
+  const url = req ? String(req.url) : input != null && input.href != null ? String(input.href) : String(input);
+  const opts = init || {};
+  const source = opts.headers != null ? opts.headers : req ? req.headers : null;
+  const headers = [];
+  if (source) {
+    if (__sbIsFn(source.forEach)) source.forEach((v, k) => headers.push([k, v]));
+    else for (const k in source) headers.push([k, source[k]]);
+  }
+  const body = opts.body !== undefined && !(opts instanceof Request) ? opts.body : req && __sbRawBody(req) !== "" ? __sbRawBody(req) : null;
+  const method = opts.method || (req && req.method) || "GET";
+  const redirect = opts.redirect || (req && req.redirect) || "follow";
+  const signal = opts.signal || (req && req.signal) || null;
+  return { url, method, headers, body, redirect, signal };
+}
+
+// An upstream reply (fetch or service.fetch) -> a Response. Headers are appended,
+// so each Set-Cookie survives, and a reply without a content type keeps none: the
+// body reaches Response as a string, which would otherwise default to text/plain.
+function __sbUpstreamResponse(r) {
+  const respHeaders = new Headers();
+  let typed = false;
+  for (let j = 0; j < (r.headers || []).length; j++) {
+    respHeaders.append(r.headers[j][0], r.headers[j][1]);
+    if (String(r.headers[j][0]).toLowerCase() === "content-type") typed = true;
+  }
+  // #176: bytes from another server or deployment, not a string this handler
+  // built -- must not be re-encoded if the handler proxies it straight
+  // through (see the assets binding for the same reasoning).
+  if (r.body != null) respHeaders.set("x-sb-raw-body", "1");
+  const response = __sbRawBodyResponse(r.body, { status: r.status || 502, headers: respHeaders });
+  if (!typed) response.headers.delete("content-type");
+  return response;
+}
+
+// A streamed upstream response (from compatibility date 2026-10-21, where body is a
+// stream anyway): the call resolves as soon as the head arrives, and the body is a
+// ReadableStream fed chunk by chunk as the broker passes them on. Each frame fires the
+// same callback, so it is an interval that the last frame clears. A reply that comes
+// whole (a broker from before streaming, or sproutd's embedded transport) is handled
+// as before. Cancelling the body, or the signal, drops the exchange, which stops the
+// upstream request.
+function __sbUpstreamStreamed(op, msg, label, signal) {
+  return new Promise((resolve, reject) => {
+    let controller = null;
+    let onAbort = null;
+    let done = false;
+    const finish = () => {
+      done = true;
+      clearInterval(id);
+      if (onAbort) signal.removeEventListener("abort", onAbort);
     };
-    if (!__sbHttpAsyncEnabled()) return respond(globalThis.__sbFetchUpstream("fetch", msg));
-    // B18: the host runs the request off the event loop. Its reply fires a timer
-    // that never fires on its own; the timer table keeps the callback alive.
-    return new Promise((resolve, reject) => {
-      const id = setTimeout(() => {
+    const id = setInterval(() => {
+      if (done) return;
+      const raw = __sbHttpAsyncResult(id);
+      if (controller === null) {
+        let reply;
         try {
-          resolve(respond(__sbFetchReply(__sbHttpAsyncResult(id))));
+          reply = JSON.parse(raw);
         } catch (e) {
-          reject(new Error("sproutboat fetch: " + ((e && e.message) || e)));
+          reply = { ok: false, error: String((e && e.message) || e) };
+        }
+        if (reply.ok === false || !reply.stream) {
+          finish();
+          try {
+            resolve(__sbUpstreamResponse(__sbFetchReply(raw)));
+          } catch (e) {
+            reject(new Error(label + ": " + ((e && e.message) || e)));
+          }
+          return;
         }
-      }, 2147483647);
+        const headers = new Headers();
+        for (let j = 0; j < (reply.headers || []).length; j++) headers.append(reply.headers[j][0], reply.headers[j][1]);
+        const body = new ReadableStream({
+          start(c) {
+            controller = c;
+          },
+          cancel() {
+            if (done) return;
+            finish();
+            __sbCancelAsync(id);
+          },
+        });
+        resolve(new Response(body, { status: reply.status || 502, headers }));
+        return;
+      }
+      const frame = JSON.parse(raw);
+      const bytes = __sbTakeBin();
+      if (frame.chunk) {
+        if (bytes.length) controller.enqueue(new Uint8Array(__sbBufFrom(bytes)));
+        return;
+      }
+      finish();
+      if (frame.ok === false) controller.error(new Error(label + ": " + (frame.error || "failed")));
+      else controller.close();
+    }, 2147483647);
+    if (signal) {
+      onAbort = () => {
+        if (done) return;
+        finish();
+        __sbCancelAsync(id);
+        if (controller === null) reject(signal.reason);
+        else controller.error(signal.reason);
+      };
+      signal.addEventListener("abort", onAbort);
+    }
+    try {
+      msg.asyncId = id;
+      msg.stream = true;
+      globalThis.__sbFetchUpstream(op, msg);
+    } catch (e) {
+      finish();
+      reject(e);
+    }
+  });
+}
+
+// Fetch's redirect handling, from compatibility date 2026-10-22 (before it, a 3xx came
+// back as it was, whatever the mode). "follow" sends the request again to the new
+// location, up to 20 times; each hop goes back through the broker, so outbound hops
+// are vetted like the first. A 303, or a 301/302 to a POST, becomes a bodiless GET;
+// a hop to another origin drops Authorization. A service binding follows through
+// the same binding, as in workerd. "error" rejects; "manual" returns the 3xx.
+function __sbFetchFollowing(op, msg, label, mode, signal) {
+  return __sbFollowHop(op, msg, label, mode, signal, 0);
+}
+function __sbFollowHop(op, msg, label, mode, signal, hops) {
+  const step = (res) => {
+    const location = res.headers.get("location");
+    const redirect = res.status === 301 || res.status === 302 || res.status === 303 || res.status === 307 || res.status === 308;
+    if (!(globalThis.__sbCompat >= "2026-10-22") || mode === "manual" || !redirect || location == null) return res;
+    if (mode === "error") throw new TypeError(label + ": redirect not allowed (redirect: \"error\")");
+    if (hops >= 20) throw new TypeError(label + ": too many redirects");
+    const dropped = __sbRawBody(res);
+    if (dropped instanceof ReadableStream) dropped.cancel();
+    const from = new URL(msg.url);
+    const to = new URL(location, from);
+    const next = { ...msg, url: to.href };
+    delete next.asyncId;
+    const toGet = res.status === 303 ? msg.method !== "GET" && msg.method !== "HEAD" : res.status !== 307 && res.status !== 308 && msg.method === "POST";
+    const drop = (name) =>
+      (toGet && /^content-(type|length|encoding|language|location)$/.test(name)) || (to.origin !== from.origin && name === "authorization");
+    next.headers = msg.headers.filter((pair) => !drop(String(pair[0]).toLowerCase()));
+    if (toGet) {
+      next.method = "GET";
+      next.body = null;
+      delete next.bodyBinary;
+    }
+    return __sbFollowHop(op, next, label, mode, signal, hops + 1);
+  };
+  const out = __sbUpstream(op, msg, label, signal);
+  return out instanceof Promise ? out.then(step) : step(out);
+}
+
+// Sends `msg` as `op` and answers with the Response: at once on a synchronous
+// transport, or (B18) as a promise when the host runs requests off its event loop.
+// The reply fires a timer that never fires on its own; the timer table keeps the
+// callback alive until then. An aborted `signal` rejects with its reason and cancels
+// the exchange, which closes its broker connection: the broker stops the upstream
+// request, and the edge in turn stops the callee's.
+function __sbUpstream(op, msg, label, signal) {
+  if (signal) signal.throwIfAborted();
+  if (!__sbHttpAsyncEnabled()) return __sbUpstreamResponse(globalThis.__sbFetchUpstream(op, msg));
+  if (globalThis.__sbCompat >= "2026-10-21") return __sbUpstreamStreamed(op, msg, label, signal);
+  return new Promise((resolve, reject) => {
+    let onAbort = null;
+    const settled = () => {
+      if (onAbort) signal.removeEventListener("abort", onAbort);
+    };
+    const id = setTimeout(() => {
+      settled();
       try {
-        msg.asyncId = id;
-        globalThis.__sbFetchUpstream("fetch", msg);
+        resolve(__sbUpstreamResponse(__sbFetchReply(__sbHttpAsyncResult(id))));
       } catch (e) {
-        clearTimeout(id);
-        reject(e);
+        reject(new Error(label + ": " + ((e && e.message) || e)));
       }
-    });
+    }, 2147483647);
+    if (signal) {
+      onAbort = () => {
+        settled();
+        clearTimeout(id);
+        __sbCancelAsync(id);
+        reject(signal.reason);
+      };
+      signal.addEventListener("abort", onAbort);
+    }
+    try {
+      msg.asyncId = id;
+      globalThis.__sbFetchUpstream(op, msg);
+    } catch (e) {
+      settled();
+      clearTimeout(id);
+      reject(e);
+    }
+  });
+}
+
+// fetch() reaches any public address; the transport refuses private and
+// reserved ones at connect (baronunread/sproutboat#174). No config, like a
+// Worker's fetch. Installed by the generated module (wrap.ts), not here: the
+// prelude must not replace fetch just by being evaluated.
+globalThis.__sbInstallFetch = function () {
+  globalThis.fetch = function (input, init) {
+    const parts = __sbFetchParts(input, init);
+    const msg = { url: parts.url, method: parts.method, headers: parts.headers, ...__sbRequestBody(parts.body) };
+    return __sbFetchFollowing("fetch", msg, "sproutboat fetch", parts.redirect, parts.signal);
   };
 };
 
@@ -5744,7 +5919,7 @@ function __sbStreamResponse(response) {
   return response;
 }
 
-async function __sbFetchWithDrain(res, tasks) {
+async function __sbFetchWithDrain(res, tasks, bindingCall) {
   let r;
   try {
     r = res && __sbIsFn(res.then) ? await res : res;
@@ -5754,7 +5929,7 @@ async function __sbFetchWithDrain(res, tasks) {
     }
   } catch (error) {
     // #179 — a rejected handler promise must not take the process down with it.
-    r = __sbErrorResponse(error);
+    r = __sbErrorResponse(error, bindingCall);
   }
   // The response goes out now and ctx.waitUntil work keeps running after it, as in
   // workerd; it was awaited first, so a 1.5 s background task delayed the response by
@@ -5767,14 +5942,42 @@ async function __sbFetchWithDrain(res, tasks) {
 // 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) {
+function __sbErrorResponse(error, bindingCall) {
   __sbLogUncaught("fetch", error);
   // Untyped, as workerd sends it: the text/plain default is for handlers' bodies.
   const response = new Response("Internal Server Error", { status: 500 });
   response.headers.delete("content-type");
+  // A service-binding caller rethrows the error, as in workerd. Only on a call the
+  // edge vouched for: the marker carries the message, and the edge strips it from
+  // anything that goes to a client.
+  if (bindingCall) {
+    const name = (error && error.name) || "Error";
+    const message = error && error.message != null ? String(error.message) : String(error);
+    response.headers.set("x-sb-uncaught", encodeURIComponent(JSON.stringify({ name: String(name), message: message.slice(0, 1000) })));
+  }
   return response;
 }
 
+// A service-binding call the platform's edge vouched for: it carries the token the edge
+// gave this sprout (SB_EDGE_TOKEN), so no client can claim one. Such a call sees the URL
+// its caller passed (x-sb-url), not the deployment's hostname, and no remote address,
+// as in workerd. The edge's headers are removed from every request before the handler
+// sees it. Returns whether the edge vouched for this one.
+function __sbBindingCallIngress(request) {
+  const headers = request.headers;
+  const want = __sbEnv("SB_EDGE_TOKEN");
+  const vouched = !!want && headers.get("x-sb-binding-call") === "1" && __sbEqCt(headers.get("x-sb-edge-token") || "", want);
+  if (vouched) {
+    const url = headers.get("x-sb-url");
+    if (url && URL.canParse(url)) request.url = url;
+    headers.delete("x-sb-remote-addr");
+  }
+  for (const name of ["x-sb-binding-call", "x-sb-url", "x-sb-edge-token"]) {
+    if (headers.get(name) != null) headers.delete(name);
+  }
+  return vouched;
+}
+
 function __sbLogUncaught(where, error) {
   try {
     let text = "";
@@ -5830,6 +6033,7 @@ globalThis.__sbEntry = function (handlers, request) {
   __sbDecodeIngress(request);
   const trigger = request.headers.get("x-sb-trigger");
   if (!trigger) {
+    const bindingCall = __sbBindingCallIngress(request);
     // #163/#128 — expose the request metadata the edge already has, the
     // Workers way, before the handler runs. httpProtocol/tlsVersion/tlsCipher
     // are only set when a trusted front proxy forwarded them; colo, ASN and
@@ -5868,11 +6072,11 @@ globalThis.__sbEntry = function (handlers, request) {
     } 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(error);
+      return __sbErrorResponse(error, bindingCall);
     }
     // Same promise-identity rule as above applies to `__sbFetchWithDrain`'s
     // own return, which is why it's tail-called rather than chained on here.
-    if (__sbTasks.length || (__res && __sbIsFn(__res.then)) || __sbHasStreamBody(__res)) return __sbFetchWithDrain(__res, __sbTasks);
+    if (__sbTasks.length || (__res && __sbIsFn(__res.then)) || __sbHasStreamBody(__res)) return __sbFetchWithDrain(__res, __sbTasks, bindingCall);
     return __sbTagCpu(__res, __t0);
   }
   if (!__sbTriggerAuthed(request)) return new Response("forbidden", { status: 403 });