@sproutboat/runtime 0.15.0 → 0.17.0

package/test/native-url.ts

@@ -0,0 +1,145 @@
+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";
+
+// URL as WHATWG defines it (Bun's URL is the reference): base URLs, setters on every
+// part, hash, default ports, dot segments, percent-encoding, and searchParams writing
+// back into the URL. Each case is an expression over U, the URL class under test.
+const CASES = [
+  `new U("https://Example.COM:443/a/./b/../c?x=1#frag").href`,
+  `new U("http://example.com:80").href`,
+  `new U("http://example.com:8080/p").host`,
+  `new U("/path?q=1", "https://a.com/base/x").href`,
+  `new U("rel", "https://a.com/base/x").href`,
+  `new U("../up", "https://a.com/a/b/c").href`,
+  `new U("?q", "https://a.com/p?old#h").href`,
+  `new U("#h2", "https://a.com/p?old#h").href`,
+  `new U("//other.com/x", "https://a.com/").href`,
+  `new U("./", "https://a.com/a/b").href`,
+  `new U("..", "https://a.com/a/b/").href`,
+  `new U("x", new U("https://a.com/d/")).href`,
+  `(() => { const u = new U("https://foo.example.com/api.js"); u.hostname = "example.com"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/"); u.port = "8080"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com:8080/"); u.port = "443"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com:8080/"); u.port = ""; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x"); u.protocol = "http"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x"); u.protocol = "http:"; u.port = "80"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x"); u.host = "b.com:9"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x"); u.search = "a=1&b=2"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x?a=1"); u.search = ""; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x"); u.hash = "top"; return u.href + " " + u.hash; })()`,
+  `(() => { const u = new U("https://a.com/x#top"); u.hash = ""; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x"); u.pathname = "new path"; return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x?a=1"); u.searchParams.set("b", "two words"); return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x?a=1&a=2"); u.searchParams.delete("a"); return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x?b=2&a=1"); u.searchParams.sort(); return u.href; })()`,
+  `(() => { const u = new U("https://a.com/x?a=1"); const p = u.searchParams; u.search = "?z=9"; return p.get("z") + " " + p.get("a"); })()`,
+  `(() => { const u = new U("https://a.com/x"); u.searchParams.append("q", "a+b&c=d!'()~*"); return u.search; })()`,
+  `new U("https://a.com/x?a=1").searchParams.get("a")`,
+  `new U("http://u:p@h.com/").username + " " + new U("http://u:p@h.com/").password`,
+  `new U("http://u:p@h.com/").href`,
+  `new U("https://a.com/p").origin`,
+  `new U("http://[::1]:8080/").hostname + " " + new U("http://[::1]:8080/").port`,
+  `new U("http://[::1]:8080/").host`,
+  `U.canParse("nope") + " " + U.canParse("https://a.com") + " " + U.canParse("/x", "https://a.com")`,
+  `(() => { try { new U("nope"); return "no throw"; } catch (e) { return e instanceof TypeError; } })()`,
+  `(() => { try { new U("https://"); return "no throw"; } catch (e) { return e instanceof TypeError; } })()`,
+  `JSON.stringify({ u: new U("https://a.com") })`,
+  `new U("https://a.com").pathname`,
+  `new U("mailto:x@y.com").pathname + " " + new U("mailto:x@y.com").protocol + " " + new U("mailto:x@y.com").origin`,
+  `String(new U("https://a.com/a b"))`,
+  `new U("https://a.com/é?q=ü#ä").href`,
+  `new U("https://a.com/x?q=it's").search`,
+  `new U("HTTPS://A.COM/X").href`,
+  `new U("https://a.com?").href`,
+  `new U("https://a.com#").href`,
+  `new U("https://a.com/%2e/x").pathname`,
+  `(() => { const u = new U("https://a.com/x"); u.href = "http://b.com/y?z"; return u.host + " " + u.pathname + " " + u.search; })()`,
+  `new U("https://a.com/x?a=1#f").toString()`,
+];
+
+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-url-"));
+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, "url.generated.js");
+  const binary = join(workdir, "url-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, [], `URL differs from WHATWG in ${diffs.length} of ${CASES.length} cases:\n${diffs.join("\n")}`);
+  console.log(`Native URL matches WHATWG URL in all ${CASES.length} cases: base URLs, setters, hash, ports, dot segments, encoding, searchParams`);
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-waituntil.ts

@@ -0,0 +1,92 @@
+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";
+
+// ctx.waitUntil work runs after the response, as in workerd: the response does not wait
+// for it, the work still finishes, and its 25 s cap leaves no timer behind once it is done.
+const handler = `export default {async fetch(request, env, ctx) {
+  const path = new URL(request.url).pathname;
+  if (path === "/later") {
+    globalThis.__done = "pending";
+    ctx.waitUntil(new Promise((resolve) => setTimeout(() => { globalThis.__done = "done"; resolve(); }, 400)));
+    return new Response("scheduled");
+  }
+  if (path === "/state") return new Response(String(globalThis.__done));
+  return new Response("ok");
+}};`;
+
+function freePort(): number {
+  const listener = Bun.listen({ hostname: "127.0.0.1", port: 0, socket: { data() {} } });
+  const port = listener.port;
+  listener.stop(true);
+  return port;
+}
+
+const workdir = await mkdtemp(join(tmpdir(), "sb-native-waituntil-"));
+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, "waituntil.generated.js");
+  const binary = join(workdir, "waituntil-native");
+  await writeFile(generated, wrapNativeFetchHandler(handler, prelude, undefined, undefined, undefined, "2026-10-01"));
+  await rm(binary, { force: true });
+
+  const compile = Bun.spawn([node, resolve(porffor, "runtime/index.js"), "native", generated, "-o", binary, "-s", "-O0"], {
+    cwd: workdir,
+    env: process.env,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    compile.exited,
+    new Response(compile.stdout).text(),
+    new Response(compile.stderr).text(),
+  ]);
+  assert.equal(exitCode, 0, `Porffor native compile failed:\n${stderr}\n${stdout}`);
+
+  const port = freePort();
+  server = Bun.spawn([binary], {
+    cwd: workdir,
+    env: { ...process.env, PORT: String(port) },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  let ready = false;
+  for (let attempt = 0; attempt < 50 && !ready; attempt++) {
+    try {
+      await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(500) });
+      ready = true;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(ready, "compiled handler did not start");
+  const t0 = performance.now();
+  const first = await (await fetch(`http://127.0.0.1:${port}/later`)).text();
+  const elapsed = performance.now() - t0;
+  assert.equal(first, "scheduled");
+  assert(elapsed < 300, `the response waited ${Math.round(elapsed)} ms for its waitUntil work`);
+  assert.equal(await (await fetch(`http://127.0.0.1:${port}/state`)).text(), "pending");
+  await Bun.sleep(700);
+  assert.equal(await (await fetch(`http://127.0.0.1:${port}/state`)).text(), "done");
+  console.log(`Native waitUntil runs after the response (${Math.round(elapsed)} ms) and completes`);
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-web-apis.ts

@@ -0,0 +1,110 @@
+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";
+
+// Web API behaviour the W2 conformance suite found wrong, compared with Bun: Headers
+// (combined get, sorted iteration, getSetCookie, trimming, validation), TextDecoder (astral,
+// replacement, fatal, BOM, stream), URLSearchParams init forms, atob/btoa checks, Unicode
+// case mapping, queueMicrotask and IDN hosts.
+const CASES = [
+  `(() => { const h = new Headers(); h.append("B", " 2 "); h.append("a", "1"); h.append("a", "x"); return [h.get("a"), [...h].map((p) => p.join("=")).join(";")].join("|"); })()`,
+  `(() => { const h = new Headers(); h.append("set-cookie", "a=1"); h.append("set-cookie", "b=2"); return [h.getSetCookie().join("+"), [...h].length].join("|"); })()`,
+  `(() => { try { new Headers({ "bad name": "1" }); return "no throw"; } catch (e) { return e.name; } })()`,
+  `(() => { try { new Headers({ a: "x\\ny" }); return "no throw"; } catch (e) { return e.name; } })()`,
+  `new TextDecoder().decode(new Uint8Array([0x61, 0xf0, 0x9f, 0x98, 0x80, 0xff, 0x62]))`,
+  `(() => { try { new TextDecoder("utf-8", { fatal: true }).decode(new Uint8Array([0xc3])); return "no throw"; } catch (e) { return e.name; } })()`,
+  `(() => { const d = new TextDecoder(); return d.decode(new Uint8Array([0xef, 0xbb, 0xbf, 0xe2, 0x82]), { stream: true }) + d.decode(new Uint8Array([0xac])); })()`,
+  `[new URLSearchParams({ a: "1", b: "x y" }).toString(), new URLSearchParams([["c", "3"]]).toString(), new URLSearchParams(new URLSearchParams("d=4")).toString()].join("|")`,
+  `(() => { try { atob("@@"); return "no throw"; } catch (e) { return e.name + ":" + atob(" aGVs bG8= "); } })()`,
+  `(() => { try { btoa("€"); return "no throw"; } catch (e) { return e.name; } })()`,
+  `["ÄÖÜ", "ΑΒΓ", "дж", "Ā", "Ωmega"].map((s) => s.toLowerCase() + s.toUpperCase()).join(",")`,
+  `new Promise((resolve) => { const o = []; setTimeout(() => o.push("t"), 0); queueMicrotask(() => o.push("m")); setTimeout(() => resolve(o.join()), 50); })`,
+  `new URL("http://münchen.test/x").host`,
+  `crypto.subtle.digest("SHA-1", new TextEncoder().encode("abc")).then((b) => Array.from(new Uint8Array(b), (x) => x.toString(16).padStart(2, "0")).join(""))`,
+  `crypto.subtle.importKey("raw", new TextEncoder().encode("key"), { name: "HMAC", hash: "SHA-1" }, true, ["sign"]).then(async (k) => [k.algorithm.hash.name, k.algorithm.length, Array.from(new Uint8Array(await crypto.subtle.sign("HMAC", k, new TextEncoder().encode("msg"))), (x) => x.toString(16).padStart(2, "0")).join(""), new Uint8Array(await crypto.subtle.exportKey("raw", k)).length].join())`,
+  `crypto.subtle.generateKey({ name: "HMAC", hash: "SHA-512" }, true, ["sign"]).then(async (k) => [k.type, k.algorithm.length, (await crypto.subtle.exportKey("raw", k)).byteLength].join())`,  `(async () => { const collect = async (rs) => { const r = rs.getReader(); const out = []; for (;;) { const { value, done } = await r.read(); if (done) return out; out.push(value); } }; const bytes = new ReadableStream({ start(c) { c.enqueue(new Uint8Array([0x61, 0xe2])); c.enqueue(new Uint8Array([0x82, 0xac, 0xf0, 0x9f])); c.enqueue(new Uint8Array([0x98, 0x80])); c.close(); } }); const text = new ReadableStream({ start(c) { c.enqueue("a\\uD83D"); c.enqueue("\\uDE00b"); c.close(); } }); return (await collect(bytes.pipeThrough(new TextDecoderStream()))).join("|") + ";" + (await collect(text.pipeThrough(new TextEncoderStream()))).map((u) => Array.from(u).join(",")).join("|"); })()`,
+];
+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-web-apis-"));
+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, "web-apis.generated.js");
+  const binary = join(workdir, "web-apis-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, [], `Web API results differ from Bun in ${diffs.length} of ${CASES.length} cases:\n${diffs.join("\n")}`);
+  console.log(`Native Web APIs match Bun in all ${CASES.length} cases`);
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}