@sproutboat/runtime 0.33.0 → 0.34.1

package/test/native-unhandled-rejection.ts

@@ -0,0 +1,133 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { ensurePorffor } from "../../toolchain/src/acquire";
+import { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
+
+// A promise that rejects with nobody waiting on it (a binding call that failed and was never
+// awaited, say a D1 run() that broke a foreign key) must not take the process down, whatever
+// the compatibility date. As on Workers it is logged, an "unhandledrejection" listener hears
+// it, and the next request is served.
+const handler = `addEventListener("unhandledrejection", (event) => {
+  globalThis.__heard = (globalThis.__heard || []).concat(String(event.reason && event.reason.message));
+});
+export default {async fetch(request) {
+  const path = new URL(request.url).pathname;
+  if (path === "/reject") {
+    try {
+      Promise.reject(new Error("D1_ERROR: FOREIGN KEY constraint failed"));
+    } catch (error) {
+      return new Response("caught", { status: 500 });
+    }
+    return new Response("fired");
+  }
+  if (path === "/promise") {
+    try {
+      new Promise(function (resolve, reject) { reject(new Error("kv failed")); });
+    } catch (error) {
+      return new Response("caught", { status: 500 });
+    }
+    return new Response("fired");
+  }
+  if (path === "/async") {
+    async function failNow() { throw new Error("async function failed"); }
+    failNow();
+    return new Response("fired");
+  }
+  if (path === "/heard") return new Response(JSON.stringify(globalThis.__heard || []));
+  return new Response("pong");
+}};`;
+
+function freePort(): number {
+  const listener = Bun.listen({ hostname: "127.0.0.1", port: 0, socket: { data() {} } });
+  const port = listener.port;
+  listener.stop(true);
+  return port;
+}
+
+for (const date of ["2026-09-28", "2026-10-24"]) {
+  const workdir = await mkdtemp(join(tmpdir(), "sb-native-unhandled-"));
+  let server: ReturnType<typeof Bun.spawn> | undefined;
+  try {
+    const porffor = await ensurePorffor();
+    const node = Bun.which("node");
+    if (!node) throw new Error("native unhandled rejection test needs node on PATH");
+    const [core, broker] = await Promise.all([
+      readFile(preludePath, "utf8"),
+      readFile(transportPath("broker"), "utf8"),
+    ]);
+    assert(core.includes(TRANSPORT_MARKER), "runtime prelude is missing its transport marker");
+    const generated = join(workdir, "unhandled.generated.js");
+    const binary = join(workdir, "unhandled-native");
+    await writeFile(
+      generated,
+      wrapNativeFetchHandler(handler, core.replace(TRANSPORT_MARKER, broker), undefined, undefined, undefined, date),
+    );
+    const compile = Bun.spawn(
+      [node, resolve(porffor, "runtime/index.js"), "native", generated, "-o", binary, "-s", "-O0"],
+      {
+        cwd: workdir,
+        env: process.env,
+        stdout: "pipe",
+        stderr: "pipe",
+      },
+    );
+    const [exitCode, stdout, stderr] = await Promise.all([
+      compile.exited,
+      new Response(compile.stdout).text(),
+      new Response(compile.stderr).text(),
+    ]);
+    assert.equal(exitCode, 0, `Porffor native compile failed:\n${stderr}\n${stdout}`);
+
+    const port = freePort();
+    server = Bun.spawn([binary], {
+      cwd: workdir,
+      env: { ...process.env, PORT: String(port), SB_BROKER_TOKEN: "native-test-token" },
+      stdout: "ignore",
+      stderr: "pipe",
+    });
+    let ready = false;
+    for (let attempt = 0; attempt < 50 && !ready; attempt++) {
+      try {
+        await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(500) });
+        ready = true;
+      } catch {
+        if (server.exitCode !== null) break;
+        await Bun.sleep(100);
+      }
+    }
+    assert(ready, `compiled handler did not start (${date})`);
+    const get = async (path: string) => (await fetch(`http://127.0.0.1:${port}${path}`)).text();
+
+    assert.equal(await get("/reject"), "fired");
+    assert.equal(await get("/pong"), "pong", `the request after an unhandled rejection failed (${date})`);
+    assert.equal(await get("/promise"), "fired");
+    assert.equal(await get("/async"), "fired");
+    await Bun.sleep(300);
+    assert.equal(await get("/pong"), "pong", `the request after a rejected promise failed (${date})`);
+    assert.equal(server.exitCode, null, `the server exited on an unhandled rejection (${date})`);
+    assert.equal(await get("/pong"), "pong", `the request after an unawaited async function threw failed (${date})`);
+    const heard = JSON.parse(await get("/heard"));
+    assert(
+      heard.some((message: string) => message.includes("FOREIGN KEY")),
+      `no unhandledrejection event for the rejected promise (${date}): ${JSON.stringify(heard)}`,
+    );
+    assert(
+      heard.some((message: string) => message.includes("async function failed")),
+      `no unhandledrejection event for the async function (${date}): ${JSON.stringify(heard)}`,
+    );
+    server.kill(9);
+    await server.exited;
+    const log = await new Response(server.stderr).text();
+    assert(log.includes("Uncaught (in promise)"), `the rejection was not logged (${date}): ${log}`);
+    server = undefined;
+    console.log(`Native unhandled rejections are reported, not fatal (${date})`);
+  } finally {
+    if (server) {
+      server.kill(9);
+      await server.exited;
+    }
+    await rm(workdir, { recursive: true, force: true });
+  }
+}

package/test/native-websockets-outbound.ts

@@ -0,0 +1,244 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Outbound WebSockets, from compatibility date 2026-11-01: new WebSocket(url) and fetch() with
+// Upgrade: websocket, on the embedded transport (standalone sprouts, sproutd). An upstream
+// server in this process (Bun) answers them; the handler's answers are what workerd gives for
+// the same code.
+interface UpstreamData {
+  readonly path: string;
+}
+const upstream = Bun.serve<UpstreamData>({
+  port: 0,
+  hostname: "127.0.0.1",
+  fetch(request, server) {
+    const path = new URL(request.url).pathname;
+    if (path === "/refuse") return new Response("no sockets", { status: 426, headers: { "x-why": "test" } });
+    const ok = server.upgrade(request, {
+      data: { path },
+      headers: path === "/proto" ? { "sec-websocket-protocol": "chat" } : undefined,
+    });
+    return ok ? undefined : new Response("expected websocket", { status: 426 });
+  },
+  websocket: {
+    open(ws) {
+      if (ws.data.path === "/hello") ws.send("hello from upstream");
+      if (ws.data.path === "/bye") ws.close(4003, "upstream bye");
+    },
+    message(ws, message) {
+      if (message === "close-me") ws.close(4004, "asked");
+      else if (message instanceof Buffer) ws.send(message);
+      else ws.send(`echo:${message}`);
+    },
+    maxPayloadLength: 64 * 1024 * 1024,
+  },
+});
+
+const handler = `export default {async fetch(request) {
+  const url = new URL(request.url);
+  const path = url.pathname;
+  const up = "ws://127.0.0.1:${upstream.port}";
+  const tick = (ms) => new Promise((r) => setTimeout(r, ms));
+  const waitFor = async (cond, ms) => { const end = Date.now() + ms; while (!cond() && Date.now() < end) await tick(10); return cond(); };
+  if (path === "/ctor") {
+    const log = [];
+    const ws = new WebSocket(up + "/proto", ["other", "chat"]);
+    log.push("state " + ws.readyState + " " + ws.url.replace(/:\\d+/, ":PORT"));
+    ws.addEventListener("open", () => { log.push("open " + ws.protocol + " " + ws.readyState); ws.send("hi"); ws.send(new Uint8Array([1, 2, 3])); });
+    ws.binaryType = "arraybuffer";
+    ws.addEventListener("message", (e) => {
+      log.push(typeof e.data === "string" ? "m:" + e.data : "b:" + Array.from(new Uint8Array(e.data)).join(","));
+      if (log.filter((l) => l[0] === "m" || l[0] === "b").length === 2) ws.close(1000, "done");
+    });
+    ws.addEventListener("close", (e) => log.push("close " + e.code + " " + e.reason + " " + e.wasClean + " " + ws.readyState));
+    await waitFor(() => log.some((l) => l.indexOf("close") === 0), 5000);
+    return Response.json(log);
+  }
+  if (path === "/ctor-early") {
+    // send() while CONNECTING throws; a greeting from the server arrives; the server's close reaches us.
+    const log = [];
+    const ws = new WebSocket(up + "/hello");
+    try { ws.send("too early"); } catch (e) { log.push(e.name); }
+    ws.addEventListener("message", (e) => { log.push(e.data); ws.send("close-me"); });
+    ws.addEventListener("close", (e) => log.push("close " + e.code + " " + e.reason + " " + e.wasClean));
+    await waitFor(() => log.some((l) => l.indexOf("close") === 0), 5000);
+    return Response.json(log);
+  }
+  if (path === "/serverclose") {
+    const log = [];
+    const ws = new WebSocket(up + "/bye");
+    ws.addEventListener("close", (e) => log.push("close " + e.code + " " + e.reason + " " + e.wasClean));
+    await waitFor(() => log.length > 0, 5000);
+    return Response.json(log);
+  }
+  if (path === "/big") {
+    const ws = new WebSocket(up + "/echo");
+    const big = "y".repeat(3 * 1024 * 1024);
+    let got = 0;
+    ws.addEventListener("open", () => ws.send(big));
+    ws.addEventListener("message", (e) => { got = e.data.length; ws.close(1000); });
+    await waitFor(() => got > 0, 10000);
+    return Response.json({ got, sent: big.length });
+  }
+  if (path === "/fetch") {
+    const res = await fetch("http://127.0.0.1:${upstream.port}/echo", { headers: { Upgrade: "websocket" } });
+    const ws = res.webSocket;
+    const log = [res.status, ws !== null, res.headers.get("upgrade")];
+    ws.accept();
+    ws.addEventListener("message", (e) => log.push(e.data));
+    ws.send("one");
+    ws.send("two");
+    await waitFor(() => log.length >= 5, 5000);
+    ws.close(1000, "bye");
+    await tick(100);
+    log.push("state " + ws.readyState);
+    return Response.json(log);
+  }
+  if (path === "/refused") {
+    const res = await fetch("http://127.0.0.1:${upstream.port}/refuse", { headers: { Upgrade: "websocket" } });
+    return Response.json([res.status, res.webSocket, res.headers.get("x-why"), await res.text()]);
+  }
+  if (path === "/proxy") {
+    // The handler returns the upstream's upgrade response: the client's socket is relayed to it.
+    return fetch("http://127.0.0.1:${upstream.port}/proto", request);
+  }
+  if (path === "/badurl") {
+    const out = [];
+    try { new WebSocket("ftp://example.com/"); } catch (e) { out.push(e.name); }
+    try { new WebSocket("not a url"); } catch (e) { out.push(e.name); }
+    try { new WebSocket("ws://example.com/#frag"); } catch (e) { out.push(e.name); }
+    try { new WebSocket("ws://example.com/", ["a", "a"]); } catch (e) { out.push(e.name); }
+    return Response.json(out);
+  }
+  if (path === "/unreachable") {
+    const log = [];
+    const ws = new WebSocket("ws://127.0.0.1:1/nothing");
+    ws.addEventListener("error", () => log.push("error"));
+    ws.addEventListener("close", (e) => log.push("close " + e.code + " " + e.wasClean));
+    await waitFor(() => log.length >= 2, 8000);
+    return Response.json(log);
+  }
+  return new Response("no route " + path, { status: 404 });
+}};`;
+
+const cli = process.env.SB_CLI;
+if (!cli) {
+  console.log("skipped: set SB_CLI to a sproutboat-cli checkout linked to this checkout (it builds the sprouts)");
+  process.exit(0);
+}
+
+function freePort(): number {
+  const listener = Bun.listen({ hostname: "127.0.0.1", port: 0, socket: { data() {} } });
+  const port = listener.port;
+  listener.stop(true);
+  return port;
+}
+
+const workdir = mkdtempSync(join(tmpdir(), "sb-native-websockets-out-"));
+const servers: ReturnType<typeof Bun.spawn>[] = [];
+// A standalone sprout built by the CLI (the embedded transport) at each compatibility date.
+const start = async (date: string) => {
+  const slug = `wsout-${date}`;
+  const project = join(workdir, slug);
+  mkdirSync(join(project, "src"), { recursive: true });
+  writeFileSync(join(project, "src/index.js"), handler);
+  writeFileSync(
+    join(project, "sproutboat.jsonc"),
+    JSON.stringify({ name: slug, main: "src/index.js", compatibility_date: date }),
+  );
+  const built = Bun.spawnSync(["bun", join(cli, "src/main.ts"), "build", "--standalone", "--target", "host"], {
+    cwd: project,
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  assert.equal(built.exitCode, 0, "the CLI could not build the sprout");
+  const port = freePort();
+  const server = Bun.spawn([join(project, "dist", slug)], {
+    cwd: project,
+    env: { ...process.env, PORT: String(port), SB_EGRESS_ALLOW: "127.0.0.1", SB_DATA_DIR: join(project, "data") },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  servers.push(server);
+  const base = `http://127.0.0.1:${port}`;
+  for (let attempt = 0; attempt < 100; attempt++) {
+    try {
+      await fetch(`${base}/badurl`, { signal: AbortSignal.timeout(500) });
+      return base;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  throw new Error("compiled handler did not start");
+};
+
+try {
+  const now = await start("2026-11-01");
+  const get = async (path: string) => (await fetch(`${now}${path}`)).json();
+
+  assert.deepEqual(await get("/badurl"), ["SyntaxError", "SyntaxError", "SyntaxError", "SyntaxError"]);
+  assert.deepEqual(await get("/ctor"), [
+    "state 0 ws://127.0.0.1:PORT/proto",
+    "open chat 1",
+    "m:echo:hi",
+    "b:1,2,3",
+    "close 1000 done true 3",
+  ]);
+  assert.deepEqual(await get("/ctor-early"), ["InvalidStateError", "hello from upstream", "close 4004 asked true"]);
+  assert.deepEqual(await get("/serverclose"), ["close 4003 upstream bye true"]);
+  assert.deepEqual(await get("/big"), { got: 3 * 1024 * 1024 + 5, sent: 3 * 1024 * 1024 });
+  assert.deepEqual(await get("/fetch"), [101, true, "websocket", "echo:one", "echo:two", "state 3"]);
+  assert.deepEqual(await get("/refused"), [426, null, "test", "no sockets"]);
+  assert.deepEqual(await get("/unreachable"), ["error", "close 1006 false"]);
+  console.log("new WebSocket(url) and fetch() upgrades connect, exchange text and bytes, and close with their codes");
+
+  // The handler returns the upstream's upgrade response: a client of the sprout talks to the upstream.
+  const ws = new WebSocket(`${now.replace("http:", "ws:")}/proxy`, "chat");
+  ws.binaryType = "arraybuffer";
+  const events: string[] = [];
+  await new Promise<void>((done, fail) => {
+    const timer = setTimeout(() => fail(new Error("proxy timed out: " + events.join("|"))), 10000);
+    ws.addEventListener("open", () => ws.send("via proxy"));
+    ws.addEventListener("message", (e) => {
+      events.push(String(e.data));
+      ws.close(1000, "done");
+    });
+    ws.addEventListener("close", (e) => {
+      events.push(`close ${e.code}`);
+      clearTimeout(timer);
+      done();
+    });
+  });
+  assert.deepEqual(events, ["echo:via proxy", "close 1000"]);
+  console.log("a handler that returns an upstream upgrade relays the client's socket to it");
+
+  // Before the date the CLI refuses `new WebSocket(url)` at build time.
+  const old = join(workdir, "old");
+  mkdirSync(join(old, "src"), { recursive: true });
+  writeFileSync(join(old, "src/index.js"), handler);
+  writeFileSync(
+    join(old, "sproutboat.jsonc"),
+    JSON.stringify({ name: "wsold", main: "src/index.js", compatibility_date: "2026-10-30" }),
+  );
+  const refused = Bun.spawnSync(["bun", join(cli, "src/main.ts"), "check"], {
+    cwd: old,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  assert.notEqual(refused.exitCode, 0);
+  assert.match(
+    refused.stdout.toString() + refused.stderr.toString(),
+    /WebSocket\(\) needs compatibility_date 2026-11-01/,
+  );
+  console.log("before 2026-11-01 the build refuses new WebSocket(url)");
+} finally {
+  for (const server of servers) {
+    server.kill(9);
+    await server.exited;
+  }
+  upstream.stop(true);
+  rmSync(workdir, { recursive: true, force: true });
+}

package/test/native-websockets.ts

@@ -9,7 +9,8 @@ import { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler }
 // the worker is plain JavaScript and works on every host; a 101 response needs a host that
 // carries client sockets (sproutd), so a standalone sprout answers it with a 501. Before the
 // date nothing is defined. The answers below are workerd's (1.20260730.1) for the same code.
-const handler = `export default {async fetch(request) {
+const handler = `const closes = [];
+export default {async fetch(request) {
   const path = new URL(request.url).pathname;
   const tick = () => new Promise((r) => setTimeout(r, 10));
   if (path === "/shape") return Response.json([typeof WebSocketPair, typeof WebSocket, typeof WebSocketRequestResponsePair, new Response("x").webSocket]);
@@ -69,6 +70,20 @@ const handler = `export default {async fetch(request) {
     const pair = new WebSocketPair();
     try { pair[0].send("x"); return new Response("sent"); } catch (e) { return new Response(e.name + ": " + e.message); }
   }
+  if (path === "/echo" || path === "/hello" || path === "/proto" || path === "/serverclose") {
+    if (request.headers.get("Upgrade") !== "websocket") return new Response("expected websocket", { status: 426 });
+    const [client, server] = Object.values(new WebSocketPair());
+    server.accept();
+    if (path === "/hello") server.send("hello");
+    if (path === "/serverclose") server.close(4002, "server says bye");
+    if (path === "/echo") {
+      server.binaryType = "arraybuffer";
+      server.addEventListener("message", (e) => server.send(typeof e.data === "string" ? "echo:" + e.data : e.data));
+      server.addEventListener("close", (e) => closes.push([e.code, e.reason, e.wasClean]));
+    }
+    return new Response(null, { status: 101, webSocket: client, headers: path === "/proto" ? { "Sec-WebSocket-Protocol": "chat" } : {} });
+  }
+  if (path === "/closes") return Response.json(closes);
   if (path === "/upgrade") {
     const [client, server] = Object.values(new WebSocketPair());
     server.accept();
@@ -136,7 +151,7 @@ try {
     }
     throw new Error("compiled handler did not start");
   };
-  const [now, before] = await Promise.all([start("2026-10-30"), start("2026-10-29")]);
+  const [now, before, hosted] = await Promise.all([start("2026-10-30"), start("2026-10-29"), start("2026-11-01")]);
 
   assert.deepEqual(await (await fetch(`${now}/shape`)).json(), ["function", "function", "function", null]);
   assert.deepEqual(await (await fetch(`${before}/shape`)).json(), ["undefined", "undefined", "undefined", null]);
@@ -168,7 +183,75 @@ try {
   assert.equal(await upgrade.text(), "WebSockets are not supported by this host yet");
   assert.equal(await (await fetch(`${now}/bad101`)).text(), "RangeError");
   assert.equal(await (await fetch(`${before}/bad101`)).text(), "RangeError");
-  console.log("a standalone sprout answers a 101 response with 501; status 101 needs a WebSocket");
+  console.log("a standalone sprout answers a 101 response with 501 before 2026-11-01; status 101 needs a WebSocket");
+
+  // From 2026-11-01 the server carries the client end: a real WebSocket.
+  const wsBase = hosted.replace("http:", "ws:");
+  const open = (url: string, protocols?: string | string[]) =>
+    new Promise<WebSocket>((ok, fail) => {
+      const ws = protocols ? new WebSocket(url, protocols) : new WebSocket(url);
+      ws.binaryType = "arraybuffer";
+      ws.addEventListener("open", () => ok(ws), { once: true });
+      ws.addEventListener("error", () => fail(new Error("WebSocket error for " + url)), { once: true });
+    });
+  const nextMessage = (ws: WebSocket) =>
+    new Promise<MessageEvent["data"]>((ok, fail) => {
+      const t = setTimeout(() => fail(new Error("timed out waiting for a message")), 5000);
+      ws.addEventListener(
+        "message",
+        (e) => {
+          clearTimeout(t);
+          ok(e.data);
+        },
+        { once: true },
+      );
+    });
+  const closedWith = (ws: WebSocket) =>
+    new Promise<[number, string]>((ok) => ws.addEventListener("close", (e) => ok([e.code, e.reason]), { once: true }));
+
+  const echo = await open(`${wsBase}/echo`);
+  echo.send("hi");
+  assert.equal(await nextMessage(echo), "echo:hi");
+  echo.send(new Uint8Array([0, 1, 2, 255]));
+  assert.deepEqual(Array.from(new Uint8Array(await nextMessage(echo))), [0, 1, 2, 255]);
+  for (let i = 0; i < 200; i++) echo.send(String(i));
+  const many: string[] = [];
+  await new Promise<void>((done) =>
+    echo.addEventListener("message", (e) => {
+      many.push(String(e.data));
+      if (many.length === 200) done();
+    }),
+  );
+  assert.deepEqual(
+    many,
+    Array.from({ length: 200 }, (_, i) => "echo:" + i),
+  );
+  const big = "x".repeat(3 * 1024 * 1024);
+  echo.send(big);
+  const bigEcho = await nextMessage(echo);
+  assert.equal(bigEcho.length, big.length + 5);
+  const gone = closedWith(echo);
+  echo.close(4001, "bye");
+  assert.deepEqual(await gone, [4001, "bye"]);
+  await Bun.sleep(100);
+  assert.deepEqual(await (await fetch(`${hosted}/closes`)).json(), [[4001, "bye", true]]);
+  console.log("a client socket echoes text, bytes, 200 queued messages and a 3 MiB message, and closes with its code");
+
+  const hello = await open(`${wsBase}/hello`);
+  assert.equal(await nextMessage(hello), "hello");
+  hello.close();
+  const proto = await open(`${wsBase}/proto`, ["other", "chat"]);
+  assert.equal(proto.protocol, "chat");
+  proto.close();
+  const bye = await open(`${wsBase}/serverclose`);
+  assert.deepEqual(await closedWith(bye), [4002, "server says bye"]);
+  console.log("a message sent before the 101 arrives first, the app picks the protocol, and the app can close");
+
+  assert.equal((await fetch(`${hosted}/echo`)).status, 426);
+  const plain = await fetch(`${hosted}/upgrade`);
+  assert.equal(plain.status, 500);
+  assert.equal(await plain.text(), "WebSocket response to a request that is not an upgrade");
+  console.log("a plain request is not upgraded, and a 101 to one is a 500");
 } finally {
   for (const server of servers) {
     server.kill(9);