@sproutboat/runtime 0.16.0 → 0.17.1

package/test/native-request.ts

@@ -0,0 +1,101 @@
+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";
+
+// new Request(request, init) and fetch-style Request copies, compared with Bun: the copy
+// keeps method, URL, headers and body, and init overrides them field by field (W1).
+const CASES = [
+  `new Request(new Request("http://a.test/x", { method: "PUT" })).method`,
+  `new Request(new Request("http://a.test/x?q=1")).url`,
+  `new Request(new Request("http://a.test/x", { method: "PUT" }), { method: "DELETE" }).method`,
+  `new Request(new Request("http://a.test/x", { headers: { a: "1" } })).headers.get("a")`,
+  `[...new Request(new Request("http://a.test/x", { headers: { a: "1" } }), { headers: { b: "2" } }).headers].join(";")`,
+  `new Request(new Request("http://a.test/x", { method: "POST", body: "hi" })).text()`,
+  `new Request(new Request("http://a.test/x", { method: "POST", body: "hi" }), { body: "yo" }).text()`,
+  `new Request(new URL("http://a.test/u")).url`,
+  `new Request("http://a.test/x", { method: "post" }).method`,
+];
+const handler = `export default {async fetch() {
+  const cases = [
+${CASES.map((c) => `    () => (${c}),`).join("\n")}
+  ];
+  const out = [];
+  for (const run of cases) {
+    try { out.push(String(await run())); } catch (e) { out.push("THROWS " + (e && e.message)); }
+  }
+  return new Response(JSON.stringify(out));
+}};`;
+const want = await Promise.all(CASES.map(async (c) => { try { return String(await new Function("return " + c)()); } catch (e) { return "THROWS " + (e instanceof Error ? e.message : String(e)); } }));
+
+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 = await mkdtemp(join(tmpdir(), "sb-native-request-"));
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  const porffor = await ensurePorffor();
+  const node = Bun.which("node");
+  if (!node) throw new Error("native streams 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 prelude = core.replace(TRANSPORT_MARKER, broker);
+  const generated = join(workdir, "request.generated.js");
+  const binary = join(workdir, "request-native");
+  await writeFile(generated, wrapNativeFetchHandler(handler, prelude));
+  await rm(binary, { force: true });
+
+  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) },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  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");
+  // SAFETY: the handler above is the only producer of this body: a JSON array with one
+  // string per case; the comparison below reports any entry that differs.
+  const got = JSON.parse(await (await fetch(`http://127.0.0.1:${port}/`)).text()) as string[];
+  const diffs = CASES.flatMap((c, i) => (got[i] === want[i] ? [] : [`${c}\n    want ${JSON.stringify(want[i])}\n    got  ${JSON.stringify(got[i])}`]));
+  assert.deepEqual(diffs, [], `Request copies differ from Bun in ${diffs.length} of ${CASES.length} cases:\n${diffs.join("\n")}`);
+  console.log(`Native Request copies match Bun in all ${CASES.length} cases`);
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-response-defaults.ts

@@ -0,0 +1,98 @@
+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";
+
+// What workerd answers for the same handler (checked 2026-10-19, workerd 2026-10-16).
+const expected = {
+  "/text": { type: "text/plain;charset=UTF-8" },
+  "/typed": { type: "text/html" },
+  "/json": { type: "application/json" },
+  "/null": { type: null },
+  "/bytes": { type: null },
+  "/redirect": { type: null, location: "https://example.com/" },
+  "/throw": { type: null },
+} satisfies Record<string, { type: string | null; location?: string }>;
+const handler = `export default {fetch(request) {
+  const path = new URL(request.url).pathname;
+  if (path === "/text") return new Response("hello");
+  if (path === "/typed") return new Response("<p>hi</p>", { headers: { "content-type": "text/html" } });
+  if (path === "/json") return Response.json({ a: 1 });
+  if (path === "/null") return new Response(null, { status: 204 });
+  if (path === "/bytes") return new Response(new Uint8Array([1, 2, 3]));
+  if (path === "/redirect") return Response.redirect("https://example.com", 301);
+  if (path === "/throw") throw new Error("boom");
+  return new Response("not found", { status: 404 });
+}};`;
+
+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 = await mkdtemp(join(tmpdir(), "sb-native-response-defaults-"));
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  const porffor = await ensurePorffor();
+  const node = Bun.which("node");
+  if (!node) throw new Error("native streams 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 prelude = core.replace(TRANSPORT_MARKER, broker);
+  const generated = join(workdir, "response.generated.js");
+  const binary = join(workdir, "response-native");
+  await writeFile(generated, wrapNativeFetchHandler(handler, prelude));
+  await rm(binary, { force: true });
+
+  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) },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  let ready = false;
+  for (let attempt = 0; attempt < 50 && !ready; attempt++) {
+    try {
+      await fetch(`http://127.0.0.1:${port}/text`, { signal: AbortSignal.timeout(500) });
+      ready = true;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(ready, "compiled handler did not start");
+  for (const [path, want] of Object.entries(expected)) {
+    const response = await fetch(`http://127.0.0.1:${port}${path}`, { redirect: "manual" });
+    assert.equal(response.headers.get("content-type"), want.type, `${path} content-type`);
+    if ("location" in want) assert.equal(response.headers.get("location"), want.location, `${path} location`);
+  }
+  console.log("Native Response defaults match workerd: text/plain for strings, application/json, normalized redirects");
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-streaming.ts

@@ -0,0 +1,117 @@
+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 ReadableStream response body is streamed (B19): each chunk reaches the client when the
+// handler produces it, over chunked encoding, with the handler's headers and no internal
+// marker; a client that goes away does not take the server down.
+const handler = `export default {async fetch(request) {
+  const path = new URL(request.url).pathname;
+  const enc = new TextEncoder();
+  if (path === "/slow") {
+    let n = 0;
+    return new Response(new ReadableStream({ async pull(c) {
+      if (n === 3) { c.close(); return; }
+      if (n > 0) await new Promise((r) => setTimeout(r, 300));
+      c.enqueue(enc.encode("chunk" + n + "\\n")); n++;
+    } }), { headers: { "content-type": "text/event-stream" } });
+  }
+  if (path === "/forever") {
+    let n = 0;
+    return new Response(new ReadableStream({ async pull(c) { await new Promise((r) => setTimeout(r, 50)); c.enqueue(enc.encode("tick " + n++ + "\\n")); } }));
+  }
+  return new Response("ok");
+}};`;
+
+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 = await mkdtemp(join(tmpdir(), "sb-native-streaming-"));
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  const porffor = await ensurePorffor();
+  const node = Bun.which("node");
+  if (!node) throw new Error("native streaming 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 prelude = core.replace(TRANSPORT_MARKER, broker);
+  const generated = join(workdir, "streaming.generated.js");
+  const binary = join(workdir, "streaming-native");
+  await writeFile(generated, wrapNativeFetchHandler(handler, prelude, undefined, undefined, undefined, "2026-10-01"));
+  await rm(binary, { force: true });
+
+  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) },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  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");
+
+  const t0 = performance.now();
+  const res = await fetch(`http://127.0.0.1:${port}/slow`);
+  assert.equal(res.headers.get("content-type"), "text/event-stream");
+  assert.equal(res.headers.get("x-sb-stream"), null, "the internal stream marker is never sent");
+  const reader = res.body!.getReader();
+  const decoder = new TextDecoder();
+  const arrivals: { ms: number; text: string }[] = [];
+  for (;;) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    arrivals.push({ ms: performance.now() - t0, text: decoder.decode(value) });
+  }
+  assert.equal(arrivals.map((a) => a.text).join(""), "chunk0\nchunk1\nchunk2\n");
+  // Buffered, everything would arrive together after ~600 ms.
+  assert(arrivals[0].ms < 250, `the first chunk took ${Math.round(arrivals[0].ms)} ms`);
+  assert(arrivals[arrivals.length - 1].ms - arrivals[0].ms > 400, "chunks arrived together, not as produced");
+
+  const abort = new AbortController();
+  const forever = await fetch(`http://127.0.0.1:${port}/forever`, { signal: abort.signal });
+  assert.equal(decoder.decode((await forever.body!.getReader().read()).value), "tick 0\n");
+  abort.abort();
+  await Bun.sleep(300);
+  assert.equal(server.exitCode, null, "a client that went away took the server down");
+  assert.equal(await (await fetch(`http://127.0.0.1:${port}/`)).text(), "ok");
+  console.log(`Native streamed body: chunks at ${arrivals.map((a) => Math.round(a.ms)).join(", ")} ms`);
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-url.ts

@@ -0,0 +1,145 @@
+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";
+
+// URL as WHATWG defines it (Bun's URL is the reference): base URLs, setters on every
+// part, hash, default ports, dot segments, percent-encoding, and searchParams writing
+// back into the URL. Each case is an expression over U, the URL class under test.
+const CASES = [
+  `new U("https://Example.COM:443/a/./b/../c?x=1#frag").href`,
+  `new U("http://example.com:80").href`,
+  `new U("http://example.com:8080/p").host`,
+  `new U("/path?q=1", "https://a.com/base/x").href`,
+  `new U("rel", "https://a.com/base/x").href`,
+  `new U("../up", "https://a.com/a/b/c").href`,
+  `new U("?q", "https://a.com/p?old#h").href`,
+  `new U("#h2", "https://a.com/p?old#h").href`,
+  `new U("//other.com/x", "https://a.com/").href`,
+  `new U("./", "https://a.com/a/b").href`,
+  `new U("..", "https://a.com/a/b/").href`,
+  `new U("x", new U("https://a.com/d/")).href`,
+  `(() => { const u = new U("https://foo.example.com/api.js"); u.hostname = "example.com"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/"); u.port = "8080"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com:8080/"); u.port = "443"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com:8080/"); u.port = ""; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x"); u.protocol = "http"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x"); u.protocol = "http:"; u.port = "80"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x"); u.host = "b.com:9"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x"); u.search = "a=1&b=2"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x?a=1"); u.search = ""; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x"); u.hash = "top"; return u.href + " " + u.hash; })()`,
+  `(() => { const u = new U("https://a.com/x#top"); u.hash = ""; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x"); u.pathname = "new path"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x?a=1"); u.searchParams.set("b", "two words"); return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x?a=1&a=2"); u.searchParams.delete("a"); return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x?b=2&a=1"); u.searchParams.sort(); return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x?a=1"); const p = u.searchParams; u.search = "?z=9"; return p.get("z") + " " + p.get("a"); })()`,
+  `(() => { const u = new U("https://a.com/x"); u.searchParams.append("q", "a+b&c=d!'()~*"); return u.search; })()`,
+  `new U("https://a.com/x?a=1").searchParams.get("a")`,
+  `new U("http://u:p@h.com/").username + " " + new U("http://u:p@h.com/").password`,
+  `new U("http://u:p@h.com/").href`,
+  `new U("https://a.com/p").origin`,
+  `new U("http://[::1]:8080/").hostname + " " + new U("http://[::1]:8080/").port`,
+  `new U("http://[::1]:8080/").host`,
+  `U.canParse("nope") + " " + U.canParse("https://a.com") + " " + U.canParse("/x", "https://a.com")`,
+  `(() => { try { new U("nope"); return "no throw"; } catch (e) { return e instanceof TypeError; } })()`,
+  `(() => { try { new U("https://"); return "no throw"; } catch (e) { return e instanceof TypeError; } })()`,
+  `JSON.stringify({ u: new U("https://a.com") })`,
+  `new U("https://a.com").pathname`,
+  `new U("mailto:x@y.com").pathname + " " + new U("mailto:x@y.com").protocol + " " + new U("mailto:x@y.com").origin`,
+  `String(new U("https://a.com/a b"))`,
+  `new U("https://a.com/é?q=ü#ä").href`,
+  `new U("https://a.com/x?q=it's").search`,
+  `new U("HTTPS://A.COM/X").href`,
+  `new U("https://a.com?").href`,
+  `new U("https://a.com#").href`,
+  `new U("https://a.com/%2e/x").pathname`,
+  `(() => { const u = new U("https://a.com/x"); u.href = "http://b.com/y?z"; return u.host + " " + u.pathname + " " + u.search; })()`,
+  `new U("https://a.com/x?a=1#f").toString()`,
+];
+
+const handler = `export default {fetch() {
+  const U = URL;
+  const cases = [
+${CASES.map((c) => `    () => (${c}),`).join("\n")}
+  ];
+  const out = [];
+  for (const run of cases) {
+    try { out.push(String(run())); } catch (e) { out.push("THROWS " + (e && e.message)); }
+  }
+  return new Response(JSON.stringify(out));
+}};`;
+const want = CASES.map((c) => String(new Function("U", "return " + c)(URL)));
+
+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 = await mkdtemp(join(tmpdir(), "sb-native-url-"));
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  const porffor = await ensurePorffor();
+  const node = Bun.which("node");
+  if (!node) throw new Error("native streams 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 prelude = core.replace(TRANSPORT_MARKER, broker);
+  const generated = join(workdir, "url.generated.js");
+  const binary = join(workdir, "url-native");
+  await writeFile(generated, wrapNativeFetchHandler(handler, prelude));
+  await rm(binary, { force: true });
+
+  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) },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  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");
+  // SAFETY: the handler above is the only producer of this body: a JSON array with one
+  // string per case; the comparison below reports any entry that differs.
+  const got = JSON.parse(await (await fetch(`http://127.0.0.1:${port}/`)).text()) as string[];
+  const diffs = CASES.flatMap((c, i) => (got[i] === want[i] ? [] : [`${c}\n    want ${JSON.stringify(want[i])}\n    got  ${JSON.stringify(got[i])}`]));
+  assert.deepEqual(diffs, [], `URL differs from WHATWG in ${diffs.length} of ${CASES.length} cases:\n${diffs.join("\n")}`);
+  console.log(`Native URL matches WHATWG URL in all ${CASES.length} cases: base URLs, setters, hash, ports, dot segments, encoding, searchParams`);
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-waituntil.ts

@@ -0,0 +1,107 @@
+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";
+
+// ctx.waitUntil work runs after the response, as in workerd: the response does not wait
+// for it, the work still finishes, and its 25 s cap leaves no timer behind once it is done.
+const handler = `export default {async fetch(request, env, ctx) {
+  const path = new URL(request.url).pathname;
+  if (path === "/later") {
+    globalThis.__done = "pending";
+    ctx.waitUntil(new Promise((resolve) => setTimeout(() => { globalThis.__done = "done"; resolve(); }, 400)));
+    return new Response("scheduled");
+  }
+  if (path === "/state") return new Response(String(globalThis.__done));
+  if (path === "/cron") return new Response(String(globalThis.__cron));
+  return new Response("ok");
+},
+async scheduled(event, env, ctx) {
+  ctx.waitUntil(new Promise((resolve) => setTimeout(() => { globalThis.__cron = event.cron; resolve(); }, 50)));
+}};`;
+
+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 = await mkdtemp(join(tmpdir(), "sb-native-waituntil-"));
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  const porffor = await ensurePorffor();
+  const node = Bun.which("node");
+  if (!node) throw new Error("native streams 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 prelude = core.replace(TRANSPORT_MARKER, broker);
+  const generated = join(workdir, "waituntil.generated.js");
+  const binary = join(workdir, "waituntil-native");
+  await writeFile(generated, wrapNativeFetchHandler(handler, prelude, undefined, undefined, undefined, "2026-10-01"));
+  await rm(binary, { force: true });
+
+  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: "inherit",
+  });
+  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");
+  const t0 = performance.now();
+  const first = await (await fetch(`http://127.0.0.1:${port}/later`)).text();
+  const elapsed = performance.now() - t0;
+  assert.equal(first, "scheduled");
+  assert(elapsed < 300, `the response waited ${Math.round(elapsed)} ms for its waitUntil work`);
+  assert.equal(await (await fetch(`http://127.0.0.1:${port}/state`)).text(), "pending");
+  await Bun.sleep(700);
+  assert.equal(await (await fetch(`http://127.0.0.1:${port}/state`)).text(), "done");
+  // A trigger answers 204 with no body. new Response("", { status: 204 }) throws under the
+  // Fetch-spec Response, and the prelude used it: the first cron or alarm took the server down.
+  const cron = await fetch(`http://127.0.0.1:${port}/`, {
+    method: "POST",
+    headers: { "x-sb-trigger": "scheduled", "x-sb-token": "native-test-token", "content-type": "application/json" },
+    body: JSON.stringify({ cron: "*/5 * * * *", scheduledTime: Date.now() }),
+  });
+  assert.equal(cron.status, 204);
+  assert.equal(await cron.text(), "");
+  assert.equal(await (await fetch(`http://127.0.0.1:${port}/cron`)).text(), "*/5 * * * *");
+  assert.equal(server.exitCode, null, "the server exited after a scheduled trigger");
+  console.log(`Native waitUntil runs after the response (${Math.round(elapsed)} ms) and completes; scheduled() answers 204`);
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}