@sproutboat/runtime 0.42.1 → 0.43.0

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) {

package/test/native-fetch-request.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 { createBroker, listen } from "../../wire/src/broker";
 import { EMPTY_BINDINGS, preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
 
@@ -124,21 +124,18 @@ const brokerServer = listen(broker, "127.0.0.1", 0);
 const servers: ReturnType<typeof Bun.spawn>[] = [];
 
 // Compiles the handler at `date` and starts it; resolves to a GET helper for it.
-async function start(porffor: string, node: string, source: string, date: string) {
+async function start(source: string, date: string) {
   const port = freePort();
   const generated = join(workdir, `fetch-request-${date}.generated.js`);
   const binary = join(workdir, `fetch-request-${date}`);
   await writeFile(generated, wrapNativeFetchHandler(handler, source, {}, EMPTY_BINDINGS, undefined, date));
-  const compile = Bun.spawn(
-    [node, resolve(porffor, "runtime/index.js"), "native", generated, "-o", binary, "-s", "-O0"],
-    {
-      cwd: workdir,
-      stdout: "pipe",
-      stderr: "pipe",
-    },
-  );
-  const [exitCode, stderr] = await Promise.all([compile.exited, new Response(compile.stderr).text()]);
-  assert.equal(exitCode, 0, `Porffor native compile at ${date} failed:\n${stderr}`);
+  await compileNative({
+    generated,
+    binary,
+    dir: workdir,
+    cacheRoot: workdir,
+    failure: `Porffor native compile at ${date} failed`,
+  });
   const server = Bun.spawn([binary], {
     cwd: workdir,
     env: {
@@ -174,19 +171,13 @@ async function start(porffor: string, node: string, source: string, date: string
 }
 
 try {
-  const porffor = await ensurePorffor({ cacheRoot: workdir });
-  const node = Bun.which("node");
-  if (!node) throw new Error("native fetch-request test needs node on PATH");
   const [core, transport] = await Promise.all([
     readFile(preludePath, "utf8"),
     readFile(transportPath("broker"), "utf8"),
   ]);
   assert(core.includes(TRANSPORT_MARKER), "runtime prelude is missing its transport marker");
   const source = core.replace(TRANSPORT_MARKER, transport);
-  const [strict, legacy] = await Promise.all([
-    start(porffor, node, source, "2026-10-23"),
-    start(porffor, node, source, "2026-10-22"),
-  ]);
+  const [strict, legacy] = await Promise.all([start(source, "2026-10-23"), start(source, "2026-10-22")]);
 
   const echo = (method: string, from: string | null, type: string | null, body: string) => ({
     method,

package/test/native-getrandomvalues.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";
 
 // crypto.getRandomValues on wider integer views, in a compiled handler, compared with Bun. It filled only the
@@ -50,10 +50,6 @@ function freePort(): number {
 const workdir = await mkdtemp(join(tmpdir(), "sb-native-getrandomvalues-"));
 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);
@@ -62,21 +58,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-headers.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";
 
 // Headers validates a name and trims a value in C before it falls back to the regular expression and
@@ -54,10 +54,6 @@ function expectedValue(value: string): string {
 const workdir = await mkdtemp(join(tmpdir(), "sb-native-headers-"));
 let server: ReturnType<typeof Bun.spawn> | undefined;
 try {
-  const porffor = await ensurePorffor();
-  const node = Bun.which("node");
-  if (!node) throw new Error("native headers 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);
@@ -66,21 +62,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], {