@sproutboat/runtime 0.15.0 → 0.17.0

package/test/native-raw-body.ts

@@ -0,0 +1,118 @@
+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";
+
+// fetch() hands a response's bytes back as a raw body (x-sb-raw-body, #176), and
+// they can arrive as a UTF-16 string holding one byte per unit: JSON.parse of the
+// transport's reply makes one. Returning that response unchanged must send the bytes.
+const handler = `export default {fetch() {
+  const bytes = JSON.parse('"caf\\u00e9 \\u00ff ok"');
+  return new Response(bytes, { headers: { "x-sb-raw-body": "1", "content-type": "application/octet-stream" } });
+}};`;
+const want = [0x63, 0x61, 0x66, 0xe9, 0x20, 0xff, 0x20, 0x6f, 0x6b];
+
+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-raw-body-"));
+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, "raw.generated.js");
+  const binary = join(workdir, "raw-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");
+  const response = await fetch(`http://127.0.0.1:${port}/`);
+  const got = [...new Uint8Array(await response.arrayBuffer())];
+  assert.deepEqual(got, want, "raw body bytes");
+  assert.equal(
+    response.headers.get("x-sb-raw-body"),
+    null,
+    "the marker never reaches the client",
+  );
+  console.log("A raw UTF-16 body is sent as its bytes");
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

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-streams.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";
+
+const expected = { chunks: ["a", "b"], transformed: ["X", "Y"], first: { value: "hello", done: false },
+  done: true, locked: false, lockError: true, cancelReason: "stop", error: "broken",
+  tee: [[1, 2], [1, 2]], pulled: [3, 4], pending: "later", bytes: [7, 8], byob: [9, 10] };
+const handler = `export default { async fetch(request) {
+  if (new URL(request.url).pathname === "/null") return new Response(null);
+  const stream = new ReadableStream({start(c){c.enqueue("hello");c.close();}});
+  const reader = stream.getReader(); let lockError = false;
+  try { stream.getReader(); } catch { lockError = true; }
+  const first = await reader.read(); const done = (await reader.read()).done;
+  reader.releaseLock();
+  const chunks = []; await ReadableStream.from(["a", "b"]).pipeTo(new WritableStream({write(x){chunks.push(x);}}));
+  const transformed = [];
+  await ReadableStream.from(["x", "y"]).pipeThrough(new TransformStream({transform(x,c){c.enqueue(x.toUpperCase());}}))
+    .pipeTo(new WritableStream({write(x){transformed.push(x);}}));
+  let cancelReason; await new ReadableStream({cancel(reason){cancelReason=reason;}}).cancel("stop");
+  let error; const broken = new ReadableStream({start(c){c.error(new Error("broken"));}}).getReader();
+  try { await broken.read(); } catch(e) { error=e.message; }
+  const branches=ReadableStream.from([1,2]).tee(); const tee=[[],[]];
+  await Promise.all(branches.map((branch,i)=>branch.pipeTo(new WritableStream({write(x){tee[i].push(x);}}))));
+  let value=3; const pulled=[];
+  await new ReadableStream({pull(c){if(value===5)c.close();else c.enqueue(value++);}})
+    .pipeTo(new WritableStream({write(x){pulled.push(x);}}));
+  let controller; const pendingReader=new ReadableStream({start(c){controller=c;}}).getReader();
+  const read=pendingReader.read(); controller.enqueue("later");controller.close();const pending=(await read).value;
+  const byteReader=new ReadableStream({type:"bytes",start(c){c.enqueue(new Uint8Array([7,8]));c.close();}}).getReader();
+  const bytes=Array.from((await byteReader.read()).value);
+  const byobReader=new ReadableStream({type:"bytes",start(c){c.enqueue(new Uint8Array([9,10]));c.close();}}).getReader({mode:"byob"});
+  const byob=Array.from((await byobReader.read(new Uint8Array(2))).value);
+  return Response.json({bytes,byob,chunks, transformed, first, done, locked:stream.locked,lockError,cancelReason,error,tee,pulled,pending});
+} };`;
+
+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-streams-"));
+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, "streams.generated.js");
+  const binary = join(workdir, "streams-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 response: Response | undefined;
+  for (let attempt = 0; attempt < 50; attempt++) {
+    try {
+      response = await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(500) });
+      break;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(response, "compiled streams handler did not start");
+  assert.equal(response.status, 200);
+  assert.deepEqual(await response.json(), expected);
+  const empty = await fetch(`http://127.0.0.1:${port}/null`);
+  assert.equal(empty.status, 200);
+  assert.equal(await empty.text(), "");
+  console.log("Native Web Streams pass reads, locks, cancellation, errors, piping, transforms, tee and pulls");
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-timers.ts

@@ -0,0 +1,89 @@
+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";
+
+const expected = { fired: 7, cancelled: false, ticks: 2 };
+const handler = `export default {async fetch() {
+  let cancelled = false;
+  const timer = globalThis.setTimeout(() => { cancelled = true; }, 1);
+  globalThis.clearTimeout(timer);
+  const fired = await new Promise(resolve => globalThis.setTimeout(resolve, 1, 7));
+  let ticks = 0;
+  await new Promise(resolve => {
+    const interval = globalThis.setInterval(() => {
+      ticks++;
+      if (ticks === 2) { globalThis.clearInterval(interval); resolve(); }
+    }, 1);
+  });
+  return Response.json({fired, cancelled, ticks});
+}};`;
+
+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-timers-"));
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  const porffor = await ensurePorffor();
+  const node = Bun.which("node");
+  if (!node) throw new Error("native timers 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, "timers.generated.js");
+  const binary = join(workdir, "timers-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 response: Response | undefined;
+  for (let attempt = 0; attempt < 50; attempt++) {
+    try {
+      response = await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(500) });
+      break;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(response, "compiled timers handler did not start");
+  assert.equal(response.status, 200);
+  assert.deepEqual(await response.json(), expected);
+  console.log("Native global timers preserve callbacks, arguments, cancellation and intervals");
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}