@sproutboat/runtime 0.21.0 → 0.21.1

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @sproutboat/runtime
 
+## 0.21.1
+
+### Patch Changes
+
+- 98800ca: The asynchronous `fetch()` and service-binding behaviour from 0.20.0 now starts at compatibility date `2026-10-22`. Before, it applied at every date, which broke apps that use the result without `await`, such as the CLI's kitchen-sink: `const r = fetch(url); r.body`.
+  
+  From `2026-10-22`, in a deployed sprout:
+  
+  - `fetch()` and `env.SERVICE.fetch()` return promises and run off the event loop;
+  - responses stream;
+  - redirects are followed;
+  - a callee's error is thrown in the caller;
+  - a callee sees its caller's URL.
+  
+  With an earlier `compatibility_date`, a deployed sprout's `fetch()` and binding calls answer at once with a `Response`, as they did before 0.20.0. To get the new behaviour, move `compatibility_date` to `2026-10-22` and rebuild.
+  
+  These stay ungated:
+  
+  - sproutd answered with promises at every date, and still does;
+  - RPC calls are always asynchronous;
+  - abort signals, `Set-Cookie` and `Content-Type` work at every date.
+
 ## 0.21.0
 
 ### Minor Changes

package/package.json

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

package/src/native-fetch-prelude.js

@@ -5218,24 +5218,19 @@ 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. 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.
+  // egress and is not subject to the private-address block. From compatibility date
+  // 2026-10-22 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. Before it, the Response comes back at once, as it always did, so a
+  // handler that uses it without awaiting keeps working.
   for (let i = 0; i < (bindings.services || []).length; i++) {
     const binding = bindings.services[i].binding;
     const fetcher = {
-      async fetch(input, init) {
+      fetch(input, init) {
+        if (globalThis.__sbCompat >= "2026-10-22") return __sbServiceFetch(binding, 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;
+        const msg = { binding, url: parts.url, method: parts.method, headers: parts.headers, ...__sbRequestBody(parts.body) };
+        return __sbUpstreamResponse(globalThis.__sbFetchUpstream("service.fetch", msg));
       },
     };
     // Any other name is an RPC method of the callee's WorkerEntrypoint (see __sbRpcCall).
@@ -5248,9 +5243,24 @@ globalThis.__sbInstallBindings = function (target, bindings) {
       },
     });
   }
-
 };
 
+// A service-binding fetch from compatibility date 2026-10-22: a promise, off the event
+// loop on an async host, following redirects, and throwing the callee's error.
+async function __sbServiceFetch(binding, 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;
+}
+
 // 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) {
@@ -5381,7 +5391,7 @@ async function __sbRpcCall(binding, method, args) {
     ],
     body,
   };
-  const response = await __sbUpstream("service.fetch", msg, label, null);
+  const response = await __sbUpstream("service.fetch", msg, label, null, true);
   const uncaught = response.headers.get("x-sb-uncaught");
   if (uncaught != null) throw __sbRemoteError(uncaught);
   if (response.headers.get("x-sb-rpc-result") !== "1") {
@@ -5462,8 +5472,8 @@ function __sbUpstreamResponse(r) {
   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
+// A streamed upstream response (from compatibility date 2026-10-22, with the other
+// asynchronous fetch() behaviour; body is a stream from 2026-10-21 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
@@ -5587,10 +5597,15 @@ function __sbFollowHop(op, msg, label, mode, signal, hops) {
 // 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) {
+// Promises from compatibility date 2026-10-22. Before it, a transport that always
+// answered at once (the broker's) still does, so handlers that use fetch()'s result
+// without awaiting keep working; sproutd's answered with promises at any date
+// (__sbAsyncAtAnyDate). `always` is for RPC, which has no older behaviour to keep.
+function __sbUpstream(op, msg, label, signal, always) {
   if (signal) signal.throwIfAborted();
-  if (!__sbHttpAsyncEnabled()) return __sbUpstreamResponse(globalThis.__sbFetchUpstream(op, msg));
-  if (globalThis.__sbCompat >= "2026-10-21") return __sbUpstreamStreamed(op, msg, label, signal);
+  const promised = always || globalThis.__sbCompat >= "2026-10-22" || __sbAsyncAtAnyDate();
+  if (!__sbHttpAsyncEnabled() || !promised) return __sbUpstreamResponse(globalThis.__sbFetchUpstream(op, msg));
+  if (globalThis.__sbCompat >= "2026-10-22") return __sbUpstreamStreamed(op, msg, label, signal);
   return new Promise((resolve, reject) => {
     let onAbort = null;
     const settled = () => {
@@ -6164,7 +6179,8 @@ function __sbBindingCallIngress(request) {
   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;
+    // The callee sees its caller's URL from compatibility date 2026-10-22, as in workerd.
+    if (url && URL.canParse(url) && globalThis.__sbCompat >= "2026-10-22") request.url = url;
     headers.delete("x-sb-remote-addr");
   }
   for (const name of ["x-sb-binding-call", "x-sb-url", "x-sb-edge-token"]) {

package/src/transport-broker.js

@@ -895,6 +895,11 @@ function __sbCancelAsync(asyncId) {
   `;
 }
 
+// Before compatibility date 2026-10-22, fetch() through the broker answered at once.
+function __sbAsyncAtAnyDate() {
+  return false;
+}
+
 // Whether the host runs exchanges off its loop (it installed a waker).
 function __sbHttpAsyncEnabled() {
   let res = false;

package/src/transport-embedded.js

@@ -2086,6 +2086,11 @@ function __sbHttpAsyncResult(asyncId) {
 // placeholder timer cleared, the reply is dropped when it arrives.
 function __sbCancelAsync() {}
 
+// sproutd ran fetch() off its loop, as a promise, at every compatibility date (B18).
+function __sbAsyncAtAnyDate() {
+  return true;
+}
+
 // Whether the host runs async requests (sb_async_enable was called).
 function __sbHttpAsyncEnabled() {
   let res = false;

package/test/native-service-bindings.ts

@@ -239,6 +239,7 @@ const broker = createBroker({
 });
 const brokerServer = listen(broker, "127.0.0.1", 0);
 let server: ReturnType<typeof Bun.spawn> | undefined;
+let legacy: ReturnType<typeof Bun.spawn> | undefined;
 const get = async (path: string) => {
   const t0 = performance.now();
   const res = await fetch(`http://127.0.0.1:${port}${path}`, { signal: AbortSignal.timeout(20_000) });
@@ -356,7 +357,7 @@ try {
   assert.equal(publicBoom.status, 500);
   assert.equal(publicBoom.headers.get("x-sb-uncaught"), null);
 
-  // Streamed responses (compatibility date 2026-10-21 on): the call resolves on the
+  // Streamed responses (compatibility date 2026-10-22 on): the call resolves on the
   // head, the first chunk arrives before the rest, and a 12 MiB body arrives intact.
   const streamed = await get("/streamed");
   assert.equal(streamed.status, 200, streamed.text);
@@ -380,15 +381,51 @@ try {
   // A deployment calling itself, 30 levels deep: every level waits on the next at once.
   const self = await get("/self");
   assert.equal(self.text, "bottom 30");
+  // Before compatibility date 2026-10-22 a binding call answers at once, as it always
+  // did: a handler that uses the Response without awaiting it keeps working.
+  const legacyHandler = `
+export default {
+  fetch(request, env) {
+    const res = env.PEER.fetch("https://peer/echo?legacy=1");
+    return new Response(String(res instanceof Response) + ":" + res.status + ":" + res.json().path);
+  },
+};
+`;
+  const legacyPort = freePort();
+  const legacySource = join(workdir, "legacy.generated.js");
+  const legacyBinary = join(workdir, "legacy-native");
+  await writeFile(legacySource, wrapNativeFetchHandler(legacyHandler, core.replace(TRANSPORT_MARKER, transport), {}, bindings, undefined, "2026-10-21"));
+  const legacyCompile = Bun.spawnSync([node, resolve(porffor, "runtime/index.js"), "native", legacySource, "-o", legacyBinary, "-s", "-O0"], { cwd: workdir });
+  assert.equal(legacyCompile.exitCode, 0, `legacy compile failed:\n${legacyCompile.stderr}`);
+  legacy = Bun.spawn([legacyBinary], {
+    cwd: workdir,
+    env: { ...process.env, PORT: String(legacyPort), SB_BROKER_PORT: String(brokerServer.port), SB_BROKER_TOKEN: "native-services" },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  let legacyText = "";
+  for (let attempt = 0; attempt < 50 && !legacyText; attempt++) {
+    try {
+      legacyText = await (await fetch(`http://127.0.0.1:${legacyPort}/`, { signal: AbortSignal.timeout(20_000) })).text();
+    } catch {
+      await Bun.sleep(100);
+    }
+  }
+  assert.equal(legacyText, "true:200:/echo?legacy=1", "before 2026-10-22 a binding call answers synchronously");
+
   console.log(
     `Service bindings return promises and run off the loop: /ping ${Math.round(ping.ms)} ms during a call, ` +
-      `8x500 ms in ${Math.round(total)} ms, self-recursion ok; URL, Request+init, stream bodies, Set-Cookie and missing content types preserved; redirects follow Fetch; aborted calls stop upstream; vouched calls see the caller's URL and rethrow the callee's errors; responses stream; RPC calls WorkerEntrypoint methods`,
+      `8x500 ms in ${Math.round(total)} ms, self-recursion ok; URL, Request+init, stream bodies, Set-Cookie and missing content types preserved; redirects follow Fetch; aborted calls stop upstream; before 2026-10-22 calls answer at once; vouched calls see the caller's URL and rethrow the callee's errors; responses stream; RPC calls WorkerEntrypoint methods`,
   );
 } finally {
   if (server) {
     server.kill(9);
     await server.exited;
   }
+  if (legacy) {
+    legacy.kill(9);
+    await legacy.exited;
+  }
   brokerServer.stop();
   broker.close();
   edge.stop(true);