@sproutboat/runtime 0.16.0 → 0.17.1

package/test/native-bodies.ts

@@ -0,0 +1,136 @@
+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";
+
+// Bodies on the wire and the Fetch classes, against Bun: byte bodies go out as their bytes
+// (a Uint8Array was sent as "104,105"), Blob and FormData bodies carry their type, and
+// Request/Response/Blob follow the spec where Bun and workerd agree.
+const handler = `export default {async fetch(request) {
+  const path = new URL(request.url).pathname;
+  if (path === "/u8") return new Response(new Uint8Array([104, 105, 0, 255]));
+  if (path === "/ab") return new Response(new Uint8Array([1, 2, 3]).buffer);
+  if (path === "/blob") return new Response(new Blob(["hé", new Uint8Array([33])], { type: "text/x-test" }));
+  if (path === "/stream") return new Response(new ReadableStream({ start(c) { c.enqueue(new TextEncoder().encode("he")); c.enqueue(new Uint8Array([108, 108, 111])); c.close(); } }));
+  if (path === "/stream-async") { await null; return new Response(new ReadableStream({ async pull(c) { await new Promise((r) => setTimeout(r, 5)); c.enqueue(new Uint8Array([0, 255])); c.close(); } }).pipeThrough(new TransformStream())); }
+  if (path === "/stream-strings") return new Response(new ReadableStream({ start(c) { c.enqueue("text"); c.close(); } }));
+  if (path === "/form") { const f = new FormData(); f.append("a", "1"); f.append("f", new Blob(["xy"]), "n.txt"); return new Response(f); }
+  const cases = [
+    () => new Request("http://a.test/a/../b?x=1#f").url,
+    async () => { const r = new Request("http://a.test", { method: "POST", body: "x" }); await r.text(); try { await r.text(); return "no throw"; } catch (e) { return r.bodyUsed + ":" + e.name; } },
+    () => new Request("http://a.test").redirect,
+    () => { try { new Request("/relative"); return "no throw"; } catch (e) { return e.name; } },
+    () => new Response("x", { status: 201, statusText: "Made" }).statusText,
+    () => { try { new Response("x", { status: 99 }); return "no throw"; } catch (e) { return e.name; } },
+    () => Response.error().type + ":" + Response.error().status,
+    async () => Array.from(new Uint8Array(await new Response(new Uint8Array([1, 2, 3])).arrayBuffer())).join(),
+    async () => (await new Response("abc").blob()).size,
+    () => { const b = new Blob(["abcdef"], { type: "Text/Plain" }); return b.size + ":" + b.type; },
+    async () => new Blob(["abcdef"]).slice(-2).text(),
+    async () => { const f = new FormData(); f.append("f", new Blob(["x"]), "n.txt"); const v = f.get("f"); return v.name + ":" + v.size; },
+    async () => (await new Response(new URLSearchParams({ a: "1" })).text()) + "|" + new Response(new URLSearchParams("a=1")).headers.get("content-type"),
+  ];
+  const out = [];
+  for (const run of cases) { try { out.push(String(await run())); } catch (e) { out.push("THROWS " + (e && e.name)); } }
+  return new Response(JSON.stringify(out));
+}};`;
+const CASE_SOURCES = handler.slice(handler.indexOf("const cases = ["), handler.indexOf("  ];") + 4);
+
+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-bodies-"));
+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, "bodies.generated.js");
+  const binary = join(workdir, "bodies-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 bytes = async (path: string) => {
+    const r = await fetch(`http://127.0.0.1:${port}${path}`);
+    return { type: r.headers.get("content-type"), bytes: Array.from(new Uint8Array(await r.arrayBuffer())) };
+  };
+  assert.deepEqual(await bytes("/u8"), { type: null, bytes: [104, 105, 0, 255] });
+  assert.deepEqual(await bytes("/ab"), { type: null, bytes: [1, 2, 3] });
+  assert.deepEqual(await bytes("/blob"), { type: "text/x-test", bytes: [104, 195, 169, 33] });
+  assert.deepEqual(await bytes("/stream"), { type: null, bytes: [104, 101, 108, 108, 111] });
+  assert.deepEqual(await bytes("/stream-async"), { type: null, bytes: [0, 255] });
+  // A stream of strings is not a body (TypeError, as in workerd). Streamed, the status line is
+  // already out when the first chunk is read, so the response ends empty instead of a 500.
+  const strings = await fetch(`http://127.0.0.1:${port}/stream-strings`);
+  assert.equal(await strings.text(), "", "a stream of strings sends no body");
+  const form = await fetch(`http://127.0.0.1:${port}/form`);
+  const boundary = (form.headers.get("content-type") || "").split("boundary=")[1];
+  assert(boundary, "multipart content type");
+  const parsed = await new Response(await form.arrayBuffer(), { headers: { "content-type": `multipart/form-data; boundary=${boundary}` } }).formData();
+  assert.equal(parsed.get("a"), "1");
+  const file = parsed.get("f");
+  assert(file instanceof File, "the file part parses back as a File");
+  assert.equal(await file.text(), "xy");
+  assert.equal(file.name, "n.txt");
+  // SAFETY: the handler above is the only producer of this body: a JSON array with one
+  // string per case.
+  const got = JSON.parse(await (await fetch(`http://127.0.0.1:${port}/cases`)).text()) as string[];
+  const want: string[] = [];
+  // SAFETY: CASE_SOURCES is the handler's own literal list of case functions.
+  const reference = new Function(`return (() => { ${CASE_SOURCES} return cases; })()`)() as Array<() => Promise<string> | string>;
+  for (const run of reference) {
+    try { want.push(String(await run())); } catch (e) { want.push("THROWS " + (e instanceof Error ? e.name : String(e))); }
+  }
+  assert.deepEqual(got, want);
+  console.log(`Native bodies are sent as bytes and ${want.length} Fetch class cases match Bun`);
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-errors.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";
+
+// Error.stack as V8 starts it (Bun is the reference for the first line): Porffor keeps no
+// frames, so only the "Name: message" line is compared.
+const CASES = [
+  `typeof new Error("boom").stack`,
+  `new Error("boom").stack.split("\\n")[0]`,
+  `new Error().stack.split("\\n")[0]`,
+  `new TypeError("bad type").stack.split("\\n")[0]`,
+  `new RangeError("out").stack.split("\\n")[0]`,
+  `(() => { try { null.x; } catch (e) { return typeof e.stack; } })()`,
+  `(() => { try { throw new Error("thrown"); } catch (e) { return e.stack.split("\\n")[0]; } })()`,
+  `JSON.stringify(new Error("x").stack.split("\\n")[0])`,
+];
+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-errors-"));
+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, "errors.generated.js");
+  const binary = join(workdir, "errors-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, [], `Error.stack differs from V8 in ${diffs.length} of ${CASES.length} cases:\n${diffs.join("\n")}`);
+  console.log(`Native Error.stack starts like V8 in all ${CASES.length} cases`);
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-events.ts

@@ -0,0 +1,102 @@
+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";
+
+// structuredClone, Event/EventTarget and AbortController in a compiled handler,
+// compared with Bun (the prelude polyfills them; found by the W2 conformance suite).
+const CASES = [
+  `(() => { const a = { n: 1, m: new Map([["k", new Set([1])]]), d: new Date(0), b: new Uint8Array([1, 2]) }; a.self = a; const c = structuredClone(a); return [c.self === c, c !== a, [...c.m.get("k")].join(), c.d.getTime(), c.b[1]].join(); })()`,
+  `(() => { try { structuredClone(() => 1); return "no throw"; } catch (e) { return e.name; } })()`,
+  `(() => { const e = structuredClone(new RangeError("x")); return e.name + ":" + e.message; })()`,
+  `(() => { const t = new EventTarget(); const o = []; const f = () => o.push("f"); t.addEventListener("x", f); t.addEventListener("x", f); t.addEventListener("x", () => o.push("once"), { once: true }); t.addEventListener("x", { handleEvent() { o.push("h"); } }); t.dispatchEvent(new Event("x")); t.dispatchEvent(new Event("x")); return o.join(); })()`,
+  `(() => { const t = new EventTarget(); t.addEventListener("x", (e) => e.preventDefault()); return [t.dispatchEvent(new Event("x", { cancelable: true })), t.dispatchEvent(new Event("x"))].join(); })()`,
+  `new CustomEvent("c", { detail: { a: 1 } }).detail.a`,
+  `(() => { const c = new AbortController(); let n = 0; c.signal.addEventListener("abort", () => n++); c.signal.onabort = () => n++; c.abort(); c.abort(); return [c.signal.aborted, c.signal.reason.name, n].join(); })()`,
+  `(() => { const c = new AbortController(); const s = AbortSignal.any([c.signal, new AbortController().signal]); c.abort("y"); return s.reason; })()`,
+  `(() => { try { AbortSignal.abort(new TypeError("t")).throwIfAborted(); return "no throw"; } catch (e) { return e.name; } })()`,
+  `(() => { const c = new AbortController(); const t = new EventTarget(); let n = 0; t.addEventListener("x", () => n++, { signal: c.signal }); c.abort(); t.dispatchEvent(new Event("x")); return n; })()`,
+];
+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-events-"));
+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, "events.generated.js");
+  const binary = join(workdir, "events-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, [], `Event, abort and clone results differ from Bun in ${diffs.length} of ${CASES.length} cases:\n${diffs.join("\n")}`);
+  console.log(`Native events, abort and structuredClone 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-iterators.ts

@@ -10,6 +10,7 @@ const expected = {
   keys: ["a", "a", "b"], values: ["1", "2", "3"],
   live: ["x", "y", true], form: [["x", "1"], ["x", "2"]],
   formLive: ["x", "y", true], self: true,
+  headers: [["a", "1"], ["b", "2"]], headersMap: 2, headersFromEntries: { a: "1", b: "2" },
 };
 const handler = `export default { fetch(request) {
   if (new URL(request.url).pathname === "/null") return new Response(null);
@@ -27,9 +28,13 @@ const handler = `export default { fetch(request) {
   const liveForm = new FormData(); liveForm.append("x", "1");
   const formIterator = liveForm.keys(); const f1 = formIterator.next().value;
   liveForm.append("y", "2"); const f2 = formIterator.next().value;
+  // Sorted input: the spec also sorts and combines on iteration, which Porffor's
+  // Headers does not do yet (insertion order).
+  const h = new Headers([["a", "1"], ["b", "2"]]);
   return Response.json({ query, keys: Array.from(params.keys()), values: Array.from(params.values()),
     live: [first, second, done], form, formLive: [f1, f2, formIterator.next().done],
-    self: iterator[Symbol.iterator]() === iterator });
+    self: iterator[Symbol.iterator]() === iterator,
+    headers: [...h], headersMap: new Map(h).size, headersFromEntries: Object.fromEntries(h) });
 } };`;
 
 function freePort(): number {

package/test/native-json.ts

@@ -0,0 +1,102 @@
+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";
+
+// JSON.stringify as the spec defines it (Bun is the reference): toJSON on Date, URL and
+// user objects, nested and in arrays, and a toJSON that returns undefined.
+const CASES = [
+  `JSON.stringify({ at: new Date(0) })`,
+  `JSON.stringify([new Date(86400000), 1])`,
+  `JSON.stringify(new Date(1700000000000))`,
+  `JSON.stringify({ u: new U("https://a.com/x?y=1") })`,
+  `JSON.stringify({ a: { toJSON() { return { b: 2 }; } } })`,
+  `JSON.stringify({ a: 1, gone: { toJSON() { return undefined; } } })`,
+  `JSON.stringify({ n: { toJSON() { return 42; } } })`,
+  `JSON.stringify({ nested: { at: new Date(0), list: [new Date(0)] } })`,
+  `JSON.stringify({ plain: { x: 1 } })`,
+];
+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-json-"));
+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, "json.generated.js");
+  const binary = join(workdir, "json-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, [], `JSON.stringify differs from the spec in ${diffs.length} of ${CASES.length} cases:\n${diffs.join("\n")}`);
+  console.log(`Native JSON.stringify honours toJSON in all ${CASES.length} cases: Date, URL, user objects, nested, undefined`);
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

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 });
+}