@sproutboat/runtime 0.16.0 → 0.17.1

package/CHANGELOG.md

@@ -1,5 +1,73 @@
 # @sproutboat/runtime
 
+## 0.17.1
+
+### Patch Changes
+
+- 3dabc97: Scheduled, queue and Durable Object alarm triggers answer `204` with no body again. The prelude built that reply as `new Response("", { status: 204 })`, which the Fetch-spec `Response` of 0.17.0 rejects (an empty string is still a body), so the first cron or alarm failed, and on the alarm path the error took the server down.
+
+## 0.17.0
+
+### Minor Changes
+
+- a96a443: Apply static asset redirects and header rules in dev and standalone asset bindings, preserving binary response bodies.
+- 6e88627: Standalone sprouts stream `ReadableStream` response bodies. The status and headers go out as soon as the handler returns, and each chunk reaches the client as it is produced (chunked encoding), so Server-Sent Events, progress output and long responses work. A client that disconnects cancels the stream. Hosts without the streaming server (sproutd's workers, for now) still read the stream to the end and send it buffered.
+
+### Patch Changes
+
+- 5d4d40b: A host that runs an event loop can let `fetch()` run without blocking the sprout: after `sb_async_enable()`, outbound requests run on up to 8 threads and resolve their promises when the host calls `sb_async_drain()`. Nothing changes for standalone sprouts, where `fetch()` stays synchronous.
+- 6880f60: Add an opt-in bounded multi-session broker worker with private supervisor control.
+  Fence queue acknowledgements to durable delivery claims and retain recoverable alarm deliveries across process crashes in broker and embedded transports.
+  
+  Resume native R2 downloads until completion or renewed backpressure instead of leaving large responses stalled.
+  
+  Retain partially written TCP replies until drain and serialize pipelined replies so large broker-backed R2 reads cannot truncate or interleave frames.
+  
+  Honor wildcard, weak and list-based If-None-Match conditions on broker direct downloads.
+  
+  Move D1 queries, batches, exec and backups off the shared broker event loop into two lazy SQL threads per broker process. Preserve database affinity, transaction rollback and session isolation, and bound queued work with per-session admission and queue deadlines. Running SQLite statements remain non-preemptible; keep shared mode opt-in.
+  
+  Enforce shared D1 execution budgets through a capability-protected native SQLite progress hook. Interrupted batches roll back and lanes remain usable. A broker watchdog revokes all sessions if native work cannot be interrupted; uncertain SQL outcomes are never automatically retried. Build the small SQLite extension during host/image preparation.
+- 846519f: Fixes found by the new differential conformance suite against workerd:
+  
+  - `JSON.stringify` of a cyclic object throws `TypeError` instead of crashing the process (it recursed until the native stack overflowed), so one request can no longer take a worker down.
+  - `structuredClone` follows the structured-clone algorithm: cycles, `Map`, `Set`, `Date`, `RegExp`, typed arrays, `DataView` and errors survive the copy, and functions and symbols throw `DataCloneError`. It was a JSON round-trip that lost every non-JSON type and also crashed on cycles.
+  - `Event`, `CustomEvent`, `EventTarget`, `AbortSignal` (`abort`, `timeout`, `any`, `throwIfAborted`) and `AbortController` exist.
+  - `Object.prototype.toString` names typed arrays (`[object Uint8Array]`, not `[object Object]`).
+- b47aad4: Outbound `fetch()` sends the port in `Host` when it isn't the scheme's default (`Host: api.example.com:8080`), as HTTP/1.1 requires. A sandboxed host can now open outbound connections on a sprout's behalf: with `SB_EGRESS_FD` set, `fetch()` asks that socket for a connected socket instead of resolving and connecting itself.
+- f19ca0d: `error.stack` is a string, V8's first line (`TypeError: message`), instead of `undefined`, for every error type including errors the runtime throws. Porffor keeps no frames to list after it.
+- ddb0f9d: Response, Request and Blob follow the Fetch spec, and binary bodies reach the client intact:
+  
+  - A `Uint8Array` or `ArrayBuffer` response body is sent as its bytes. It was sent as text: `new Response(new Uint8Array([104, 105]))` reached the client as `104,105`, and an `ArrayBuffer` as `[object ArrayBuffer]`.
+  - `Response` has `statusText`, `type`, `bodyUsed` and `Response.error()`. A status outside 200–599 throws `RangeError`, a body with 101/204/205/304 throws `TypeError`, and `arrayBuffer()`/`text()` handle byte bodies (UTF-8 both ways).
+  - `Request` normalizes its URL and rejects relative or invalid ones, has `redirect` and `bodyUsed`, rejects a body on GET/HEAD, and sets the default content type for string and `URLSearchParams` bodies.
+  - A body can be read once: a second `text()`/`json()`/`arrayBuffer()`/`blob()` throws `TypeError`.
+  - `Blob` holds bytes, with `size`, `type`, `slice` (negative indices too), and promise-returning `text`/`arrayBuffer`/`bytes`. `File` exists. `FormData` stores a `Blob` value as a `File` named by its filename, and `new Response(formData)` sends multipart/form-data.
+- f201b58: `fetch(request)` sends the Request's method, headers and body (it sent a plain GET), and `init` overrides them field by field as in workerd. `fetch(new URL(...))` works. An uncaught exception's 500 response has no content type again, as in workerd.
+- 08d0192: Builds are fast again: the URLSearchParams serializer added in the previous release doubled native compile time (a hello-world handler went from 6.6 s to 13.4 s); it now encodes in one pass and compiles in 6.8 s.
+- 6d6ae43: `Headers` is iterable (`new Map(headers)`, `[...headers]`, `Object.fromEntries(headers)`), and `new Headers([["name", "value"]])` reads the pairs instead of producing headers named "0", "1"...
+- 9fdf3fa: Upgrade the verified vendored Porffor pin to Alpha 18 (`deda494`). Alpha 18 brings spec BigInt arithmetic and bitwise operators, iterator helpers, Set methods, `Array.fromAsync`, Atomics, resizable ArrayBuffers, explicit resource management, a rewritten Temporal, an on-demand Intl polyfill, and many RegExp, Promise and Object spec fixes. Three downstream workarounds are dropped because upstream now covers them: the typed-array read and write bounds checks (#238, #241), the `toJSON` step in `JSON.stringify` (Alpha 18 also adds the replacer argument), and the Web Streams adapter for dynamic array iterator lookup. The remaining patches are unchanged.
+- 4c78d83: Match the Fetch spec and workerd for common responses: string bodies default to `text/plain;charset=UTF-8`, `Response.json` sets `application/json`, and `Response.redirect` serializes its URL (`https://example.com` becomes `https://example.com/`) with a null body.
+- 088cad0: Shared-object (split) builds no longer crash on start or lose the Web Streams classes.
+  
+  - **Toolchain:** split output prefixes module globals with `pg_`. A global named like a libc symbol (the prelude's `clone`, or an app's `hash` or `search`) bound to libc instead, so the runtime wrote into libc's code and every worker crashed. Internal `__` globals keep their names. Standalone builds are unchanged, because their globals are `static`.
+  - **Runtime:** the Web Streams polyfill installs each class with its own `globalThis.X =` assignment. Where the prelude is a separate unit, Porffor resolved `new ReadableStream()` in app code at compile time and, seeing only a dynamic install, compiled it to a ReferenceError. `gen-streams.ts` now fails if an export of the polyfill is not installed.
+- 6e42051: A `ReadableStream` response body is sent. The stream is read to the end and the body sent buffered (at most 32 MiB). Before, the client received the text `[object ReadableStream]`. As in workerd, chunks must be bytes, and a stream of strings answers 500. Streamed (progressive) delivery is a separate step.
+- 9dc109d: `TextEncoderStream` and `TextDecoderStream` exist. The decoder runs `TextDecoder` in streaming mode, so a character split across chunks decodes correctly, and the encoder holds a lone high surrogate until the next chunk.
+- 28b0c39: `URL` behaves like the WHATWG URL: `new URL(path, base)`, setters for every part (`url.hostname = ...`, `port`, `protocol`, `host`, `search`, `hash`, `href`), default ports dropped, dot segments resolved, percent-encoding, `URL.canParse`, and `searchParams` changes written back into the URL. `JSON.stringify` calls `toJSON`, so a `Date` serializes as its ISO string (it was `{}`) and a `URL` as its href.
+- 6b64985: A fetch handler's response no longer waits for its `ctx.waitUntil` work: the response goes out as soon as the handler returns and the background work keeps running, still capped at 25 s, as in workerd. A handler that scheduled 1.5 s of background work used to answer 1.5 s late. The cap's timer is also cleared once the work finishes, so a sprout no longer keeps a timer pending for 25 s after every `waitUntil`. `scheduled` and `queue` handlers still finish their `waitUntil` work before they reply.
+- eec94f1: Web API fixes found by the conformance suite against workerd:
+  
+  - `Headers` follows the Fetch spec: `get` joins repeated values with `", "`, iteration is sorted by name with values combined (each `Set-Cookie` listed separately), `getSetCookie()` exists, values are trimmed, and invalid names or values throw `TypeError`. Each appended header still reaches the wire as its own line.
+  - `TextDecoder` is the WHATWG UTF-8 decoder. Characters outside the BMP (emoji) decode correctly, invalid bytes become U+FFFD (or throw with `fatal`), the BOM is stripped unless `ignoreBOM`, and `{ stream: true }` keeps an incomplete sequence for the next chunk.
+  - `toLowerCase`/`toUpperCase` map non-ASCII letters (Latin, Greek, Cyrillic and the rest of the BMP's simple mappings). They mapped ASCII only.
+  - `new URLSearchParams(init)` accepts a record, a sequence of pairs or another `URLSearchParams`. Only strings worked; `{ a: "1" }` gave `%5Bobject+Object%5D=`.
+  - `atob` ignores ASCII whitespace and throws `InvalidCharacterError` on invalid input, and `btoa` throws on characters above U+00FF.
+  - `queueMicrotask` exists.
+  - URL hosts are converted to ASCII (Punycode): `new URL("http://münchen.test").host` is `xn--mnchen-3ya.test`.
+  - `crypto.subtle.digest` supports SHA-1 and MD5, and HMAC works with SHA-1. `exportKey("raw")`, `generateKey` for HMAC and workerd's `crypto.subtle.timingSafeEqual` exist, and imported keys report `algorithm.length`. Errors carry WebCrypto's names (`NotSupportedError`, `InvalidAccessError`), and `getRandomValues` over 65,536 bytes throws `QuotaExceededError`.
+  - `setTimeout(fn, 0)` and `setInterval(fn, 0)` fire on Linux. uSockets arms timers with `timerfd_settime`, and a zero expiry disarms the timer, so a zero-delay timer never ran (macOS fired it). Timers are armed at 1 ms at least.
+
 ## 0.16.0
 
 ### Minor Changes

package/WEB_STREAMS.md

@@ -9,9 +9,13 @@ Native regression tests cover default readers, locking, pending reads,
 cancellation, source errors, array conversion, writable sinks, pipeTo,
 pipeThrough, transforms, tee, pull sources, byte streams and BYOB reads.
 This is API support for streams in memory, not progressive HTTP transport.
-Request and Response bodies and outbound fetch remain buffered. Passing a
-ReadableStream as an HTTP body is not supported. TextEncoderStream,
-TextDecoderStream, CompressionStream and DecompressionStream are not included.
+A ReadableStream response body is streamed by a standalone sprout's native server:
+the status and headers go out at once and each chunk is written as it is produced
+(chunked encoding), so Server-Sent Events and long responses work. Chunks must be bytes.
+Hosts that do not stream yet (sproutd's workers) read the stream to the end and send it
+buffered, at most 32 MiB. Request bodies and outbound fetch remain buffered.
+TextEncoderStream and TextDecoderStream are included; CompressionStream and
+DecompressionStream are not.
 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.16.0",
+  "version": "0.17.1",
   "license": "MIT",
   "type": "module",
   "repository": {

package/src/asset-rules.test.js

@@ -0,0 +1,125 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import {
+  matchRedirect,
+  matchHeaders,
+  parseHeaders,
+  parseRedirects,
+} from "../../assets/src/assets.ts";
+
+const source = readFileSync(new URL("./native-fetch-prelude.js", import.meta.url), "utf8");
+const start = source.indexOf("function __sbAssetRedirect(");
+const end = source.indexOf("// Installed only when the project declares bindings.", start);
+if (start < 0 || end < start) throw new Error("asset rule helpers not found");
+// oxlint-disable-next-line no-function-constructor -- test the text-only native prelude
+const load = new Function(
+  "__sbRawBodyResponse",
+  source.slice(start, end) +
+    "\nreturn { redirect: __sbAssetRedirect, matches: __sbAssetHeaderMatches, response: __sbAssetResponse };",
+);
+const { redirect, matches, response } = load((body, init) => new Response(body, init));
+
+test("native redirect matching agrees with shared asset rules", () => {
+  const rules = parseRedirects(
+    "/old /new 301\n/blog/:slug /posts/:slug\n/docs/* https://example.test/:splat 307",
+  );
+  for (const path of [
+    "/old",
+    "/old/",
+    "/blog/a",
+    "/blog/a/b",
+    "/docs",
+    "/docs/",
+    "/docs/a/b",
+    "/missing",
+  ]) {
+    for (const rule of rules) expect(redirect(rule, path)).toBe(matchRedirect(rule, path));
+  }
+});
+
+test("native header matching agrees with shared asset rules", () => {
+  const rules = parseHeaders(
+    "/*\n  X-Test: yes\n/assets/*\n  Cache-Control: public\n/exact\n  ! ETag",
+  );
+  for (const path of ["/", "/assets", "/assets/a/b", "/exact", "/exact/deep", "/missing"]) {
+    expect(rules.filter((rule) => matches(rule.pattern, path))).toEqual(matchHeaders(rules, path));
+  }
+});
+
+test("redirects override files and SPA fallback, with the first matching rule winning", () => {
+  const rules = { redirects: parseRedirects("/old /first 301\n/old /second 302") };
+  for (const found of [true, false]) {
+    const result = response("/old", {
+      found,
+      body: "asset",
+      type: "text/html",
+      hash: "abc",
+      rules,
+    });
+    expect(result.status).toBe(301);
+    expect(result.headers.get("location")).toBe("/first");
+    expect(result.headers.has("etag")).toBe(false);
+    expect(result.headers.has("x-sb-raw-body")).toBe(false);
+  }
+});
+
+test("header rules replace and remove defaults in order without losing the raw-byte marker", async () => {
+  const rules = {
+    headers: parseHeaders(
+      "/*\n  X-Test: first\n  Cache-Control: public\n/assets/*\n  X-Test: second\n  ! ETag\n  ! x-sb-raw-body",
+    ),
+  };
+  const result = response("/assets/deep/file.bin", {
+    found: true,
+    status: 200,
+    body: "binary",
+    type: "application/octet-stream",
+    hash: "abc",
+    rules,
+  });
+  expect(result.headers.get("x-test")).toBe("second");
+  expect(result.headers.get("cache-control")).toBe("public");
+  expect(result.headers.has("etag")).toBe(false);
+  expect(result.headers.get("x-sb-raw-body")).toBe("1");
+  expect(await result.text()).toBe("binary");
+});
+
+test("SPA/custom-404 assets receive headers, generated missing responses do not", () => {
+  const rules = { headers: parseHeaders("/*\n  X-Test: asset") };
+  expect(
+    response("/missing", {
+      status: 200,
+      found: true,
+      type: "text/html",
+      body: "shell",
+      rules,
+    }).headers.get("x-test"),
+  ).toBe("asset");
+  const custom = response("/missing", {
+    status: 404,
+    found: false,
+    type: "text/html",
+    body: "404 page",
+    rules,
+  });
+  expect(custom.status).toBe(404);
+  expect(custom.headers.get("x-test")).toBe("asset");
+  expect(
+    response("/missing", { status: 404, found: false, body: "Not Found", rules }).headers.has(
+      "x-test",
+    ),
+  ).toBe(false);
+});
+
+test("a set wins over an unset in the same header block, matching edge behavior", () => {
+  const rules = { headers: parseHeaders("/*\n  ! ETag\n  ETag: custom") };
+  expect(
+    response("/file", {
+      found: true,
+      type: "text/plain",
+      body: "x",
+      hash: "abc",
+      rules,
+    }).headers.get("etag"),
+  ).toBe("custom");
+});

package/src/egress.test.ts

@@ -60,7 +60,8 @@ const ALLOW = "8.8.4.4, 10.9.9.9";
 test("private and reserved addresses are blocked, public ones are not", () => {
   for (const address of BLOCKED)
     expect([address, blockedRange(address)]).not.toEqual([address, null]);
-  for (const address of PUBLIC) expect([address, blockedRange(address)]).toEqual([address, null]);
+  for (const address of PUBLIC)
+    expect([address, blockedRange(address)]).toEqual([address, null]);
   expect(blockedRange("::ffff:127.0.0.1")).toBe("127.0.0.0/8");
   expect(blockedRange("64:ff9b::a00:1")).toBe("10.0.0.0/8");
 });
@@ -98,7 +99,10 @@ test("the C table in transport-embedded.js is generated from this one (bun run g
 
 test("the C check gives the same answer and message as the TS one", () => {
   const source = readFileSync(transportFile, "utf8");
-  const block = source.slice(source.indexOf("// EGRESS:BEGIN"), source.indexOf("// EGRESS:END"));
+  const block = source.slice(
+    source.indexOf("// EGRESS:BEGIN"),
+    source.indexOf("// EGRESS:END"),
+  );
   const dir = mkdtempSync(join(tmpdir(), "sb-egress-"));
   try {
     writeFileSync(
@@ -140,7 +144,9 @@ int main(int argc, char** argv) {
       env: { ...process.env, SB_EGRESS_ALLOW: ALLOW },
     });
     const fromC = run.stdout.toString().trimEnd().split("\n");
-    const fromTs = addresses.map((a) => egressRefusal("h", a, egressAllowList(ALLOW)) ?? "ok");
+    const fromTs = addresses.map(
+      (a) => egressRefusal("h", a, egressAllowList(ALLOW)) ?? "ok",
+    );
     expect(fromC).toEqual(fromTs);
   } finally {
     rmSync(dir, { recursive: true, force: true });
@@ -150,6 +156,243 @@ int main(int argc, char** argv) {
 test("#174: fetch() needs no config, so every sprout gets it", () => {
   const handler = `export default { async fetch() { return await fetch("https://api.example.com/"); } };`;
   expect(validateHttpSyncSource(handler)).toEqual({ ok: true });
-  const prelude = readFileSync(new URL("./native-fetch-prelude.js", import.meta.url), "utf8");
-  expect(wrapNativeFetchHandler(handler, prelude)).toContain("__sbInstallFetch();");
+  const prelude = readFileSync(
+    new URL("./native-fetch-prelude.js", import.meta.url),
+    "utf8",
+  );
+  expect(wrapNativeFetchHandler(handler, prelude)).toContain(
+    "__sbInstallFetch();",
+  );
+});
+
+test("SB_EGRESS_FD: the host connects, the sprout gets the socket", () => {
+  const source = readFileSync(transportFile, "utf8");
+  const block = source.slice(
+    source.indexOf("// EGRESS-FD:BEGIN"),
+    source.indexOf("// EGRESS-FD:END"),
+  );
+  const dir = mkdtempSync(join(tmpdir(), "sb-egress-fd-"));
+  try {
+    // A fake host on one end of a socketpair: "up" gets a socket whose peer says
+    // "hello", "down" a refusal, and the third question is never answered.
+    writeFileSync(
+      join(dir, "check.c"),
+      `#include <errno.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+${block}
+static void answer(int via, const char* text, int fd) {
+  union { struct cmsghdr align; char space[CMSG_SPACE(sizeof(int))]; } control;
+  struct iovec io = { (void*)text, strlen(text) };
+  struct msghdr msg;
+  memset(&msg, 0, sizeof(msg));
+  msg.msg_iov = &io; msg.msg_iovlen = 1;
+  if (fd >= 0) {
+    msg.msg_control = control.space; msg.msg_controllen = sizeof(control.space);
+    struct cmsghdr* c = CMSG_FIRSTHDR(&msg);
+    c->cmsg_level = SOL_SOCKET; c->cmsg_type = SCM_RIGHTS; c->cmsg_len = CMSG_LEN(sizeof(int));
+    memcpy(CMSG_DATA(c), &fd, sizeof(fd));
+  }
+  sendmsg(via, &msg, 0);
+}
+int main(void) {
+  int pair[2];
+  socketpair(AF_UNIX, SOCK_STREAM, 0, pair);
+  if (fork() == 0) {
+    close(pair[0]);
+    char line[512];
+    ssize_t n = read(pair[1], line, sizeof(line) - 1); line[n > 0 ? n : 0] = 0;
+    printf("asked %s", line); fflush(stdout);
+    int remote[2];
+    socketpair(AF_UNIX, SOCK_STREAM, 0, remote);
+    write(remote[1], "hello", 5);
+    answer(pair[1], "ok\\n", remote[0]);
+    n = read(pair[1], line, sizeof(line) - 1); line[n > 0 ? n : 0] = 0;
+    printf("asked %s", line); fflush(stdout);
+    answer(pair[1], "no fetch() refused: down.test is not allowed\\n", -1);
+    n = read(pair[1], line, sizeof(line) - 1);
+    _exit(0);  // closes without answering
+  }
+  close(pair[1]);
+  char refused[512] = "";
+  int fd = sb_egress_fd_connect(pair[0], "up.test", 443, refused, sizeof(refused));
+  char got[6] = "";
+  if (fd >= 0) read(fd, got, 5);
+  printf("fd %s %s\\n", fd >= 0 ? "yes" : "no", got);
+  fd = sb_egress_fd_connect(pair[0], "down.test", 80, refused, sizeof(refused));
+  printf("fd %s %s\\n", fd >= 0 ? "yes" : "no", refused);
+  refused[0] = 0;
+  printf("fd %s\\n", sb_egress_fd_connect(pair[0], "gone.test", 80, refused, sizeof(refused)) >= 0 ? "yes" : "no");
+  printf("fd %s\\n", sb_egress_fd_connect(pair[0], "after.test", 80, refused, sizeof(refused)) >= 0 ? "yes" : "no");
+  wait(0);
+  return 0;
+}
+`,
+    );
+    const cc = Bun.spawnSync([
+      "cc",
+      "-Wall",
+      "-Werror",
+      "-Wno-unused-result",
+      "-o",
+      join(dir, "check"),
+      join(dir, "check.c"),
+    ]);
+    expect(cc.stderr.toString()).toBe("");
+    const run = Bun.spawnSync([join(dir, "check")]);
+    expect(run.stdout.toString().trimEnd().split("\n").sort()).toEqual(
+      [
+        "asked up.test 443",
+        "fd yes hello",
+        "asked down.test 80",
+        "fd no fetch() refused: down.test is not allowed",
+        "fd no",
+        "fd no",
+      ].sort(),
+    );
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("the Host header carries a non-default port", () => {
+  const source = readFileSync(transportFile, "utf8");
+  const between = (from: string, to: string) =>
+    source.slice(source.indexOf(from), source.indexOf(to));
+  const buffer = between(
+    "typedef struct { char* p; size_t len; size_t cap; } sb_buf;",
+    "static void sb_putjson(",
+  );
+  const builder = between(
+    "// body_len, not strlen(body)",
+    "// Turn a whole raw response",
+  );
+  const dir = mkdtempSync(join(tmpdir(), "sb-host-"));
+  try {
+    writeFileSync(
+      join(dir, "check.c"),
+      `#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+${buffer}
+${builder}
+static void show(int port, int default_port) {
+  sb_buf req = { 0, 0, 0 };
+  sb_build_request(&req, "example.com", port, default_port, "/", "GET", "", 0, 0);
+  printf("%s", strstr(req.p, "Host: "));
+  free(req.p);
+}
+int main(void) { show(80, 80); show(8080, 80); show(443, 443); show(8443, 443); return 0; }
+`,
+    );
+    const cc = Bun.spawnSync([
+      "cc",
+      "-Wall",
+      "-Werror",
+      "-Wno-unused-function",
+      "-o",
+      join(dir, "check"),
+      join(dir, "check.c"),
+    ]);
+    expect(cc.stderr.toString()).toBe("");
+    const hosts = Bun.spawnSync([join(dir, "check")])
+      .stdout.toString()
+      .split("\r\n")
+      .filter((l) => l.startsWith("Host: "));
+    expect(hosts).toEqual([
+      "Host: example.com",
+      "Host: example.com:8080",
+      "Host: example.com",
+      "Host: example.com:8443",
+    ]);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("async fetch: requests run on threads and come back through the host", () => {
+  const source = readFileSync(transportFile, "utf8");
+  const block = source.slice(
+    source.indexOf("// ASYNC:BEGIN"),
+    source.indexOf("// ASYNC:END"),
+  );
+  const dir = mkdtempSync(join(tmpdir(), "sb-async-"));
+  try {
+    // Stand-ins: a client that takes 200 ms, and a host that records which timers fire.
+    writeFileSync(
+      join(dir, "check.c"),
+      `#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <pthread.h>
+typedef unsigned int u32;
+static void sb_init_anchors(void) {}
+static char* sb_error_json(const char* a, const char* b) { char* s = malloc(256); snprintf(s, 256, "%s%s", a, b); return s; }
+static char* sb_http_request(const char* host, int port, const char* path, const char* method,
+                             const char* headers, const char* body, size_t body_len, int tls) {
+  (void)port; (void)method; (void)headers; (void)body_len; (void)tls;
+  usleep(200000);
+  char* s = malloc(256); snprintf(s, 256, "%s%s %s", host, path, body); return s;
+}
+static int fired = 0;
+void porf_native_fetch_timer_clear(u32 id) { (void)id; }
+const char* sb_async_reply(u32 id);
+void porf_native_fetch_fire_timer(u32 id) { printf("%u %s\\n", id, sb_async_reply(id)); fired++; }
+static char* copy(const char* s) { return strdup(s); }
+${block}
+int main(void) {
+  int fd = sb_async_enable();
+  if (fd < 0 || !sb_async_enabled()) return 1;
+  struct timespec a, b;
+  clock_gettime(CLOCK_MONOTONIC, &a);
+  for (u32 i = 1; i <= 16; i++) {
+    char path[16]; snprintf(path, sizeof(path), "/%u", i);
+    sb_async_submit(i, 80, 0, copy("h"), copy(path), copy("GET"), copy(""), copy("body"), 4);
+  }
+  while (fired < 16) { struct pollfd p = { fd, POLLIN, 0 }; poll(&p, 1, 5000); sb_async_drain(); }
+  clock_gettime(CLOCK_MONOTONIC, &b);
+  long ms = (b.tv_sec - a.tv_sec) * 1000 + (b.tv_nsec - a.tv_nsec) / 1000000;
+  printf("elapsed %s\\n", ms < 1000 ? "overlapped" : "serial");
+  printf("outside a callback %s\\n", sb_async_reply(1) ? "leaks" : "nothing");
+  return 0;
+}
+`,
+    );
+    const cc = Bun.spawnSync([
+      "cc",
+      "-Wall",
+      "-Werror",
+      "-Wno-unused-function",
+      "-pthread",
+      "-o",
+      join(dir, "check"),
+      join(dir, "check.c"),
+    ]);
+    expect(cc.stderr.toString()).toBe("");
+    const lines = Bun.spawnSync([join(dir, "check")])
+      .stdout.toString()
+      .trimEnd()
+      .split("\n");
+    // 16 requests of 200 ms on 8 threads: two rounds, not sixteen.
+    expect(lines.slice(0, 16).sort()).toEqual(
+      Array.from({ length: 16 }, (_, i) => `${i + 1} h/${i + 1} body`).sort(),
+    );
+    expect(lines.slice(16)).toEqual([
+      "elapsed overlapped",
+      "outside a callback nothing",
+    ]);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
 });

package/src/gen-streams.ts

@@ -16,14 +16,13 @@ if (!code.startsWith("(() => {") || !code.trimEnd().endsWith("})();")) {
   throw new Error("Unexpected streams bundle format");
 }
 code = code.slice("(() => {".length).trimEnd().slice(0, -"})();".length);
+// streams-entry.js installs each class with its own static assignment (see there).
+const exported = Object.keys(await import("web-streams-polyfill"));
+const missing = exported.filter((name) => !code.includes(`globalThis.${name} = `));
+if (!exported.length || missing.length) throw new Error(`streams-entry.js does not install: ${missing.join(", ") || "(no exports found)"}`);
 code = code.replace(/^\s*\/\/ .*streams-entry.js$/m, "// streams-entry.js");
 code = code.replace(/^\s*\/\/ .*web-streams-polyfill\/dist\/ponyfill.mjs$/m,
   "// web-streams-polyfill 4.3.0, MIT, copyright Mattias Buelens (see WEB_STREAMS_LICENSE)");
-// Alpha 16's direct array iterator works, but dynamic symbol lookup misses it.
-const lookup = "const r = e[t];\n    if (r != null)";
-if (!code.includes(lookup)) throw new Error("Streams iterator adapter target changed");
-code = code.replace(lookup,
-  "let r = e[t];\n    if (r == null && t === Symbol.iterator && Array.isArray(e)) r = () => e.values();\n    if (r != null)");
 const path = `${import.meta.dir}/native-fetch-prelude.js`;
 let prelude = await readFile(path, "utf8");
 const start = prelude.indexOf(marker);