@sproutboat/runtime 0.42.2 → 0.44.0

package/test/native-bodies.ts

@@ -1,8 +1,8 @@
 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 { join } from "node:path";
+import { compileNative } from "./native-compile";
 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
@@ -80,14 +80,7 @@ function freePort(): number {
 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"),
-  ]);
+  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");
@@ -95,18 +88,7 @@ try {
   await writeFile(generated, wrapNativeFetchHandler(handler, prelude, undefined, undefined, undefined, "2026-10-21"));
   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}`);
+  await compileNative({ generated, binary, dir: workdir });
 
   const port = freePort();
   server = Bun.spawn([binary], {
@@ -142,7 +124,9 @@ try {
   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();
+  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");
@@ -153,11 +137,20 @@ try {
   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>;
+  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))); }
+    try {
+      want.push(String(await run()));
+    } catch (e) {
+      want.push("THROWS " + (e instanceof Error ? e.name : String(e)));
+    }
   }
-  assert.deepEqual(got, want.map((w) => (w.startsWith("workerd:") ? "workerd:TypeError" : w)));
+  assert.deepEqual(
+    got,
+    want.map((w) => (w.startsWith("workerd:") ? "workerd:TypeError" : w)),
+  );
   console.log(`Native bodies are sent as bytes and ${want.length} Fetch class cases match Bun`);
 } finally {
   if (server) {

package/test/native-byte-text.ts

@@ -1,8 +1,8 @@
 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 { join } from "node:path";
+import { compileNative } from "./native-compile";
 import { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
 
 // sproutd #22: __sbFromUtf8 and __sbToBytes run in C (__sbFromUtf8Native, __sbToBytesNative).
@@ -92,28 +92,12 @@ function freePort(): number {
 const workdir = await mkdtemp(join(tmpdir(), "sb-native-byte-text-"));
 let server: ReturnType<typeof Bun.spawn> | undefined;
 try {
-  const porffor = await ensurePorffor();
-  const node = Bun.which("node");
-  if (!node) throw new Error("native byte-text test needs node on PATH");
   const broker = await readFile(transportPath("broker"), "utf8");
   assert(core.includes(TRANSPORT_MARKER), "runtime prelude is missing its transport marker");
   const generated = join(workdir, "bytes.generated.js");
   const binary = join(workdir, "bytes-native");
   await writeFile(generated, wrapNativeFetchHandler(handler, core.replace(TRANSPORT_MARKER, broker)));
-  const compile = Bun.spawn(
-    [node, resolve(porffor, "runtime/index.js"), "native", generated, "-o", binary, "-s", "-O0"],
-    {
-      cwd: workdir,
-      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}`);
+  await compileNative({ generated, binary, dir: workdir });
 
   const port = freePort();
   // Peak RSS: /proc's high-water mark on Linux, time(1) on macOS.

package/test/native-compile.ts

@@ -0,0 +1,163 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { ensurePorffor } from "../../toolchain/src/acquire";
+import { ensurePorfforA21 } from "../../toolchain/src/a21/acquire";
+import {
+  composeStandaloneA21,
+  SHARED_PRELUDE_FILE,
+  STANDALONE_A21_COMPILE_FLAGS,
+} from "../../toolchain/src/a21/standalone";
+import { buildStandaloneA21 } from "../../toolchain/src/a21/standalone-build";
+import { standaloneChannel } from "../../toolchain/src/a21/standalone-channel";
+import { bearsslEnv } from "./bearssl";
+
+export type NativeCompileInput = {
+  /** The generated module (`wrapNativeFetchHandler` output), already written to disk. */
+  generated: string;
+  /** Where the compiled binary goes. */
+  binary: string;
+  /** Working directory of the compile, and where alpha 22 puts its intermediate files. Default: the binary's directory. */
+  dir?: string;
+  /** Toolchain cache root for the alpha 19 tree (`ensurePorffor({ cacheRoot })`). */
+  cacheRoot?: string;
+  /** Objects and link flags for the link line (alpha 19: `SB_EXTRA_LINK`). */
+  extraLink?: string[];
+  /** Flags for every C compile (alpha 19: `SB_EXTRA_CFLAGS`). */
+  extraCflags?: string[];
+  /** Link BearSSL, as a test that uses crypto.subtle needs. */
+  bearssl?: boolean;
+  /** `-O` level. Default 0. */
+  optimize?: number;
+  /** Extra environment for the alpha 19 compiler process (the default is `process.env`). */
+  env?: Record<string, string>;
+  /** Message prefix of the failure assertion. Default "Porffor native compile failed". */
+  failure?: string;
+};
+
+type UwsModule = {
+  UWS_COMMIT: string;
+  ensureUWebSockets: () => string;
+  ensureUSocketsBuilt: (dir: string) => void;
+};
+
+let renderQueue: Promise<void> = Promise.resolve();
+
+const channel = () => standaloneChannel();
+
+const split = (flags: string | undefined): string[] => (flags ?? "").split(" ").filter(Boolean);
+
+async function drain(child: Bun.Subprocess<"ignore", "pipe", "pipe">) {
+  const [exitCode, stdout, stderr] = await Promise.all([
+    child.exited,
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+  ]);
+  return { exitCode, stdout, stderr };
+}
+
+/** The host uWebSockets checkout with a built uSockets.a, built on first use. */
+async function uwsDirectory(alpha19: string): Promise<string> {
+  // SAFETY: the patched alpha 19 tree's compiler/uwebsockets.js exports these (see the toolchain's standaloneShimSource).
+  const mod: UwsModule = await import(resolve(alpha19, "compiler/uwebsockets.js"));
+  const dir = resolve(homedir(), ".cache/porffor/deps", `uWebSockets-${mod.UWS_COMMIT}`);
+  if (!existsSync(join(dir, "uSockets/uSockets.a"))) {
+    // SAFETY: the compiler's prefs.js installs `Prefs` on globalThis as a plain flag object.
+    const g = globalThis as { Prefs?: { eventLoop?: boolean } };
+    const prev = g.Prefs;
+    g.Prefs = { ...prev, eventLoop: true };
+    try {
+      mod.ensureUSocketsBuilt(mod.ensureUWebSockets());
+    } finally {
+      if (prev === undefined) delete g.Prefs;
+      else g.Prefs = prev;
+    }
+  }
+  return dir;
+}
+
+/** Compile a generated module into a native binary on the standalone channel (alpha 22 by default, `SPROUTBOAT_PORFFOR_CHANNEL=alpha-19` for the fallback). */
+export async function compileNative(input: NativeCompileInput): Promise<void> {
+  const which = channel();
+  const dir = input.dir ?? dirname(input.binary);
+  const optimize = input.optimize ?? 0;
+  const failure = input.failure ?? "Porffor native compile failed";
+  const bearssl = input.bearssl ? await bearsslEnv() : undefined;
+  const extraLink = [...(input.extraLink ?? []), ...split(bearssl?.SB_EXTRA_LINK)];
+  const extraCflags = [...(input.extraCflags ?? []), ...split(bearssl?.SB_EXTRA_CFLAGS)];
+  const alpha19 = await ensurePorffor(input.cacheRoot === undefined ? {} : { cacheRoot: input.cacheRoot });
+
+  if (which === "alpha-19") {
+    const node = Bun.which("node");
+    if (!node) throw new Error("native compile needs node on PATH");
+    const env = { ...process.env, ...input.env };
+    if (extraLink.length > 0) env.SB_EXTRA_LINK = extraLink.join(" ");
+    if (extraCflags.length > 0) env.SB_EXTRA_CFLAGS = extraCflags.join(" ");
+    const compile = Bun.spawn(
+      [
+        node,
+        resolve(alpha19, "runtime/index.js"),
+        "native",
+        input.generated,
+        "-o",
+        input.binary,
+        "-s",
+        `-O${optimize}`,
+      ],
+      { cwd: dir, env, stdout: "pipe", stderr: "pipe" },
+    );
+    const { exitCode, stdout, stderr } = await drain(compile);
+    if (exitCode !== 0) throw new Error(`${failure}:\n${stderr}\n${stdout}`);
+    return;
+  }
+
+  const bun = process.execPath;
+  const alpha22 = await ensurePorfforA21("alpha-22");
+  const work = join(dir, `a22-${(input.binary.split("/").pop() ?? "bin").replace(/[^\w.-]/g, "_")}`);
+  await rm(work, { recursive: true, force: true });
+  await mkdir(work, { recursive: true });
+  const composed = composeStandaloneA21(await readFile(input.generated, "utf8"), alpha19);
+  // Beside the generated module: its relative imports (a handler's sibling helper files) resolve from the
+  // directory of the file they were written in, and the shared prelude carries the module's body. The
+  // chain recognises the prelude by its file name, so a test that compiles several variants from one
+  // directory at once (native-websockets) takes turns: the render is the only step that reads it.
+  const source = dirname(resolve(input.generated));
+  const entry = join(source, "entry.a22.js");
+  const turn = renderQueue;
+  let release = () => {};
+  renderQueue = new Promise<void>((done) => (release = done));
+  await turn;
+  let rendered: Awaited<ReturnType<typeof drain>>;
+  try {
+    await writeFile(join(source, SHARED_PRELUDE_FILE), composed.sharedPrelude);
+    await writeFile(entry, composed.entry);
+    const unitsDir = join(work, "units");
+    const render = Bun.spawn(
+      [bun, resolve(alpha22, "runtime/index.js"), "c", entry, "-o", `${unitsDir}/`, ...STANDALONE_A21_COMPILE_FLAGS],
+      { cwd: work, env: { ...process.env, ...input.env }, stdout: "pipe", stderr: "pipe" },
+    );
+    rendered = await drain(render);
+  } finally {
+    release();
+  }
+  if (rendered.exitCode !== 0) throw new Error(`${failure} (alpha 22 render):\n${rendered.stderr}\n${rendered.stdout}`);
+  const unitsDir = join(work, "units");
+  await rm(input.binary, { force: true });
+  await buildStandaloneA21({
+    unitsDir,
+    alpha19Root: alpha19,
+    outPath: input.binary,
+    cc: ["cc"],
+    cxx: ["c++"],
+    uwsDir: await uwsDirectory(alpha19),
+    extraLink,
+    extraCflags,
+    optimize,
+    flto: false,
+    musl: false,
+    strip: true,
+  }).catch((error: Error) => {
+    throw new Error(`${failure} (alpha 22 build):\n${error.message}`);
+  });
+}

package/test/native-cpu-requests.ts

@@ -1,8 +1,8 @@
 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 { join } from "node:path";
+import { compileNative } from "./native-compile";
 import { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
 
 // Per-request CPU (design 02): x-sb-cpu-ms counts the thread CPU time of the slices in which one
@@ -43,9 +43,6 @@ function freePort(): number {
 const workdir = await mkdtemp(join(tmpdir(), "sb-native-cpu-requests-"));
 const servers: ReturnType<typeof Bun.spawn>[] = [];
 async function build(date: string): Promise<number> {
-  const porffor = await ensurePorffor();
-  const node = Bun.which("node");
-  if (!node) throw new Error("native cpu test needs node on PATH");
   const [core, broker] = await Promise.all([readFile(preludePath, "utf8"), readFile(transportPath("broker"), "utf8")]);
   assert(core.includes(TRANSPORT_MARKER), "runtime prelude is missing its transport marker");
   const generated = join(workdir, `cpu-${date}.generated.js`);
@@ -54,21 +51,7 @@ async function build(date: string): Promise<number> {
     generated,
     wrapNativeFetchHandler(handler, core.replace(TRANSPORT_MARKER, broker), undefined, undefined, undefined, date),
   );
-  const compile = Bun.spawn(
-    [node, resolve(porffor, "runtime/index.js"), "native", generated, "-o", binary, "-s", "-O0"],
-    {
-      cwd: workdir,
-      env: process.env,
-      stdout: "pipe",
-      stderr: "pipe",
-    },
-  );
-  const [exitCode, stdout, stderr] = await Promise.all([
-    compile.exited,
-    new Response(compile.stdout).text(),
-    new Response(compile.stderr).text(),
-  ]);
-  assert.equal(exitCode, 0, `Porffor native compile failed:\n${stderr}\n${stdout}`);
+  await compileNative({ generated, binary, dir: workdir });
   const port = freePort();
   const server = Bun.spawn([binary], {
     cwd: workdir,

package/test/native-cpu-stamp.ts

@@ -1,8 +1,8 @@
 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 { join } from "node:path";
+import { compileNative } from "./native-compile";
 import { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
 
 // The x-sb-cpu-ms stamp is added to the handler's own Response (it used to build a second one),
@@ -52,29 +52,12 @@ async function start(binary: string, env: Record<string, string>): Promise<numbe
   throw new Error("compiled handler did not start");
 }
 try {
-  const porffor = await ensurePorffor();
-  const node = Bun.which("node");
-  if (!node) throw new Error("native cpu stamp test needs node on PATH");
   const [core, broker] = await Promise.all([readFile(preludePath, "utf8"), readFile(transportPath("broker"), "utf8")]);
   assert(core.includes(TRANSPORT_MARKER), "runtime prelude is missing its transport marker");
   const generated = join(workdir, "stamp.generated.js");
   const binary = join(workdir, "stamp-native");
   await writeFile(generated, wrapNativeFetchHandler(handler, core.replace(TRANSPORT_MARKER, broker)));
-  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}`);
+  await compileNative({ generated, binary, dir: workdir });
 
   const port = await start(binary, {});
   const get = (path: string, headers: Record<string, string> = {}, p = port) =>

package/test/native-crypto.ts

@@ -1,9 +1,8 @@
 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 { bearsslEnv } from "./bearssl";
+import { join } from "node:path";
+import { compileNative } from "./native-compile";
 import { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
 
 // These values come from Bun WebCrypto and node:crypto, not from the runtime
@@ -68,10 +67,6 @@ function freePort(): number {
 const workdir = await mkdtemp(join(tmpdir(), "sb-native-crypto-"));
 let server: ReturnType<typeof Bun.spawn> | undefined;
 try {
-  const porffor = await ensurePorffor({ cacheRoot: workdir });
-  const node = Bun.which("node");
-  if (!node) throw new Error("native crypto 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);
@@ -85,21 +80,7 @@ try {
   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, ...(await bearsslEnv()) },
-      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}`);
+  await compileNative({ generated, binary, dir: workdir, cacheRoot: workdir, bearssl: true });
 
   const port = freePort();
   server = Bun.spawn([binary], {

package/test/native-domexception.ts

@@ -1,8 +1,8 @@
 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 { join } from "node:path";
+import { compileNative } from "./native-compile";
 import { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
 
 // DOMException in a compiled handler, compared with Bun. Porffor ships a stub global that
@@ -47,10 +47,6 @@ function freePort(): number {
 const workdir = await mkdtemp(join(tmpdir(), "sb-native-domexception-"));
 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);
@@ -59,21 +55,7 @@ try {
   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}`);
+  await compileNative({ generated, binary, dir: workdir });
 
   const port = freePort();
   server = Bun.spawn([binary], {

package/test/native-errors.ts

@@ -1,8 +1,8 @@
 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 { join } from "node:path";
+import { compileNative } from "./native-compile";
 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
@@ -40,14 +40,7 @@ function freePort(): number {
 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"),
-  ]);
+  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");
@@ -55,18 +48,7 @@ try {
   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}`);
+  await compileNative({ generated, binary, dir: workdir });
 
   const port = freePort();
   server = Bun.spawn([binary], {
@@ -89,8 +71,14 @@ try {
   // 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")}`);
+  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) {

package/test/native-events.ts

@@ -1,8 +1,8 @@
 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 { join } from "node:path";
+import { compileNative } from "./native-compile";
 import { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
 
 // structuredClone, Event/EventTarget and AbortController in a compiled handler,
@@ -29,7 +29,15 @@ ${CASES.map((c) => `    () => (${c}),`).join("\n")}
   }
   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)); } }));
+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() {} } });
@@ -41,14 +49,7 @@ function freePort(): number {
 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"),
-  ]);
+  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");
@@ -56,18 +57,7 @@ try {
   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}`);
+  await compileNative({ generated, binary, dir: workdir });
 
   const port = freePort();
   server = Bun.spawn([binary], {
@@ -90,8 +80,14 @@ try {
   // 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")}`);
+  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) {