@sproutboat/runtime 0.39.0 → 0.41.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @sproutboat/runtime
 
+## 0.41.0
+
+### Minor Changes
+
+- 1eacf43: Secrets read from the environment (a standalone binary, a sproutd worker) are decoded as UTF-8 from the proposed compatibility date 2026-11-07. Before, the handler got the environment's bytes one char per byte, so `é` arrived as `é`. The broker transport is unchanged: its secrets already arrive as real strings. Bytes that are not valid UTF-8 pass through as before.
+
+### Patch Changes
+
+- f74835a: `crypto.subtle` signs and verifies P-256 (ES256 and ECDH) with BearSSL's 64-bit `ec_p256_m64` where the target has a 128-bit multiply, and keeps the portable code everywhere else (and for P-384 and P-521). BearSSL never picks m64 by itself, so the C asks for it with `br_ec_p256_m64_get()`, which returns null on a target without one. Through the runtime on macOS arm64, ES256 signs 2.2x faster (2,563 to 5,621 per second) and verifies 3.1x faster (1,318 to 4,050 per second). Results are unchanged, so there is no new compatibility date.
+  
+  This needs the BearSSL that the CLI pins from the release that ships with it: m64 is not in BearSSL 0.6, so a CLI that still links 0.6 cannot link this runtime.
+
+## 0.40.0
+
+### Minor Changes
+
+- 1ae7843: From the proposed compatibility date 2026-11-16, `fetch()` on the standalone binary runs off the event loop. It used to run each request to the end before it returned, so 20 concurrent fetches to a 100 ms endpoint took 2,000 ms and every other request waited behind them. They now go to a pool of up to 32 I/O threads (the same client sproutd runs on 8), the handler suspends, and the server keeps serving; the 20 fetches take about 100 ms. The reply is delivered on the loop through the uWS waker the standalone server already installs for outbound WebSockets, so JavaScript still runs on one thread. Earlier dates keep the synchronous call, because a handler that relied on one request at a time across an `await fetch()` now interleaves with others, as it does in workerd. Behaviour on sproutd and through the broker is unchanged.
+
 ## 0.39.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.39.0",
+  "version": "0.41.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/native-fetch-prelude.js

@@ -9397,6 +9397,14 @@ static const sbc_u8 sbc_oid_x25519[] = { 0x2b, 0x65, 0x6e };
 static int sbc_oid_eq(const sbc_u8* a, size_t al, const sbc_u8* b, size_t bl) { return al == bl && memcmp(a, b, al) == 0; }
 
 static int sbc_curve_br(int c) { return c == 1 ? BR_EC_secp256r1 : c == 2 ? BR_EC_secp384r1 : c == 3 ? BR_EC_secp521r1 : 0; }
+
+static const br_ec_impl* sbc_ec(int br_curve) {
+  if (br_curve == BR_EC_secp256r1) {
+    const br_ec_impl* fast = br_ec_p256_m64_get();
+    if (fast) return fast;
+  }
+  return br_ec_get_default();
+}
 static int sbc_curve_from_br(int c) { return c == BR_EC_secp256r1 ? 1 : c == BR_EC_secp384r1 ? 2 : c == BR_EC_secp521r1 ? 3 : 0; }
 static size_t sbc_curve_size(int c) { return c == 1 ? 32 : c == 2 ? 48 : c == 3 ? 66 : 0; }
 static void sbc_curve_oid(int c, const sbc_u8** o, size_t* n) {
@@ -9579,7 +9587,7 @@ static int sbc_decode(int pkcs8, const sbc_u8* der, size_t len, sbc_buf* out) {
       if (cv) {
         sbc_u8 pub[133];
         br_ec_public_key pk;
-        if (br_ec_compute_pub(br_ec_get_default(), &pk, pub, sk) != 0) {
+        if (br_ec_compute_pub(sbc_ec(sk->curve), &pk, pub, sk) != 0) {
           sbc_put1(out, SBC_K_EC); sbc_put1(out, (sbc_u8)cv); sbc_put1(out, 1);
           sbc_field(out, pk.q, pk.qlen);
 
@@ -9862,7 +9870,7 @@ static int sbc_ecdsa_sign(int bits, const sbc_u8* key, size_t kl, const sbc_u8*
   sbc_u8 h[64], sig[132];
   rc = SBC_OPERATION;
   if (sbc_digest(bits, m, ml, h)) {
-    size_t n = br_ecdsa_sign_raw_get_default()(br_ec_get_default(), sbc_hash(bits), h, sk, sig);
+    size_t n = br_ecdsa_sign_raw_get_default()(sbc_ec(sk->curve), sbc_hash(bits), h, sk, sig);
     if (n) { sbc_put(out, sig, n); rc = SBC_OK; }
   }
   free(dc);
@@ -9877,7 +9885,7 @@ static int sbc_ecdsa_verify(int bits, int curve, const sbc_u8* point, size_t pl,
   if (sl != 2 * fs) return SBC_OK;
   br_ec_public_key pk;
   pk.curve = sbc_curve_br(curve); pk.q = (sbc_u8*)point; pk.qlen = pl;
-  if (br_ecdsa_vrfy_raw_get_default()(br_ec_get_default(), h, sbc_hlen(bits), &pk, sig, sl)) *ok = 1;
+  if (br_ecdsa_vrfy_raw_get_default()(sbc_ec(pk.curve), h, sbc_hlen(bits), &pk, sig, sl)) *ok = 1;
   return SBC_OK;
 }
 
@@ -9887,12 +9895,12 @@ static int sbc_ec_point_ok(int curve, const sbc_u8* point, size_t pl) {
   sbc_u8 q[133];
   memcpy(q, point, pl);
   sbc_u8 one[1] = { 1 };
-  return br_ec_get_default()->mul(q, pl, one, 1, sbc_curve_br(curve)) != 0;
+  return sbc_ec(sbc_curve_br(curve))->mul(q, pl, one, 1, sbc_curve_br(curve)) != 0;
 }
 static int sbc_ec_keygen(int curve, sbc_buf* out) {
   br_ec_private_key sk; br_ec_public_key pk;
   sbc_u8 kb[BR_EC_KBUF_PRIV_MAX_SIZE], pb[BR_EC_KBUF_PUB_MAX_SIZE];
-  const br_ec_impl* impl = br_ec_get_default();
+  const br_ec_impl* impl = sbc_ec(sbc_curve_br(curve));
   if (!br_ec_keygen(&sbc_prng, impl, &sk, kb, sbc_curve_br(curve))) return SBC_OPERATION;
   if (!br_ec_compute_pub(impl, &pk, pb, &sk)) return SBC_OPERATION;
   size_t need = br_encode_ec_pkcs8_der(0, &sk, &pk);
@@ -10059,8 +10067,9 @@ static int sbc_ecdh(int curve, const sbc_u8* pkcs8, size_t kl, const sbc_u8* pee
   if (sk->curve == sbc_curve_br(curve) && fs && pl == 1 + 2 * fs && peer[0] == 4) {
     sbc_u8 pt[133];
     memcpy(pt, peer, pl);
-    if (br_ec_get_default()->mul(pt, pl, sk->x, sk->xlen, sk->curve)) {
-      size_t xl; size_t xo = br_ec_get_default()->xoff(sk->curve, &xl);
+    const br_ec_impl* impl = sbc_ec(sk->curve);
+    if (impl->mul(pt, pl, sk->x, sk->xlen, sk->curve)) {
+      size_t xl; size_t xo = impl->xoff(sk->curve, &xl);
       sbc_put(out, pt + xo, xl); rc = SBC_OK;
     }
   }

package/src/subtle/README.md

@@ -12,10 +12,10 @@ uses it.
 
 | Need | Source | Licence |
 | --- | --- | --- |
-| SHA-1/256/384/512, HMAC, HKDF | BearSSL 0.6 | MIT |
-| RSA (private and public operations, key generation, PKCS#1 v1.5 padding), RSA-OAEP | BearSSL 0.6 | MIT |
-| ECDSA and ECDH on P-256, P-384, P-521, EC key generation | BearSSL 0.6 | MIT |
-| AES (constant-time), CBC, CTR, GCM | BearSSL 0.6 | MIT |
+| SHA-1/256/384/512, HMAC, HKDF | BearSSL (master 7bea48e) | MIT |
+| RSA (private and public operations, key generation, PKCS#1 v1.5 padding), RSA-OAEP | BearSSL (master 7bea48e) | MIT |
+| ECDSA and ECDH on P-256, P-384, P-521, EC key generation | BearSSL (master 7bea48e) | MIT |
+| AES (constant-time), CBC, CTR, GCM | BearSSL (master 7bea48e) | MIT |
 | Ed25519, X25519 | Monocypher 4.0.2, vendored in `vendor/` | BSD-2-Clause or CC0-1.0 |
 
 BearSSL is already linked into every embedded sprout (standalone binaries and sproutd) for

package/src/subtle/subtle.c

@@ -183,6 +183,17 @@ static int sbc_oid_eq(const sbc_u8* a, size_t al, const sbc_u8* b, size_t bl) {
 
 /* Curve codes used on the wire to JS: 1 = P-256, 2 = P-384, 3 = P-521. */
 static int sbc_curve_br(int c) { return c == 1 ? BR_EC_secp256r1 : c == 2 ? BR_EC_secp384r1 : c == 3 ? BR_EC_secp521r1 : 0; }
+/* BearSSL's default EC implementation is the portable m31 (m15 where there is no 64-bit multiply
+   result). P-256 has a 64-bit specialisation, m64, that is roughly 3x faster to sign and 5x to verify,
+   but BearSSL never selects it by itself. br_ec_p256_m64_get() returns null on a target without a
+   128-bit multiply, and m64 only knows P-256, so every other curve keeps the default. */
+static const br_ec_impl* sbc_ec(int br_curve) {
+  if (br_curve == BR_EC_secp256r1) {
+    const br_ec_impl* fast = br_ec_p256_m64_get();
+    if (fast) return fast;
+  }
+  return br_ec_get_default();
+}
 static int sbc_curve_from_br(int c) { return c == BR_EC_secp256r1 ? 1 : c == BR_EC_secp384r1 ? 2 : c == BR_EC_secp521r1 ? 3 : 0; }
 static size_t sbc_curve_size(int c) { return c == 1 ? 32 : c == 2 ? 48 : c == 3 ? 66 : 0; }
 static void sbc_curve_oid(int c, const sbc_u8** o, size_t* n) {
@@ -380,7 +391,7 @@ static int sbc_decode(int pkcs8, const sbc_u8* der, size_t len, sbc_buf* out) {
       if (cv) {
         sbc_u8 pub[133];
         br_ec_public_key pk;
-        if (br_ec_compute_pub(br_ec_get_default(), &pk, pub, sk) != 0) {
+        if (br_ec_compute_pub(sbc_ec(sk->curve), &pk, pub, sk) != 0) {
           sbc_put1(out, SBC_K_EC); sbc_put1(out, (sbc_u8)cv); sbc_put1(out, 1);
           sbc_field(out, pk.q, pk.qlen);
           /* The scalar, left padded to the field size as JWK d wants it. */
@@ -677,7 +688,7 @@ static int sbc_ecdsa_sign(int bits, const sbc_u8* key, size_t kl, const sbc_u8*
   sbc_u8 h[64], sig[132];
   rc = SBC_OPERATION;
   if (sbc_digest(bits, m, ml, h)) {
-    size_t n = br_ecdsa_sign_raw_get_default()(br_ec_get_default(), sbc_hash(bits), h, sk, sig);
+    size_t n = br_ecdsa_sign_raw_get_default()(sbc_ec(sk->curve), sbc_hash(bits), h, sk, sig);
     if (n) { sbc_put(out, sig, n); rc = SBC_OK; }
   }
   free(dc);
@@ -692,7 +703,7 @@ static int sbc_ecdsa_verify(int bits, int curve, const sbc_u8* point, size_t pl,
   if (sl != 2 * fs) return SBC_OK;
   br_ec_public_key pk;
   pk.curve = sbc_curve_br(curve); pk.q = (sbc_u8*)point; pk.qlen = pl;
-  if (br_ecdsa_vrfy_raw_get_default()(br_ec_get_default(), h, sbc_hlen(bits), &pk, sig, sl)) *ok = 1;
+  if (br_ecdsa_vrfy_raw_get_default()(sbc_ec(pk.curve), h, sbc_hlen(bits), &pk, sig, sl)) *ok = 1;
   return SBC_OK;
 }
 /* A public point is valid when it is on the curve (the group is prime order, cofactor 1). */
@@ -702,12 +713,12 @@ static int sbc_ec_point_ok(int curve, const sbc_u8* point, size_t pl) {
   sbc_u8 q[133];
   memcpy(q, point, pl);
   sbc_u8 one[1] = { 1 };
-  return br_ec_get_default()->mul(q, pl, one, 1, sbc_curve_br(curve)) != 0;
+  return sbc_ec(sbc_curve_br(curve))->mul(q, pl, one, 1, sbc_curve_br(curve)) != 0;
 }
 static int sbc_ec_keygen(int curve, sbc_buf* out) {
   br_ec_private_key sk; br_ec_public_key pk;
   sbc_u8 kb[BR_EC_KBUF_PRIV_MAX_SIZE], pb[BR_EC_KBUF_PUB_MAX_SIZE];
-  const br_ec_impl* impl = br_ec_get_default();
+  const br_ec_impl* impl = sbc_ec(sbc_curve_br(curve));
   if (!br_ec_keygen(&sbc_prng, impl, &sk, kb, sbc_curve_br(curve))) return SBC_OPERATION;
   if (!br_ec_compute_pub(impl, &pk, pb, &sk)) return SBC_OPERATION;
   size_t need = br_encode_ec_pkcs8_der(0, &sk, &pk);
@@ -885,8 +896,9 @@ static int sbc_ecdh(int curve, const sbc_u8* pkcs8, size_t kl, const sbc_u8* pee
   if (sk->curve == sbc_curve_br(curve) && fs && pl == 1 + 2 * fs && peer[0] == 4) {
     sbc_u8 pt[133];
     memcpy(pt, peer, pl);
-    if (br_ec_get_default()->mul(pt, pl, sk->x, sk->xlen, sk->curve)) {
-      size_t xl; size_t xo = br_ec_get_default()->xoff(sk->curve, &xl);
+    const br_ec_impl* impl = sbc_ec(sk->curve);
+    if (impl->mul(pt, pl, sk->x, sk->xlen, sk->curve)) {
+      size_t xl; size_t xo = impl->xoff(sk->curve, &xl);
       sbc_put(out, pt + xo, xl); rc = SBC_OK;
     }
   }

package/src/subtle/subtle.test.ts

@@ -9,7 +9,7 @@ import { assembleSubtleC } from "./assemble";
 
 const bear = join(
   process.env.SPROUTBOAT_TOOLCHAIN_CACHE ?? join(homedir(), ".cache/sproutboat"),
-  "bearssl-0.6/bearssl-0.6",
+  "bearssl-7bea48e/BearSSL-7bea48e",
 );
 const lib = join(bear, "build/libbearssl.a");
 // SUBTLE_DRIVER: a prebuilt driver binary (a machine with no C compiler, or a cross-built one).

package/src/transport-embedded.js

@@ -3145,11 +3145,16 @@ typedef struct sb_async_job {
   char *host, *path, *method, *headers, *body, *out;
   size_t body_len;
 } sb_async_job;
+// sproutd runs one host per sprout among hundreds, so a few threads each; a standalone binary is the
+// only process of its app, and workerd lets one request hold 50 subrequests.
 #define SB_ASYNC_THREADS 8
+#define SB_ASYNC_THREADS_STANDALONE 32
 static pthread_mutex_t sb_async_lock = PTHREAD_MUTEX_INITIALIZER;
 static sb_async_job *sb_async_queue = 0, *sb_async_queue_tail = 0, *sb_async_done = 0, *sb_async_current = 0;
 static int sb_async_pipe[2] = { -1, -1 };
 static int sb_async_threads = 0;
+// The standalone server's way back onto its loop (uWS defer, patchAsyncWaker); set by sb_async_set_waker.
+static void (*sb_wsc_waker)(void) = 0;
 
 int sb_async_enable(void) {
   if (sb_async_pipe[0] >= 0) return sb_async_pipe[0];
@@ -3160,7 +3165,10 @@ int sb_async_enable(void) {
   }
   return sb_async_pipe[0];
 }
-int sb_async_enabled(void) { return sb_async_pipe[0] >= 0; }
+// A host runs requests off its loop when it watches the pipe (sproutd) or gave a waker (standalone).
+int sb_async_enabled(void) { return sb_async_pipe[0] >= 0 || sb_wsc_waker != 0; }
+// Only the pipe host (sproutd) has always answered fetch() with a promise; see __sbAsyncAtAnyDate.
+int sb_async_piped(void) { return sb_async_pipe[0] >= 0; }
 static void sb_async_free(sb_async_job* j) {
   free(j->host); free(j->path); free(j->method); free(j->headers); free(j->body); free(j->out); free(j);
 }
@@ -3168,8 +3176,12 @@ static void sb_async_free(sb_async_job* j) {
 static void sb_async_finish_locked(sb_async_job* j) {
   j->next = sb_async_done;
   sb_async_done = j;
-  char one = 1;
-  while (write(sb_async_pipe[1], &one, 1) < 0 && errno == EINTR) {}
+  if (sb_async_pipe[1] >= 0) {
+    char one = 1;
+    while (write(sb_async_pipe[1], &one, 1) < 0 && errno == EINTR) {}
+  }
+  // uWS's defer is thread-safe and never takes sb_async_lock, so calling it here cannot deadlock.
+  if (sb_wsc_waker) sb_wsc_waker();
 }
 static void* sb_async_thread(void* unused) {
   (void)unused;
@@ -3192,7 +3204,7 @@ static void sb_async_start(sb_async_job* j) {
   j->next = 0;
   if (sb_async_queue_tail) sb_async_queue_tail->next = j; else sb_async_queue = j;
   sb_async_queue_tail = j;
-  int spawn = sb_async_threads < SB_ASYNC_THREADS;
+  int spawn = sb_async_threads < (sb_async_pipe[0] >= 0 ? SB_ASYNC_THREADS : SB_ASYNC_THREADS_STANDALONE);
   if (spawn) sb_async_threads++;
   pthread_mutex_unlock(&sb_async_lock);
   if (!spawn) return;
@@ -3236,7 +3248,7 @@ static void (*sb_wsc_drain_hook)(void) = 0;
 // Host: the fd became readable. Fires each finished request's callback.
 void sb_async_drain(void) {
   char buf[64];
-  while (read(sb_async_pipe[0], buf, sizeof(buf)) > 0) {}
+  if (sb_async_pipe[0] >= 0) while (read(sb_async_pipe[0], buf, sizeof(buf)) > 0) {}
   if (sb_wsc_drain_hook) sb_wsc_drain_hook();
   pthread_mutex_lock(&sb_async_lock);
   sb_async_job* done = sb_async_done;
@@ -3294,7 +3306,6 @@ typedef struct sb_wsc {
 static pthread_mutex_t sb_wsc_lock = PTHREAD_MUTEX_INITIALIZER;
 static sb_wsc* sb_wscs = 0;
 static unsigned sb_wsc_next = 0;
-static void (*sb_wsc_waker)(void) = 0;
 void sb_async_set_waker(void (*wake)(void)) { sb_wsc_waker = wake; }
 static int sb_wsc_pipe_enabled(void) { return sb_async_pipe[0] >= 0; }
 static void sb_async_poke(void) {
@@ -4318,12 +4329,21 @@ 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).
+// sproutd ran fetch() off its loop, as a promise, at every compatibility date (B18). The standalone
+// server (a waker, no pipe) keeps the date its fetch() promise has always had.
 function __sbAsyncAtAnyDate() {
-  return true;
+  let res = false;
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    int sb_async_piped(void);
+    if (sb_async_piped()) res = porf_box(1, 2);
+  `;
+  return res;
 }
 
-// Whether the host runs async requests (sb_async_enable was called).
+// Whether the host runs async requests: sproutd (sb_async_enable was called) at any date, the
+// standalone server (it gave a waker) from the date its fetch() leaves the loop, so an app that
+// relied on one request at a time across an `await fetch()` keeps that until it opts in.
 function __sbHttpAsyncEnabled() {
   let res = false;
   // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
@@ -4331,7 +4351,7 @@ function __sbHttpAsyncEnabled() {
     int sb_async_enabled(void);
     if (sb_async_enabled()) res = porf_box(1, 2);
   `;
-  return res;
+  return res && (__sbAsyncAtAnyDate() || __sbCompatDate() >= "2026-11-16");
 }
 
 // The outbound client's JSON reply -> the fetch op's result.
@@ -4942,8 +4962,13 @@ function __sbEmbeddedDispatch(msg) {
   if (op === "secret.get") {
     // Secrets reach a standalone binary through the environment, the same
     // channel the launcher and the supervisor use; there is nothing to decrypt.
-    const value = __sbEnv(String(msg.name));
-    if (!value) throw new Error("secret not set: " + msg.name);
+    const raw = __sbEnv(String(msg.name));
+    if (!raw) throw new Error("secret not set: " + msg.name);
+    // __sbEnv hands back the environment's bytes as a bytestring, one char per byte, so a UTF-8 secret ("é" is
+    // C3 A9) reached the app as "é". From compatibility date 2026-11-07 it is decoded as UTF-8, as workerd's
+    // secrets are text. Bytes that are not valid UTF-8 pass through unchanged (__sbFromUtf8's rule). The broker
+    // transport is not touched: its secrets arrive as JSON, already real strings.
+    const value = __sbCompatDate() >= "2026-11-07" ? __sbFromUtf8(raw) : raw;
     return { ok: true, value };
   }
 

package/test/bearssl.ts

@@ -7,9 +7,10 @@ import { join, resolve } from "node:path";
 // The prelude carries crypto.subtle's native half on every transport, so a test that compiles a
 // handler using crypto.subtle needs BearSSL on the include path and link line, as the CLI arranges
 // for a build. Same pinned source as the CLI's src/bearssl.ts; built once into the toolchain cache.
-const VERSION = "0.6";
-const URL_ = `https://bearssl.org/bearssl-${VERSION}.tar.gz`;
-const SHA256 = "6705bba1714961b41a728dfc5debbe348d2966c117649392f8c8139efc83ff14";
+const COMMIT = "7bea48e5e850ab4cafbe68d3765cdaba13a86d6f";
+const VERSION = COMMIT.slice(0, 7);
+const URL_ = `https://bearssl.org/gitweb/?p=BearSSL;a=snapshot;h=${COMMIT};sf=tgz`;
+const SHA256 = "ed397832b1613582737d9c1ce01c1af74ad6a9e9c52a341e24433987cda0f372";
 
 const walk = async (dir: string): Promise<string[]> =>
   (
@@ -28,7 +29,7 @@ export async function bearsslEnv(): Promise<{ SB_EXTRA_CFLAGS: string; SB_EXTRA_
     process.env.SPROUTBOAT_TOOLCHAIN_CACHE ?? join(homedir(), ".cache/sproutboat"),
     `bearssl-${VERSION}-test`,
   );
-  const tree = join(root, `bearssl-${VERSION}`);
+  const tree = join(root, `BearSSL-${VERSION}`);
   const objects = join(root, "obj");
   const marker = join(objects, ".complete");
   if (!existsSync(marker)) {

package/test/fixtures/async-fetch/README.md

@@ -0,0 +1,9 @@
+Repro for standalone `fetch()` off the event loop (compatibility date 2026-11-16).
+
+```sh
+bun slow.ts 19100 &                                   # /slow?delay=MS, /echo
+sproutboat build --standalone --target host .         # compatibility_date 2026-11-16
+PORT=19201 SB_EGRESS_ALLOW=127.0.0.1 ./dist/af-fan &
+curl 'localhost:19201/fan?n=20&delay=100'             # about 110 ms; 2,040 ms at 2026-11-15
+curl 'localhost:19201/order?delay=200' & curl 'localhost:19201/order?delay=200'   # interleave from 11-16
+```

package/test/fixtures/async-fetch/slow.ts

@@ -0,0 +1,17 @@
+// bun /tmp/af/slow.ts PORT : /slow?delay=ms answers "slow-<i>" after delay; /echo returns the body
+Bun.serve({
+  port: Number(process.argv[2] || 19100),
+  hostname: "0.0.0.0",
+  async fetch(req) {
+    const u = new URL(req.url);
+    if (u.pathname === "/slow") {
+      await Bun.sleep(Number(u.searchParams.get("delay") || 100));
+      return new Response("slow-" + (u.searchParams.get("i") ?? "x"));
+    }
+    if (u.pathname === "/echo")
+      return new Response("echo:" + (await req.text()) + ":" + req.headers.get("x-test"), {
+        headers: { "content-type": "text/x-echo" },
+      });
+    return new Response("nf", { status: 404 });
+  },
+});

package/test/fixtures/async-fetch/sproutboat.jsonc

@@ -0,0 +1,5 @@
+{
+  "name": "af-fan",
+  "main": "src/index.js",
+  "compatibility_date": "2026-11-16",
+}

package/test/fixtures/async-fetch/src/index.js

@@ -0,0 +1,50 @@
+let counter = 0;
+export default {
+  async fetch(request) {
+    const u = new URL(request.url);
+    if (u.pathname === "/ping") return new Response("ok");
+    const base = u.searchParams.get("base") || "http://127.0.0.1:19100";
+    if (u.pathname === "/fan") {
+      const n = Number(u.searchParams.get("n") || 20);
+      const delay = u.searchParams.get("delay") || "100";
+      const t0 = Date.now();
+      const rs = await Promise.all(
+        Array.from({ length: n }, (_, i) => fetch(base + "/slow?i=" + i + "&delay=" + delay).then((r) => r.text())),
+      );
+      return Response.json({ n, ms: Date.now() - t0, bodies: rs.slice(0, 3), last: rs[n - 1] });
+    }
+    if (u.pathname === "/one") {
+      const r = await fetch(base + "/slow?delay=" + (u.searchParams.get("delay") || "0"));
+      return new Response(await r.text(), { status: r.status });
+    }
+    if (u.pathname === "/post") {
+      const r = await fetch(base + "/echo", { method: "POST", body: "hello-" + ++counter, headers: { "x-test": "1" } });
+      return Response.json({ status: r.status, text: await r.text(), ct: r.headers.get("content-type") });
+    }
+    if (u.pathname === "/refuse") {
+      try {
+        await fetch("http://127.0.0.1:1/");
+        return new Response("no error", { status: 500 });
+      } catch (e) {
+        return Response.json({ rejected: true, name: e.name, message: String(e.message) });
+      }
+    }
+    if (u.pathname === "/abort") {
+      const ac = new AbortController();
+      setTimeout(() => ac.abort(), 20);
+      try {
+        await fetch(base + "/slow?delay=500", { signal: ac.signal });
+        return new Response("no abort", { status: 500 });
+      } catch (e) {
+        return Response.json({ aborted: true, name: e.name });
+      }
+    }
+    if (u.pathname === "/order") {
+      // global state across an await fetch
+      const mine = ++counter;
+      await fetch(base + "/slow?delay=" + (u.searchParams.get("delay") || "50")).then((r) => r.text());
+      return Response.json({ mine, after: counter });
+    }
+    return new Response("not found", { status: 404 });
+  },
+};

package/test/standalone-restart-stress.py

@@ -0,0 +1,348 @@
+#!/usr/bin/env python3
+"""Restart stress for a standalone binary (docs/standalone.md, "Restarting without dropping a request").
+
+    standalone-restart-stress.py BINARY --mode MODE [--restarts N] [--keepalive N] [--fresh N] [--writes]
+
+Linux. Continuous load against one port while the binary is replaced N times; the count that matters
+is how many requests failed. MODE says how the swap is done:
+
+  overlap     the old recipe: start the new copy on the same port (SO_REUSEPORT), SIGTERM the old one.
+              Closing the old listener resets whatever sits in its accept queue.
+  stop-start  SIGTERM the old copy, wait for it, start the new one. Nothing listens in between.
+  systemd     a socket + service pair of user units under `systemd --user`; each swap is
+              `systemctl --user restart`. The socket stays open, so connections queue.
+  usr2        run the binary directly; each swap replaces the file on disk (install + rename) and sends
+              SIGUSR2. The running copy starts the new one on its listening socket and drains.
+
+The load is FRESH threads (a connection per request) and KEEPALIVE threads (one connection reused,
+as a proxy's pool does). A reused connection the server closes in the same instant is retried once on
+a new connection, as every client retries an idempotent request, and counted separately. With --writes
+half the requests are POST /w against a D1 table (the app's /n route returns the row count), and the
+run ends by checking that every acknowledged write is in the table, so a swap that loses or doubles one
+shows up. The app is expected to answer GET /x with 200 and, for --writes, POST /w with the new row id.
+
+Prints one JSON line; exit status 1 on any failed request or lost write.
+"""
+import argparse, http.client, json, os, shutil, signal, socket, subprocess, sys, tempfile, threading, time
+from pathlib import Path
+
+ap = argparse.ArgumentParser()
+ap.add_argument("binary")
+ap.add_argument("--mode", required=True, choices=["overlap", "stop-start", "systemd", "usr2"])
+ap.add_argument("--restarts", type=int, default=30)
+ap.add_argument("--keepalive", type=int, default=3)
+ap.add_argument("--fresh", type=int, default=3)
+ap.add_argument("--writes", action="store_true")
+ap.add_argument("--fresh-delay-ms", type=float, default=3, help="pause between a fresh loader's requests (conntrack: every connection leaves a TIME_WAIT entry, and a full nf_conntrack table silently drops SYNs)")
+ap.add_argument("--settle-ms", type=int, default=250, help="pause between swaps")
+ap.add_argument("--env", action="append", default=[], help="KEY=value for the binary")
+args = ap.parse_args()
+
+binary = Path(args.binary).resolve()
+scratch = Path(tempfile.mkdtemp(prefix="sb-restart-"))
+installed = scratch / "app"
+shutil.copy(binary, installed)
+installed.chmod(0o755)
+data = scratch / "data"
+data.mkdir()
+with socket.socket() as s:
+    s.bind(("127.0.0.1", 0))
+    port = s.getsockname()[1]
+env = dict(os.environ, PORT=str(port), SB_DATA_DIR=str(data))
+for item in args.env:
+    k, _, v = item.partition("=")
+    env[k] = v
+
+stop = [False]
+lock = threading.Lock()
+stats = {"ok": 0, "retried": 0, "writes_acked": 0}
+failures = []
+latencies = []
+t_start = time.time()
+
+
+def note_failure(kind, err):
+    with lock:
+        failures.append({"t": round(time.time() - t_start, 3), "kind": kind, "error": err})
+
+
+def one_request(conn, write):
+    t0 = time.time()
+    if write:
+        conn.request("POST", "/w", body=b"x")
+    else:
+        conn.request("GET", "/x")
+    r = conn.getresponse()
+    body = r.read()
+    dt = time.time() - t0
+    with lock:
+        latencies.append(dt)
+    return r.status, body.decode(errors="replace"), r.will_close
+
+
+def record(status, body, write, kind):
+    if status == 200 or (write and status in (200, 201)):
+        with lock:
+            stats["ok"] += 1
+            if write:
+                stats["writes_acked"] += 1
+    else:
+        note_failure(kind, f"status {status} {body[:40]}")
+
+
+def fresh_loader(index):
+    n = 0
+    while not stop[0]:
+        time.sleep(args.fresh_delay_ms / 1000)
+        n += 1
+        write = args.writes and (n + index) % 2 == 0
+        c = http.client.HTTPConnection("127.0.0.1", port, timeout=20)
+        try:
+            status, body, _ = one_request(c, write)
+            record(status, body, write, "fresh")
+        except Exception as e:
+            note_failure("fresh", type(e).__name__ + ": " + str(e)[:80])
+        finally:
+            c.close()
+
+
+def keepalive_loader(index):
+    conn = None
+    n = 0
+    while not stop[0]:
+        n += 1
+        write = args.writes and (n + index) % 2 == 0
+        reused = conn is not None
+        if conn is None:
+            conn = http.client.HTTPConnection("127.0.0.1", port, timeout=20)
+        try:
+            status, body, closing = one_request(conn, write)
+            if closing:
+                conn.close()
+                conn = None
+            record(status, body, write, "keepalive")
+        except Exception as e:
+            conn.close()
+            conn = None
+            if not reused or write:
+                # A write is not retried: it may have been applied, and the point is to see it fail.
+                note_failure("keepalive", ("new connection: " if not reused else "write on reused connection: ") + type(e).__name__ + ": " + str(e)[:80])
+                continue
+            c2 = http.client.HTTPConnection("127.0.0.1", port, timeout=20)
+            try:
+                status, body, _ = one_request(c2, False)
+                with lock:
+                    stats["retried"] += 1
+                record(status, body, False, "keepalive")
+            except Exception as e2:
+                note_failure("keepalive", "retry failed: " + type(e2).__name__ + ": " + str(e2)[:80])
+            finally:
+                c2.close()
+
+
+def conntrack():
+    try:
+        return int(Path("/proc/sys/net/netfilter/nf_conntrack_count").read_text())
+    except OSError:
+        return 0
+
+
+def wait_ready(timeout=10):
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        try:
+            c = http.client.HTTPConnection("127.0.0.1", port, timeout=2)
+            c.request("GET", "/x")
+            if c.getresponse().status == 200:
+                c.close()
+                return True
+        except Exception:
+            pass
+        time.sleep(0.05)
+    return False
+
+
+procs = []
+unit = f"sbrs-{os.getpid()}"
+unit_dir = Path.home() / ".config/systemd/user"
+log_n = [0]
+
+
+def spawn(extra_env=None):
+    log_n[0] += 1
+    log = open(scratch / f"run{log_n[0]}.log", "w")
+    p = subprocess.Popen([str(installed)], cwd=scratch, env=dict(env, **(extra_env or {})), stdout=log, stderr=log, start_new_session=True)
+    procs.append(p)
+    return p
+
+
+def exited(p, limit):
+    try:
+        p.wait(limit)
+        return True
+    except subprocess.TimeoutExpired:
+        return False
+
+
+def alive(pid, child=None):
+    """Is pid still running? A zombie nobody reaped (the container case) is gone, and our own child is reaped here."""
+    if child is not None:
+        return child.poll() is None
+    try:
+        with open(f"/proc/{pid}/stat") as f:
+            return f.read().rsplit(")", 1)[1].split()[0] != "Z"
+    except OSError:
+        return False
+
+
+def replace_binary():
+    tmp = scratch / "app.new"
+    shutil.copy(binary, tmp)
+    tmp.chmod(0o755)
+    os.replace(tmp, installed)
+
+
+def sctl(*a):
+    return subprocess.run(["systemctl", "--user", *a], capture_output=True, text=True)
+
+
+summary = {"mode": args.mode, "binary": str(binary), "port": port}
+threads = []
+try:
+    while conntrack() > 20000:
+        time.sleep(5)
+    summary["conntrack_at_start"] = conntrack()
+    swap_ms = []
+    if args.mode == "systemd":
+        # Real unit files, not systemd-run: a transient service is garbage-collected when it stops,
+        # which takes its socket with it. These are the units docs/standalone.md describes.
+        unit_dir.mkdir(parents=True, exist_ok=True)
+        (unit_dir / f"{unit}.socket").write_text(f"[Socket]\nListenStream=127.0.0.1:{port}\nBacklog=4096\nTriggerLimitIntervalSec=0\n")
+        (unit_dir / f"{unit}.service").write_text(
+            f"[Unit]\nRequires={unit}.socket\n# A stress run restarts several times a second; the default limit (5 starts in 10 s) would fail the unit.\nStartLimitIntervalSec=0\n\n[Service]\nExecStart={installed}\nWorkingDirectory={scratch}\n"
+            f"Environment=PORT={port} SB_DATA_DIR={data}\n"
+            + "".join(f"Environment={item}\n" for item in args.env)
+            + "KillSignal=SIGTERM\nTimeoutStopSec=30\nMemoryMax=256M\nMemorySwapMax=0\n"
+        )
+        for step in (["daemon-reload"], ["start", f"{unit}.socket"]):
+            r = sctl(*step)
+            if r.returncode:
+                raise SystemExit("systemctl " + " ".join(step) + " failed: " + r.stderr)
+    else:
+        current = spawn()
+        newest_pid = current.pid
+    if not wait_ready():
+        raise SystemExit("the binary did not answer GET /x")
+    t_start = time.time()
+    for i in range(args.fresh):
+        threads.append(threading.Thread(target=fresh_loader, args=(i,), daemon=True))
+    for i in range(args.keepalive):
+        threads.append(threading.Thread(target=keepalive_loader, args=(i,), daemon=True))
+    for t in threads:
+        t.start()
+    time.sleep(1)
+    seen_logs = set()
+    for i in range(args.restarts):
+        t0 = time.time()
+        if args.mode == "overlap":
+            nxt = spawn()
+            time.sleep(0.4)  # up and accepting beside the old one
+            current.send_signal(signal.SIGTERM)
+            if not exited(current, 15):
+                note_failure("restart", "old copy did not exit in 15 s")
+                current.kill()
+            current = nxt
+        elif args.mode == "stop-start":
+            current.send_signal(signal.SIGTERM)
+            if not exited(current, 15):
+                note_failure("restart", "old copy did not exit in 15 s")
+                current.kill()
+            current = spawn()
+        elif args.mode == "systemd":
+            replace_binary()
+            r = sctl("restart", f"{unit}.service")
+            if r.returncode:
+                note_failure("restart", "systemctl restart: " + r.stderr[:80])
+        elif args.mode == "usr2":
+            replace_binary()
+            pid = newest_pid
+            os.kill(pid, signal.SIGUSR2)
+            # The successor is the old copy's child; it logs its pid into the old copy's log file.
+            deadline = time.time() + 15
+            newest_pid = None
+            logfile = scratch / f"run1.log"
+            while time.time() < deadline and newest_pid is None:
+                for line in logfile.read_text().splitlines():
+                    if "restart: started" in line and line not in seen_logs:
+                        seen_logs.add(line)
+                        newest_pid = int(line.rsplit(" ", 1)[1])
+                if newest_pid is None:
+                    time.sleep(0.05)
+            if newest_pid is None:
+                note_failure("restart", "no successor started")
+                break
+            # wait for the old pid to be gone
+            while time.time() < deadline and alive(pid, current if i == 0 else None):
+                time.sleep(0.02)
+            if not wait_ready(10):
+                note_failure("restart", "successor never answered")
+        swap_ms.append(round((time.time() - t0) * 1000))
+        time.sleep(args.settle_ms / 1000)
+    time.sleep(1)
+    stop[0] = True
+    for t in threads:
+        t.join(30)
+    lost = None
+    if args.writes:
+        try:
+            c = http.client.HTTPConnection("127.0.0.1", port, timeout=20)
+            c.request("GET", "/n")
+            rows = int(c.getresponse().read().decode().strip())
+            lost = stats["writes_acked"] - rows
+            summary["rows_in_table"] = rows
+        except Exception as e:
+            lost = f"could not read /n: {e}"
+    lat = sorted(latencies)
+    summary.update({
+        "restarts": args.restarts,
+        "swap_ms_median": sorted(swap_ms)[len(swap_ms) // 2] if swap_ms else 0,
+        "swap_ms_max": max(swap_ms or [0]),
+        "requests_ok": stats["ok"],
+        "reused_retried": stats["retried"],
+        "writes_acked": stats["writes_acked"],
+        "writes_unaccounted": lost,
+        "failed": len(failures),
+        "failures": failures[:12],
+        "latency_ms": {"p50": round(lat[len(lat) // 2] * 1000, 2) if lat else 0, "p99": round(lat[int(len(lat) * 0.99)] * 1000, 1) if lat else 0, "max": round(lat[-1] * 1000, 1) if lat else 0},
+        "seconds": round(time.time() - t_start, 1),
+        "conntrack_at_end": conntrack(),
+        "loaders": {"fresh": args.fresh, "keepalive": args.keepalive},
+    })
+finally:
+    stop[0] = True
+    for p in procs:
+        if p.poll() is None:
+            try:
+                os.killpg(p.pid, signal.SIGTERM)
+            except ProcessLookupError:
+                pass
+    if args.mode == "usr2":
+        # successors are not our children: stop each by the pid it logged
+        for log in scratch.glob("run*.log"):
+            for line in log.read_text().splitlines():
+                if "restart: started" in line:
+                    try:
+                        os.kill(int(line.rsplit(" ", 1)[1]), signal.SIGKILL)
+                    except (ProcessLookupError, ValueError):
+                        pass
+    if args.mode == "systemd":
+        sctl("stop", f"{unit}.service", f"{unit}.socket")
+        for ext in ("socket", "service"):
+            (unit_dir / f"{unit}.{ext}").unlink(missing_ok=True)
+        sctl("daemon-reload")
+    time.sleep(0.5)
+    if not os.environ.get("KEEP_SCRATCH"):
+        shutil.rmtree(scratch, ignore_errors=True)
+    print(json.dumps(summary))
+bad = summary.get("failed", 1) or (summary.get("writes_unaccounted") not in (None, 0))
+sys.exit(1 if bad else 0)