@sproutboat/toolchain 0.10.1 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @sproutboat/toolchain
 
+## 0.11.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.
+
+## 0.10.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.10.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/toolchain",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "license": "MIT",
   "type": "module",
   "repository": {

package/src/acquire.test.ts

@@ -147,7 +147,8 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
       "  }\n" +
       "\n" +
       "  if (body_owned) free(body_owned);\n" +
-      "}\n",
+      "}\n" +
+      "int main(void) {\n  porf_native_fetch_runtime_init();\n  porf_native_fetch_static_init();\n\n  return 0;\n}\n",
     "compiler/builtins/json.ts":
       "let __Porffor_json_bufLimit: i32 = 0;\n    depth += 1;\n    depth -= 1;\n    depth += 1;\n    depth -= 1;\n  let out: i32 = __Porffor_json_serialize(buffer, value, 0, space);\n" +
       "// sb_json_utf16_v1\n" +

package/src/fetch-classes.ts

@@ -72,8 +72,11 @@ export const REQUEST_CLASS_SOURCE = String.raw`class Request {
   // body is a ReadableStream, as in Fetch: a stream body itself, else a stream made once over
   // the bytes. The value as given stays in _bodyInit, which the native writer, streaming and
   // the prelude read; assigning body (the native ingress does) sets it.
+  // From compatibility date 2026-10-21. Before it, body is the value as given, as it always
+  // was here (apps read request.body as a string); a deployed handler keeps its behaviour.
   static _bodyAsStream(message) {
     const init = message._bodyInit;
+    if (!(globalThis.__sbCompat >= '2026-10-21')) return init;
     if (init == null) return null;
     if (Request._isStream(init)) return init;
     if (message._bodyStream == null) {

package/src/fingerprint.ts

@@ -21,7 +21,7 @@ export const PATCH_SOURCES = [
  * patch.ts as the module patch.ts is everywhere else. Kept current by fingerprint.test.ts
  * (UPDATE_FINGERPRINT=1 bun test packages/toolchain/src/fingerprint.test.ts).
  */
-export const RELEASED_FINGERPRINT = "9a717433bb3b";
+export const RELEASED_FINGERPRINT = "66de5cdac773";
 
 /** The fingerprint of the sources in dir, or null where they are not on disk. */
 export function sourceFingerprint(dir: string): string | null {

package/src/patch.test.ts

@@ -16,6 +16,7 @@ import {
   patchCaseMapping,
   patchZeroDelayTimers,
   patchStreamingResponses,
+  patchAsyncWaker,
   patchSplitGlobals,
   patchBlobClass,
   patchFetchClasses,
@@ -771,6 +772,30 @@ test("streaming patch adds the stream registry and attaches marked responses, id
   }
 });
 
+test("async waker patch installs a loop waker in the native server, idempotently", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-async-waker-"));
+  try {
+    await mkdir(join(root, "compiler"));
+    const file = join(root, "compiler/uwebsockets.js");
+    await writeFile(
+      file,
+      "static void on_request() {}\nint main(void) {\n  porf_native_fetch_runtime_init();\n  porf_native_fetch_static_init();\n\n  uWS::App();\n}\n",
+    );
+    await patchAsyncWaker(root);
+    const patched = await readFile(file, "utf8");
+    expect(patched).toContain('extern "C" __attribute__((weak)) void sb_async_set_waker(void (*wake)(void))');
+    expect(patched).toContain("sb_async_loop->defer([] {");
+    expect(patched.indexOf("sb_async_set_waker(sb_async_wake);")).toBeGreaterThan(patched.indexOf("porf_native_fetch_static_init();"));
+    expect(patched.indexOf("sb_async_set_waker(sb_async_wake);")).toBeLessThan(patched.indexOf("uWS::App();"));
+    await patchAsyncWaker(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+    await writeFile(file, "export const x = 1;\n");
+    await expect(patchAsyncWaker(root)).rejects.toThrow("main() anchor not found");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
 test("split globals patch prefixes module globals so none binds to libc, idempotently", async () => {
   const root = await mkdtemp(join(tmpdir(), "sb-split-globals-"));
   try {

package/src/patch.ts

@@ -1841,6 +1841,39 @@ const DEFERRED_DISCARD_EDITS: [string, string][] = [
   ],
 ];
 
+const ASYNC_WAKER_MARKER = "// sproutboat: async broker exchanges";
+const ASYNC_WAKER_MAIN =
+  "int main(void) {\n  porf_native_fetch_runtime_init();\n  porf_native_fetch_static_init();\n";
+
+/**
+ * The broker transport runs fetch() and service-binding calls on its own threads
+ * once the host gives it a way back onto the loop, so a sprout keeps serving while
+ * a call is in flight. uWS's `defer()` is that way: it is the loop's one thread-safe
+ * entry (it locks, queues and wakes the loop). Builds without the broker transport
+ * link the weak no-op defaults and stay synchronous.
+ */
+export async function patchAsyncWaker(root: string): Promise<void> {
+  const shimFile = resolve(root, "compiler/uwebsockets.js");
+  const shim = await readFile(shimFile, "utf8");
+  if (shim.includes(ASYNC_WAKER_MARKER)) return;
+  if (!shim.includes(ASYNC_WAKER_MAIN))
+    throw new Error(`could not patch Porffor's native server for async calls: main() anchor not found in ${shimFile}`);
+  const waker = `${ASYNC_WAKER_MARKER}
+extern "C" __attribute__((weak)) void sb_async_set_waker(void (*wake)(void)) { (void)wake; }
+extern "C" __attribute__((weak)) void sb_async_drain(void) {}
+static uWS::Loop* sb_async_loop = nullptr;
+static void sb_async_wake(void) {
+  sb_async_loop->defer([] {
+    __porffor_js_enter();
+    sb_async_drain();
+    __porffor_js_exit();
+  });
+}
+`;
+  const install = "  sb_async_loop = uWS::Loop::get();\n  sb_async_set_waker(sb_async_wake);\n";
+  await writeFile(shimFile, shim.replace(ASYNC_WAKER_MAIN, waker + ASYNC_WAKER_MAIN + install));
+}
+
 /** #287: deferred discard and idle return. After patchQuietCollection, which adds the quiet collector. */
 export async function patchDeferredDiscard(root: string): Promise<void> {
   const file = resolve(root, "compiler/render.js");
@@ -2282,6 +2315,7 @@ export async function ensurePorfforPatched(root: string): Promise<void> {
   await patchRenderJs(root);
   await patchStreamingResponses(root);
   await patchQuietCollection(root);
+  await patchAsyncWaker(root);
   await patchDeferredDiscard(root);
   await patchDateParser(root);
   await patchPromiseResolveNull(root);