@sproutboat/runtime 0.44.0 → 0.46.0

package/test/fixtures/asset-redirect-cases.ts

@@ -0,0 +1,28 @@
+/** What a `_redirects` matcher must answer, from Cloudflare's rules engine: [file text, request path, [status, location] or null]. */
+export type RedirectCase = [text: string, path: string, want: [status: number, location: string] | null];
+
+export const REDIRECT_CASES: RedirectCase[] = [
+  ["/compare /compare/ 308", "/compare", [308, "/compare/"]],
+  ["/compare /compare/ 308", "/compare/", null],
+  ["/compare/ /compare 308", "/compare/", [308, "/compare"]],
+  ["/compare/ /compare 308", "/compare", null],
+  ["/user/:id /profile/:id", "/user/42", [302, "/profile/42"]],
+  ["/user/:id /profile/:id", "/user/42/", null],
+  ["/user/:id /profile/:id", "/user/", null],
+  ["/user/:id /profile/:id", "/user", null],
+  ["/blog/* /posts/:splat 301", "/blog/", [301, "/posts/"]],
+  ["/blog/* /posts/:splat 301", "/blog", null],
+  ["/blog/* /posts/:splat 301", "/blog/a/b/", [301, "/posts/a/b/"]],
+  ["/a/*/c /x/:splat", "/a/b/b2/c", [302, "/x/b/b2"]],
+  ["/a/*/c /x/:splat", "/a/c", null],
+  ["/:lang/docs /docs/:lang 301", "/fr/docs", [301, "/docs/fr"]],
+  ["/:lang/docs /docs/:lang 301", "/fr/docs/", null],
+  ["/files/:name.html /pages/:name", "/files/about.html", [302, "/pages/about"]],
+  ["/:a-:b /x/:b/:a", "/one-two", [302, "/x/two/one"]],
+  ["/:a/:a /x", "/p/p", null],
+  ["/*/*/ /x", "/a/b/", null],
+  ["/a:1 /b", "/a:1", [302, "/b"]],
+  ["/blog/* /dynamic/:splat\n/blog/old /static\n/blog/old /static-2", "/blog/old", [302, "/static"]],
+  ["/blog/* /dynamic/:splat\n/blog/old /static", "/blog/new", [302, "/dynamic/new"]],
+  ["/x/:a /first\n/x/:b /second", "/x/1", [302, "/first"]],
+];

package/test/fixtures/do-evict-app.js

@@ -0,0 +1,172 @@
+// Durable Object eviction fixture (plan 018): objects that count what survives an eviction. Every handler is a path:
+//   /via/ID/OP?...   a stub.fetch to object ID of class Obj (or Slow, Flaky) running OP; errors come back as JSON with `overloaded`
+//   /release/N       resolves the zombie promise N
+//   /zombie-result/N what the zombie got when it tried to write after its object was evicted
+const json = (v, status = 200) =>
+  new Response(JSON.stringify(v), { status, headers: { "content-type": "application/json" } });
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+globalThis.__release = {};
+globalThis.__zombie = {};
+
+export class Obj {
+  constructor(state, env) {
+    this.state = state;
+    this.mem = 0;
+    this.ctor = 0;
+    // The constructor count lives in storage: it goes up once per wake, not per request.
+    state.blockConcurrencyWhile(async () => {
+      this.ctor = ((await state.storage.get("ctor")) || 0) + 1;
+      await state.storage.put("ctor", this.ctor);
+    });
+  }
+  async fetch(request) {
+    const url = new URL(request.url);
+    const q = (k, d) => (url.searchParams.has(k) ? url.searchParams.get(k) : d);
+    const storage = this.state.storage;
+    switch (url.pathname.slice(1)) {
+      case "mem":
+        this.mem++;
+        return json({ mem: this.mem, ctor: this.ctor });
+      case "put":
+        await storage.put(q("k", "k"), q("v", "v"));
+        this.state.storage.sql.exec("CREATE TABLE IF NOT EXISTS t (v TEXT)");
+        this.state.storage.sql.exec("INSERT INTO t VALUES (?)", q("v", "v"));
+        return json({ ok: true });
+      case "get": {
+        let rows = [];
+        try {
+          rows = this.state.storage.sql
+            .exec("SELECT v FROM t")
+            .toArray()
+            .map((r) => r.v);
+        } catch {}
+        return json({ k: (await storage.get(q("k", "k"))) ?? null, rows, ctor: this.ctor, mem: this.mem });
+      }
+      case "alarm":
+        await storage.setAlarm(Date.now() + Number(q("ms", "1000")));
+        return json({ ok: true, ctor: this.ctor });
+      case "failalarm":
+        await storage.put("failAlarm", Number(q("n", "2")));
+        await storage.setAlarm(Date.now() + Number(q("ms", "300")));
+        return json({ ok: true });
+      case "alarmlog":
+        return json({
+          log: (await storage.get("alarmLog")) || [],
+          runs: (await storage.get("alarmRuns")) || 0,
+          ctor: this.ctor,
+        });
+      case "hold":
+        await sleep(Number(q("ms", "1000")));
+        return json({ mem: this.mem, ctor: this.ctor });
+      case "waituntil":
+        this.state.waitUntil(sleep(Number(q("ms", "800"))).then(() => storage.put("wu", "done")));
+        return json({ ok: true });
+      case "timer": {
+        const ms = Number(q("ms", "1200"));
+        setTimeout(() => {
+          this.fired = true;
+        }, ms);
+        return json({ ok: true });
+      }
+      case "interval":
+        this.tick = 0;
+        setInterval(() => {
+          this.tick++;
+        }, 100);
+        return json({ ok: true });
+      case "txn":
+        await storage.transaction(async (txn) => {
+          await txn.put("t", 1);
+          await sleep(Number(q("ms", "1200")));
+        });
+        return json({ ok: true });
+      case "abort":
+        this.state.abort("test abort");
+        return json({ unreachable: true });
+      case "zombie": {
+        const n = q("n", "1");
+        const state = this.state;
+        // A promise chain the handler forgets: it wakes after the object was evicted and writes as if it were still alive.
+        new Promise((resolve) => {
+          globalThis.__release[n] = resolve;
+        }).then(async () => {
+          try {
+            await state.storage.put("z", "written by a zombie");
+            globalThis.__zombie[n] = "wrote";
+          } catch (e) {
+            globalThis.__zombie[n] = "rejected: " + e.message;
+          }
+        });
+        return json({ ok: true });
+      }
+      default:
+        return json({ error: "no such op" }, 404);
+    }
+  }
+  async alarm(info) {
+    const storage = this.state.storage;
+    const left = (await storage.get("failAlarm")) || 0;
+    const runs = ((await storage.get("alarmRuns")) || 0) + 1;
+    await storage.put("alarmRuns", runs);
+    const log = (await storage.get("alarmLog")) || [];
+    log.push({ retryCount: info.retryCount, isRetry: info.isRetry, ctor: this.ctor, mem: this.mem });
+    await storage.put("alarmLog", log);
+    if (left > 0) {
+      await storage.put("failAlarm", left - 1);
+      throw new Error("alarm failed on purpose");
+    }
+  }
+}
+
+// A constructor that holds the gate for a while: events queue behind it.
+export class Slow {
+  constructor(state) {
+    this.state = state;
+    state.blockConcurrencyWhile(async () => {
+      await sleep(600);
+      this.ready = true;
+    });
+  }
+  async fetch() {
+    return json({ ready: this.ready === true });
+  }
+}
+
+// A constructor whose blockConcurrencyWhile rejects the first time: the object is reset and built again.
+export class Flaky {
+  constructor(state) {
+    this.state = state;
+    state.blockConcurrencyWhile(async () => {
+      const n = ((await state.storage.get("flaky")) || 0) + 1;
+      await state.storage.put("flaky", n);
+      if (n === 1) throw new Error("first construction fails");
+      this.ok = n;
+    });
+  }
+  async fetch() {
+    return json({ ok: this.ok });
+  }
+}
+
+export default {
+  async fetch(request, env) {
+    const url = new URL(request.url);
+    const parts = url.pathname.split("/");
+    if (parts[1] === "release") {
+      globalThis.__release[parts[2]]();
+      await sleep(50);
+      return json({ ok: true });
+    }
+    if (parts[1] === "zombie-result") return json({ result: globalThis.__zombie[parts[2]] ?? null });
+    if (parts[1] !== "via") return new Response("ok");
+    const cls = url.searchParams.get("cls") || "Obj";
+    const ns = cls === "Slow" ? env.SLOW : cls === "Flaky" ? env.FLAKY : env.OBJ;
+    try {
+      const stub = ns.get(ns.idFromName(parts[2]));
+      const res = await stub.fetch(new Request("https://do/" + parts[3] + url.search));
+      return new Response(await res.text(), { status: res.status, headers: { "content-type": "application/json" } });
+    } catch (e) {
+      return json({ error: String(e.message), overloaded: e.overloaded === true }, 503);
+    }
+  },
+};

package/test/native-asset-redirects.ts

@@ -0,0 +1,80 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { parseRedirects, type RedirectRule } from "../../assets/src/assets";
+import { compileNative } from "./native-compile";
+import { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
+import { REDIRECT_CASES } from "./fixtures/asset-redirect-cases";
+
+// The `_redirects` matcher the compiled prelude runs (`__sbFindAssetRedirect`, used by env.ASSETS.fetch and the
+// embedded transport's assets.get) against the cases the portable matcher in @sproutboat/assets is held to
+// (packages/runtime/src/asset-rules.test.js reads the same file): Cloudflare's rules, so a trailing slash is
+// significant and `/compare /compare/ 308` is one hop. The handler reaches the prelude's function from inside the
+// module, so what runs is the Porffor-compiled code, not Bun's reading of it.
+const handler = `export default {
+  async fetch(request) {
+    const { rules, path } = await request.json();
+    return Response.json(__sbFindAssetRedirect(rules, path));
+  },
+};`;
+
+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-asset-redirects-"));
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  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, "redirects.generated.js");
+  const binary = join(workdir, "redirects-native");
+  await writeFile(generated, wrapNativeFetchHandler(handler, core.replace(TRANSPORT_MARKER, broker)));
+  await rm(binary, { force: true });
+  await compileNative({ generated, binary, dir: workdir, cacheRoot: workdir });
+
+  const port = freePort();
+  server = Bun.spawn([binary], {
+    cwd: workdir,
+    env: { ...process.env, PORT: String(port) },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  const ask = async (rules: RedirectRule[], path: string) => {
+    const response = await fetch(`http://127.0.0.1:${port}/`, {
+      method: "POST",
+      body: JSON.stringify({ rules, path }),
+      signal: AbortSignal.timeout(20_000),
+    });
+    return { status: response.status, body: await response.json() };
+  };
+  let ready = false;
+  for (let attempt = 0; attempt < 50 && !ready; attempt++) {
+    try {
+      await ask([], "/");
+      ready = true;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(ready, "compiled handler did not start");
+  for (const [text, path, want] of REDIRECT_CASES) {
+    const answer = await ask(parseRedirects(text), path);
+    const label = `${JSON.stringify(text)} ${path}`;
+    assert.equal(answer.status, 200, `${label}: status`);
+    const got = answer.body === null ? null : [answer.body.status, answer.body.location];
+    assert.deepEqual(got, want, label);
+  }
+  console.log(`Native _redirects matching agrees with Cloudflare on ${REDIRECT_CASES.length} cases`);
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-cc.ts

@@ -0,0 +1,178 @@
+import assert from "node:assert/strict";
+import { existsSync } from "node:fs";
+import { mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { prepareMainUnit } from "../../toolchain/src/a21/standalone";
+import bridgeSource from "../../toolchain/src/a21/native-fetch-a22.c" with { type: "text" };
+import { renderStandaloneUnits } from "./native-compile";
+import { standaloneChannel } from "../../toolchain/src/a21/standalone-channel";
+import { preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
+
+// The calling convention of every call between host C (the bridge) and generated code, on Porffor alpha 23.
+// Alpha 23 prefixes each generated JS function with PORF_CC, which is `__attribute__((swiftcall))` on clang
+// arm64 and nothing elsewhere. A host C file that declares or calls one of those functions without PORF_CC
+// compiles and links, and works until link-time optimisation sees the two sides disagree and turns the call
+// into `unreachable`: the macOS arm64 binary trapped at startup (SIGTRAP in main) calling p__main__23main.
+// The reverse direction matters as much: functions the host defines for generated code to call (the
+// timer and response entry points) are plain C, and must stay so.
+//
+// Every unit of a rendered standalone build, and the bridge, is compiled to LLVM IR for each arm64 and x86-64
+// target a clang-based compiler here can reach, and every function the IR defines, declares or calls must carry
+// swiftcc exactly when its source declaration has PORF_CC (and the target is arm64). Needs clang or zig;
+// without one, the test is skipped, and on CI (CI is set) that is an error.
+const handler = `export default { fetch() { return new Response("hello"); } };`;
+
+type Target = { name: string; triple: string; arm64: boolean };
+const TARGETS: Target[] = [
+  { name: "darwin-arm64", triple: "arm64-apple-macos", arm64: true },
+  { name: "linux-arm64", triple: "aarch64-linux-gnu", arm64: true },
+  { name: "linux-arm64-musl", triple: "aarch64-linux-musl", arm64: true },
+  { name: "linux-x64", triple: "x86_64-linux-gnu", arm64: false },
+  { name: "linux-x64-musl", triple: "x86_64-linux-musl", arm64: false },
+  { name: "darwin-x64", triple: "x86_64-apple-macos", arm64: false },
+];
+
+// Compilers to try per target, as argv prefixes: zig cc ships every libc's headers, clang only the host's
+// (plus Debian's cross headers when libc6-dev-arm64-cross is installed).
+const COMPILERS: string[][] = [
+  ["zig", "cc"],
+  ["clang"],
+  ["clang", "-isystem", "/usr/aarch64-linux-gnu/include"],
+  ["cc"],
+];
+
+const PROBE = `#include <stdint.h>\n#include <stdlib.h>\n#include <stdio.h>\n#include <string.h>\n#include <time.h>\n#include <signal.h>\n#include <unistd.h>\nint main(void) { return 0; }\n`;
+
+async function spawn(argv: string[], cwd?: string) {
+  const child = Bun.spawn(argv, { cwd, stdout: "pipe", stderr: "pipe" });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    child.exited,
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+  ]);
+  return { exitCode, stdout, stderr };
+}
+
+/** A clang-based compiler for `triple` that can include the libc headers the units need, or null. */
+/** The LLVM IR of `source` for `triple`, or the compiler's error. zig cc cannot write IR to stdout, so it goes through a file. */
+async function emitIr(cc: string[], triple: string, source: string, args: string[] = []) {
+  const out = join(workdir, `ir-${++irCounter}.ll`);
+  const run = await spawn([...cc, "-target", triple, "-S", "-emit-llvm", "-w", ...args, "-o", out, source]);
+  const ir = run.exitCode === 0 && existsSync(out) ? await readFile(out, "utf8") : "";
+  await rm(out, { force: true });
+  return { ok: run.exitCode === 0 && ir.includes("target triple"), ir, error: run.stderr };
+}
+
+/** A clang-based compiler for `triple` that can include the libc headers the units need, or null. */
+async function compilerFor(triple: string, probe: string): Promise<string[] | null> {
+  for (const cc of COMPILERS) {
+    if (!Bun.which(cc[0])) continue;
+    try {
+      // gcc named `cc` rejects -target, and only clang's IR has a `target triple` line
+      if ((await emitIr(cc, triple, probe)).ok) return cc;
+    } catch {
+      // not runnable
+    }
+  }
+  return null;
+}
+
+/** The names the sources declare or define with PORF_CC. */
+function swiftNames(texts: string[]): Set<string> {
+  const names = new Set<string>();
+  for (const text of texts)
+    for (const m of text.matchAll(/^[ \t]*(?:extern[ \t]+|static[ \t]+)?PORF_CC[ \t]+[^;{(\n]*?(\w+)[ \t]*\(/gm))
+      names.add(m[1]);
+  return names;
+}
+
+/** Every function an IR file defines, declares or calls by name, with whether that site says swiftcc. */
+function irReferences(ir: string): { name: string; swift: boolean; kind: string }[] {
+  const out: { name: string; swift: boolean; kind: string }[] = [];
+  for (const m of ir.matchAll(/^(define|declare)\b([^@\n]*)@([\w.$]+)\(/gm))
+    out.push({ kind: m[1], swift: /\bswiftcc\b/.test(m[2]), name: m[3] });
+  for (const m of ir.matchAll(/\bcall\b([^@(\n]*)@([\w.$]+)\(/g))
+    out.push({ kind: "call", swift: /\bswiftcc\b/.test(m[1]), name: m[2] });
+  return out;
+}
+
+if (standaloneChannel() !== "alpha-23") {
+  // alpha 22's porf.h has no PORF_CC and alpha 19 has no bridge: nothing to compare
+  console.log(`SKIPPED: the calling-convention check is for the alpha-23 channel, not ${standaloneChannel()}`);
+  process.exit(0);
+}
+
+const workdir = await mkdtemp(join(tmpdir(), "sb-native-cc-"));
+let irCounter = 0;
+try {
+  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, "cc.generated.js");
+  await writeFile(generated, wrapNativeFetchHandler(handler, core.replace(TRANSPORT_MARKER, broker)));
+  const units = await renderStandaloneUnits({ generated, binary: join(workdir, "cc-native"), dir: workdir });
+  prepareMainUnit(join(units, "porf__main.c"));
+  const bridge = join(units, "porf_native_fetch_a22.c");
+  await writeFile(bridge, bridgeSource);
+  const sources = (await readdir(units)).filter((f) => f.endsWith(".c")).sort();
+  assert(sources.includes("porf_native_fetch_a22.c") && sources.includes("porf__main.c"), "units are missing");
+  const texts = await Promise.all([
+    ...sources.map((f) => readFile(join(units, f), "utf8")),
+    readFile(join(units, "porf.h"), "utf8"),
+  ]);
+  const swift = swiftNames(texts);
+  const probe = join(workdir, "probe.c");
+  await writeFile(probe, PROBE);
+
+  assert(
+    swift.has("p__main__23main"),
+    "porf.h no longer declares p__main__23main with PORF_CC: has the compiler dropped swiftcall (alpha 24)?",
+  );
+  const hasMacro = texts[texts.length - 1].includes("#define PORF_CC __attribute__((swiftcall))");
+  assert(hasMacro, "porf.h has no PORF_CC swiftcall definition: this test is written for Porffor alpha 23 or later");
+
+  const checked: string[] = [];
+  for (const target of TARGETS) {
+    const cc = await compilerFor(target.triple, probe);
+    if (!cc) continue;
+    let swiftRefs = 0;
+    let bridgeCallsMain = false;
+    for (const file of sources) {
+      const compile = await emitIr(cc, target.triple, join(units, file), ["-O0", "-I", units]);
+      assert(compile.ok, `${target.name}: ${file} did not compile:\n${compile.error.slice(-2000)}`);
+      for (const ref of irReferences(compile.ir)) {
+        const want = target.arm64 && swift.has(ref.name);
+        assert.equal(
+          ref.swift,
+          want,
+          `${target.name}: ${file} ${ref.kind}s ${ref.name} ${ref.swift ? "with" : "without"} swiftcc, but the source ` +
+            `${swift.has(ref.name) ? "declares it with PORF_CC" : "declares it without PORF_CC"}` +
+            (target.arm64 ? "" : " (and this target has no swiftcall)"),
+        );
+        if (ref.swift) swiftRefs++;
+        if (file === "porf_native_fetch_a22.c" && ref.kind === "call" && ref.name === "p__main__23main")
+          bridgeCallsMain = true;
+      }
+    }
+    assert(bridgeCallsMain, `${target.name}: the bridge no longer calls p__main__23main (or the IR scan missed it)`);
+    if (target.arm64) assert(swiftRefs > 0, `${target.name}: no swiftcc anywhere: the scan is vacuous`);
+    else assert.equal(swiftRefs, 0, `${target.name}: swiftcc on a target without it`);
+    checked.push(target.name);
+  }
+
+  // Strict only where the job provisions an arm64 compiler (SB_NATIVE_CC_STRICT=1 in ci.yml's native job).
+  // The release workflow runs test:native on a stock runner without one; failing there blocked 0.26.1.
+  const strict = process.env.SB_NATIVE_CC_STRICT === "1";
+  const arm64Hosted = process.platform === "darwin" ? "darwin-arm64" : "linux-arm64";
+  if (checked.length === 0 || !checked.includes(arm64Hosted)) {
+    const message = `no compiler for ${arm64Hosted} (needs clang with its headers, or zig): checked ${checked.join(", ") || "nothing"}`;
+    assert(!strict, message);
+    console.log(
+      `SKIPPED: ${message}${process.env.CI ? " (set SB_NATIVE_CC_STRICT=1 in a job that installs one)" : ""}`,
+    );
+  } else {
+    console.log(`Host C and generated code agree on the calling convention for ${checked.join(", ")}`);
+  }
+} finally {
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-compile.ts

@@ -10,7 +10,7 @@ import {
   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 { standaloneA21Channel, standaloneChannel } from "../../toolchain/src/a21/standalone-channel";
 import { bearsslEnv } from "./bearssl";
 
 export type NativeCompileInput = {
@@ -30,6 +30,11 @@ export type NativeCompileInput = {
   bearssl?: boolean;
   /** `-O` level. Default 0. */
   optimize?: number;
+  /** Link-time optimisation, as the CLI's host and release builds have it (`-flto`). Default off. */
+  flto?: boolean;
+  /** Compilers as argv prefixes (default `cc` and `c++`). */
+  cc?: string[];
+  cxx?: string[];
   /** 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". */
@@ -112,8 +117,50 @@ export async function compileNative(input: NativeCompileInput): Promise<void> {
     return;
   }
 
+  const a21Channel = standaloneA21Channel(standaloneChannel());
+  const unitsDir = await renderStandaloneUnits({
+    generated: input.generated,
+    binary: input.binary,
+    dir,
+    cacheRoot: input.cacheRoot,
+    env: input.env,
+    failure,
+  });
+  await rm(input.binary, { force: true });
+  await buildStandaloneA21({
+    unitsDir,
+    alpha19Root: alpha19,
+    outPath: input.binary,
+    cc: input.cc ?? ["cc"],
+    cxx: input.cxx ?? ["c++"],
+    uwsDir: await uwsDirectory(alpha19),
+    extraLink,
+    extraCflags,
+    optimize,
+    flto: input.flto ?? false,
+    musl: false,
+    strip: true,
+  }).catch((error: Error) => {
+    throw new Error(`${failure} (${a21Channel} build):\n${error.message}`);
+  });
+}
+
+export type RenderUnitsInput = Pick<
+  NativeCompileInput,
+  "generated" | "binary" | "dir" | "cacheRoot" | "env" | "failure"
+>;
+
+/**
+ * The compiler's half of a standalone build on the alpha 21 line: compose the sources, render the C units
+ * with the pinned alpha 22 or 23 compiler, and return the units directory (porf.h, porf__main.c, the units).
+ */
+export async function renderStandaloneUnits(input: RenderUnitsInput): Promise<string> {
+  const dir = input.dir ?? dirname(input.binary);
+  const failure = input.failure ?? "Porffor native compile failed";
+  const alpha19 = await ensurePorffor(input.cacheRoot === undefined ? {} : { cacheRoot: input.cacheRoot });
   const bun = process.execPath;
-  const alpha22 = await ensurePorfforA21("alpha-22");
+  const a21Channel = standaloneA21Channel(standaloneChannel());
+  const a21 = await ensurePorfforA21(a21Channel);
   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 });
@@ -134,30 +181,14 @@ export async function compileNative(input: NativeCompileInput): Promise<void> {
     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],
+      [bun, resolve(a21, "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}`);
-  });
+  if (rendered.exitCode !== 0)
+    throw new Error(`${failure} (${a21Channel} render):\n${rendered.stderr}\n${rendered.stdout}`);
+  return join(work, "units");
 }