@sproutboat/runtime 0.34.5 → 0.36.0

package/test/fixtures/als-app.js

@@ -0,0 +1,136 @@
+// AsyncLocalStorage as Workers has it (nodejs_compat). The same file runs on workerd for the
+// comparison, where the class comes from node:async_hooks; here the prelude's global stands in
+// until the CLI maps the import.
+const ALS = globalThis.__sbAlsForTest || globalThis.AsyncLocalStorage;
+const als = new ALS();
+const other = new ALS();
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function run(path, id, delay) {
+  if (path === "/basic") {
+    const out = [];
+    out.push(als.getStore());
+    out.push(als.run("a", () => als.getStore()));
+    out.push(als.run("a", () => als.run("b", () => als.getStore())));
+    out.push(als.run("a", () => als.run("b", () => als.exit(() => als.getStore()))));
+    out.push(als.run("a", () => other.run("x", () => [als.getStore(), other.getStore()])));
+    out.push(als.getStore());
+    try {
+      als.run("t", () => {
+        throw new Error("boom");
+      });
+    } catch (e) {
+      out.push(["threw", e.message, als.getStore()]);
+    }
+    out.push(als.run("args", (x, y) => [als.getStore(), x, y], 1, 2));
+    out.push(als.run("v", () => 7));
+    return out;
+  }
+  if (path === "/await") {
+    return als.run({ id }, async () => {
+      const seen = [als.getStore().id];
+      await sleep(delay);
+      seen.push(als.getStore().id);
+      await null;
+      seen.push(als.getStore().id);
+      await Promise.resolve().then(() => seen.push(als.getStore().id));
+      await new Promise((resolve) =>
+        setTimeout(() => {
+          seen.push(als.getStore().id);
+          resolve();
+        }, delay),
+      );
+      await Promise.all([
+        sleep(delay),
+        (async () => {
+          await sleep(1);
+          seen.push(als.getStore().id);
+        })(),
+      ]);
+      const viaThen = await new Promise((resolve) => {
+        sleep(delay).then(() => resolve(als.getStore().id));
+      });
+      seen.push(viaThen);
+      queueMicrotask(() => seen.push("q" + als.getStore().id));
+      await sleep(1);
+      let ticks = 0;
+      await new Promise((resolve) => {
+        const timer = setInterval(() => {
+          seen.push("i" + als.getStore().id);
+          if (++ticks === 2) {
+            clearInterval(timer);
+            resolve();
+          }
+        }, 1);
+      });
+      try {
+        await Promise.reject(new Error("r"));
+      } catch (e) {
+        seen.push("c" + als.getStore().id);
+      }
+      await Promise.allSettled([Promise.reject(new Error("s"))]);
+      seen.push("s" + als.getStore().id);
+      return seen;
+    });
+  }
+  if (path === "/bind") {
+    const snapped = als.run("captured", () => ALS.snapshot());
+    const bound = () => snapped(() => als.getStore());
+    const snap = als.run("snap", () => ALS.snapshot());
+    const results = [bound(), als.run("other", () => bound()), snap(() => als.getStore()), als.getStore()];
+    await sleep(1);
+    results.push(
+      await als.run("later", async () => {
+        await sleep(1);
+        return bound();
+      }),
+    );
+    return results;
+  }
+  if (path === "/nested-async") {
+    const inner = async () => {
+      await sleep(delay);
+      return als.getStore();
+    };
+    const a = als.run("outer", async () => {
+      const x = await inner();
+      const y = await als.run("inner", () => inner());
+      const z = await inner();
+      return [x, y, z, als.getStore()];
+    });
+    return await a;
+  }
+  if (path === "/leak") {
+    // A run() that finished leaves nothing behind, even while its async work is pending.
+    let pending;
+    als.run("gone", () => {
+      pending = sleep(delay);
+    });
+    const before = als.getStore();
+    await pending;
+    return [before, als.getStore()];
+  }
+  return null;
+}
+
+export default {
+  async fetch(request, env, ctx) {
+    const url = new URL(request.url);
+    const id = url.searchParams.get("id") || "";
+    const delay = Number(url.searchParams.get("d") || 1);
+    if (url.pathname === "/wu") {
+      als.run({ id }, () => {
+        ctx.waitUntil(
+          (async () => {
+            await sleep(delay);
+            globalThis.__alsWu = als.getStore().id;
+          })(),
+        );
+      });
+      return new Response("scheduled");
+    }
+    if (url.pathname === "/wu-read") return new Response(String(globalThis.__alsWu));
+    const result = await run(url.pathname, id, delay);
+    return Response.json(result);
+  },
+};

package/test/fixtures/concurrent-app.js

@@ -0,0 +1,229 @@
+// The app under test in native-concurrent-requests.ts: every route keeps its own request's
+// values in locals, awaits on timers, fetch(), body streams, KV, D1 and WebSockets, and
+// reports what it saw before and after each await. A reply that holds another request's id
+// is a leak between interleaved requests. Written to the subset every host compiles.
+const seenCf = [];
+const seenHeaders = [];
+const seenCtx = [];
+const wakeups = {};
+let active = 0;
+let maxActive = 0;
+let dbReady = false;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function handle(request, env, ctx) {
+  {
+    const url = new URL(request.url);
+    const path = url.pathname;
+    const rid = request.headers.get("x-rid") || url.searchParams.get("id") || "";
+    const delays = (url.searchParams.get("d") || "3,3,3").split(",").map(Number);
+    const snap = () => ({
+      rid: request.headers.get("x-rid"),
+      cookie: request.headers.get("cookie"),
+      url: request.url,
+      method: request.method,
+      env: env.GREETING,
+      ctx: ctx === myCtx,
+      cf: request.cf === myCf,
+      headers: request.headers === myHeaders,
+    });
+    const myCtx = ctx;
+    const myCf = request.cf;
+    const myHeaders = request.headers;
+    seenCf.push(myCf);
+    seenHeaders.push(myHeaders);
+    seenCtx.push(ctx);
+
+    if (path === "/report") {
+      return Response.json({
+        n: seenCf.length,
+        maxActive,
+        cfShared: new Set(seenCf).size !== seenCf.length,
+        headersShared: new Set(seenHeaders).size !== seenHeaders.length,
+        ctxShared: new Set(seenCtx).size !== seenCtx.length,
+      });
+    }
+    if (path === "/wu") return Response.json(wakeups[rid] || null);
+
+    if (path === "/mix") {
+      // Locals that must survive every await and every collection in between.
+      const mine = { id: rid, list: [], text: "t-" + rid };
+      for (let i = 0; i < 20; i++) mine.list.push(rid + ":" + i);
+      const out = { rid, steps: [snap()] };
+      const extra = new Headers(request.headers);
+      extra.set("x-mine", rid);
+      ctx.waitUntil(
+        (async () => {
+          await sleep(5 + delays[0]);
+          wakeups[rid] = { rid, again: request.headers.get("x-rid"), mine: mine.id, ctx: ctx === myCtx };
+        })(),
+      );
+      for (let i = 0; i < delays.length; i++) {
+        await sleep(delays[i]);
+        if (url.searchParams.get("alloc")) {
+          // Garbage between awaits: forces collections while other requests are suspended.
+          let junk = [];
+          for (let k = 0; k < 40; k++) junk.push("j".repeat(2000 + k) + k);
+          junk = null;
+        }
+        out.steps.push(snap());
+      }
+      const upstream = url.searchParams.get("up");
+      if (upstream) {
+        const r = await fetch(upstream + "/echo?id=" + rid + "&ms=" + delays[0], { headers: { "x-rid": rid } });
+        out.upstream = await r.json();
+        out.steps.push(snap());
+      }
+      out.mine = { id: mine.id, text: mine.text, list: mine.list.join(",") };
+      out.extra = extra.get("x-mine");
+      out.xrid = extra.get("x-rid");
+      return Response.json(out, { headers: { "x-rid": rid, "x-echo": rid } });
+    }
+
+    if (path === "/promise") {
+      // A promise returned from an async function and adopted by another, with timers between.
+      const inner = async () => {
+        await sleep(delays[0]);
+        return { rid, from: "inner", seen: request.headers.get("x-rid") };
+      };
+      const outer = async () => {
+        const v = await inner();
+        await sleep(delays[1] || 1);
+        return v;
+      };
+      const all = await Promise.all([outer(), outer(), inner()]);
+      const raced = await Promise.race([sleep(50).then(() => "slow"), sleep(delays[0]).then(() => rid)]);
+      const settled = await Promise.allSettled([Promise.reject(new Error("e-" + rid)), Promise.resolve(rid)]);
+      return Response.json({
+        rid,
+        all: all.map((x) => x.seen),
+        raced,
+        settled: [settled[0].reason.message, settled[1].value],
+        again: request.headers.get("x-rid"),
+      });
+    }
+
+    if (path === "/boom") {
+      await sleep(delays[0]);
+      throw new Error("boom-" + rid);
+    }
+    if (path === "/catch") {
+      try {
+        await sleep(delays[0]);
+        throw new Error("caught-" + rid);
+      } catch (error) {
+        await sleep(delays[1] || 1);
+        return Response.json({ rid, message: error.message, again: request.headers.get("x-rid") });
+      }
+    }
+    if (path === "/reject") {
+      // Nothing waits on this rejection: the request and its neighbours go on.
+      Promise.reject(new Error("unhandled-" + rid));
+      await sleep(delays[0]);
+      return Response.json({ rid, ok: true, again: request.headers.get("x-rid") });
+    }
+
+    if (path === "/body") {
+      // The body is read in pieces with a timer between each, other requests interleaving.
+      const reader = request.body.getReader();
+      let bytes = 0;
+      let sum = 0;
+      let pieces = 0;
+      for (;;) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        pieces++;
+        bytes += value.length;
+        for (let i = 0; i < value.length; i++) sum = (sum + value[i]) % 1000003;
+        await sleep(1);
+      }
+      return Response.json({ rid, bytes, sum, pieces, again: request.headers.get("x-rid") });
+    }
+    if (path === "/text") {
+      const text = await request.text();
+      await sleep(delays[0]);
+      let sum = 0;
+      for (let i = 0; i < text.length; i++) sum = (sum + text.charCodeAt(i)) % 1000003;
+      return Response.json({ rid, bytes: text.length, sum, again: request.headers.get("x-rid") });
+    }
+
+    if (path === "/stream") {
+      let i = 0;
+      const n = 8;
+      const stream = new ReadableStream({
+        async pull(controller) {
+          await sleep(delays[0]);
+          if (i === n) {
+            controller.close();
+            return;
+          }
+          controller.enqueue(new TextEncoder().encode(rid + ":" + i + ":" + request.headers.get("x-rid") + "\n"));
+          i++;
+        },
+      });
+      return new Response(stream, { headers: { "content-type": "text/plain", "x-rid": rid } });
+    }
+
+    if (path === "/store") {
+      if (!dbReady) {
+        dbReady = true;
+        await env.DB.exec("CREATE TABLE IF NOT EXISTS t (rid TEXT, v TEXT)");
+      }
+      await env.KV.put("k-" + rid, rid);
+      await sleep(delays[0]);
+      const kv = await env.KV.get("k-" + rid);
+      await env.DB.prepare("INSERT INTO t (rid, v) VALUES (?, ?)")
+        .bind(rid, "v-" + rid)
+        .run();
+      await sleep(delays[1] || 1);
+      const row = await env.DB.prepare("SELECT v FROM t WHERE rid = ?").bind(rid).first();
+      return Response.json({ rid, kv, row: row && row.v, again: request.headers.get("x-rid") });
+    }
+
+    if (path === "/pair") {
+      // A WebSocketPair that stays in the worker: messages with timers between them.
+      const [client, server] = Object.values(new WebSocketPair());
+      server.accept();
+      client.accept();
+      const log = [];
+      server.addEventListener("message", (e) => {
+        log.push("s:" + e.data);
+        server.send("echo:" + e.data + ":" + request.headers.get("x-rid"));
+      });
+      client.addEventListener("message", (e) => log.push("c:" + e.data));
+      for (let i = 0; i < 4; i++) {
+        client.send(rid + ":" + i);
+        await sleep(delays[0]);
+      }
+      await sleep(5);
+      client.close(1000, rid);
+      return Response.json({ rid, log });
+    }
+
+    if (path === "/ws") {
+      // A client socket (hosts that carry them): each message is answered after a timer.
+      if (request.headers.get("Upgrade") !== "websocket") return new Response("expected websocket", { status: 426 });
+      const [client, server] = Object.values(new WebSocketPair());
+      server.accept();
+      server.addEventListener("message", async (e) => {
+        await sleep(delays[0]);
+        server.send(rid + "|" + e.data + "|" + request.headers.get("x-rid"));
+      });
+      return new Response(null, { status: 101, webSocket: client });
+    }
+
+    return new Response("ok " + rid);
+  }
+}
+
+export default {
+  async fetch(request, env, ctx) {
+    active++;
+    if (active > maxActive) maxActive = active;
+    try {
+      return await handle(request, env, ctx);
+    } finally {
+      active--;
+    }
+  },
+};

package/test/native-async-local-storage.ts

@@ -0,0 +1,97 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// AsyncLocalStorage (design 02, milestone 2): the store follows the control flow across
+// awaits, promise reactions, timers, intervals, microtasks and ctx.waitUntil, and many
+// requests interleaved in one process each see only their own. The expected values are what
+// workerd (nodejs_compat) answers for test/fixtures/als-app.js.
+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-als-"));
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  const project = join(workdir, "app");
+  mkdirSync(join(project, "src"), { recursive: true });
+  writeFileSync(join(project, "src/index.js"), readFileSync(new URL("./fixtures/als-app.js", import.meta.url)));
+  writeFileSync(
+    join(project, "sproutboat.jsonc"),
+    JSON.stringify({ name: "als", main: "src/index.js", compatibility_date: process.env.SB_COMPAT ?? "2026-11-01" }),
+  );
+  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();
+  server = Bun.spawn([join(project, "dist/als")], {
+    cwd: project,
+    env: { ...process.env, PORT: String(port), SB_DATA_DIR: join(project, "data") },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  const base = `http://127.0.0.1:${port}`;
+  let ready = false;
+  for (let attempt = 0; attempt < 100 && !ready; attempt++) {
+    try {
+      await fetch(`${base}/none`, { signal: AbortSignal.timeout(500) });
+      ready = true;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(ready, "the standalone app did not start");
+  const get = async (path: string) => (await fetch(`${base}${path}`)).json();
+
+  assert.deepEqual(await get("/basic"), [
+    null,
+    "a",
+    "b",
+    null,
+    ["a", "x"],
+    null,
+    ["threw", "boom", null],
+    ["args", 1, 2],
+    7,
+  ]);
+  const steps = (id: string) => [id, id, id, id, id, id, id, `q${id}`, `i${id}`, `i${id}`, `c${id}`, `s${id}`];
+  assert.deepEqual(await get("/await?id=one&d=2"), steps("one"));
+  assert.deepEqual(await get("/bind"), ["captured", "captured", "snap", null, "captured"]);
+  assert.deepEqual(await get("/nested-async?d=2"), ["outer", "inner", "outer", "outer"]);
+  assert.deepEqual(await get("/leak?d=2"), [null, null]);
+  await (await fetch(`${base}/wu?id=wu1&d=20`)).text();
+  await Bun.sleep(100);
+  assert.equal(await (await fetch(`${base}/wu-read`)).text(), "wu1");
+  console.log(
+    "run, exit and snapshot behave as workerd's; the store follows awaits, timers, intervals, microtasks and waitUntil",
+  );
+
+  // Many requests at once, each with its own store and its own delays.
+  const ids = Array.from({ length: 60 }, (_, i) => `req${i}`);
+  const answers = await Promise.all(ids.map((id, i) => get(`/await?id=${id}&d=${1 + (i % 7)}`)));
+  ids.forEach((id, i) => assert.deepEqual(answers[i], steps(id), `request ${id} saw another request's store`));
+  const nested = await Promise.all(ids.map((id, i) => get(`/nested-async?id=${id}&d=${1 + (i % 5)}`)));
+  nested.forEach((answer) => assert.deepEqual(answer, ["outer", "inner", "outer", "outer"]));
+  assert.equal(server.exitCode, null, "the server exited");
+  console.log("60 interleaved requests each saw only their own store at every await");
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  rmSync(workdir, { recursive: true, force: true });
+}

package/test/native-concurrent-requests.ts

@@ -0,0 +1,87 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { drive, startUpstream } from "./concurrent-driver";
+
+// Concurrent requests in one process (design 02, milestone 1). A standalone binary serves many
+// requests at once: they interleave on timers, request and response body streams, KV, D1 and
+// in-worker WebSockets, and each reply must hold only its own request's values (headers, body,
+// cookie, env, ctx, cf, errors, ctx.waitUntil results). The same app and driver run against a
+// sproutd worker (test/concurrency-smoke.py, which serves up to 8 requests per process).
+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-concurrent-"));
+const upstream = startUpstream();
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  const project = join(workdir, "app");
+  mkdirSync(join(project, "src"), { recursive: true });
+  writeFileSync(join(project, "src/index.js"), readFileSync(new URL("./fixtures/concurrent-app.js", import.meta.url)));
+  writeFileSync(
+    join(project, "sproutboat.jsonc"),
+    JSON.stringify({
+      name: "conc",
+      main: "src/index.js",
+      compatibility_date: process.env.SB_COMPAT ?? "2026-11-01",
+      vars: { GREETING: "hi" },
+      kv_namespaces: ["KV"],
+      d1_databases: ["DB"],
+    }),
+  );
+  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();
+  server = Bun.spawn([join(project, "dist/conc")], {
+    cwd: project,
+    env: { ...process.env, PORT: String(port), SB_EGRESS_ALLOW: "127.0.0.1", SB_DATA_DIR: join(project, "data") },
+    stdout: "ignore",
+    stderr: "ignore",
+  });
+  const base = `http://127.0.0.1:${port}`;
+  let ready = false;
+  for (let attempt = 0; attempt < 100 && !ready; attempt++) {
+    try {
+      await fetch(`${base}/ping`, { signal: AbortSignal.timeout(500) });
+      ready = true;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(ready, "the standalone app did not start");
+
+  const { requests, failures } = await drive({
+    base,
+    upstream: `http://127.0.0.1:${upstream.port}`,
+    requests: Number(process.env.SB_CONC_REQUESTS ?? 40),
+    rounds: Number(process.env.SB_CONC_ROUNDS ?? 5),
+    clientSockets: false,
+    store: true,
+  });
+  assert.equal(failures.length, 0, `cross-request leaks or failures:\n${failures.slice(0, 20).join("\n")}`);
+  assert.equal(server.exitCode, null, "the server exited");
+  console.log(`Standalone: ${requests} interleaved requests, no value crossed between them`);
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  upstream.stop(true);
+  rmSync(workdir, { recursive: true, force: true });
+}