@sproutboat/runtime 0.15.0 → 0.16.0

package/src/streams-entry.js

@@ -0,0 +1,5 @@
+// Generator input only. Native modules use the generated, import-free block.
+import * as streams from "web-streams-polyfill";
+for (const name of Object.keys(streams)) {
+  if (globalThis[name] == null) globalThis[name] = streams[name];
+}

package/test/native-base64.ts

@@ -0,0 +1,89 @@
+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";
+
+const expected = Array.from({length:10}, (_,length) => {
+  const bytes=Uint8Array.from({length}, (_,i) => (i*71+251)%256);
+  const padded=Buffer.from(bytes).toString("base64");
+  return {padded,url:padded.replaceAll("+","-").replaceAll("/","_").replace(/=+$/, ""),decoded:Array.from(bytes)};
+});
+const handler = `export default {fetch() {
+  const rows=[];
+  for(let length=0;length<10;length++) {
+    const bytes=new Uint8Array(length);for(let i=0;i<length;i++)bytes[i]=(i*71+251)%256;
+    const padded=bytes.toBase64();const url=bytes.toBase64({alphabet:"base64url",omitPadding:true});
+    const decoded=Array.from(Uint8Array.fromBase64(url,{alphabet:"base64url"}));
+    rows.push({padded,url,decoded});
+  }
+  return Response.json(rows);
+}};`;
+
+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-base64-"));
+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, "base64.generated.js");
+  const binary = join(workdir, "base64-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 response: Response | undefined;
+  for (let attempt = 0; attempt < 50; attempt++) {
+    try {
+      response = await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(500) });
+      break;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(response, "compiled streams handler did not start");
+  assert.equal(response.status, 200);
+  assert.deepEqual(await response.json(), expected);
+  console.log("Native base64 and base64url round-trip zero to nine bytes with correct padding");
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-model-resolver.ts

@@ -0,0 +1,100 @@
+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";
+
+const expected = {a: "user", b: "account", again: "user", plural: "user", custom: "user"};
+const handler = `
+const makeResolver = ({usePlural, schema}) => {
+  return (model) => {
+    const resolve = (candidate) => {
+      if (schema[candidate]) return candidate;
+      return Object.entries(schema).find((entry) => entry[1].modelName === candidate)?.[0];
+    };
+    if (usePlural && model.endsWith("s")) {
+      const m = resolve(model.slice(0, -1));
+      if (m) return m;
+    }
+    const m = resolve(model);
+    if (!m) throw new Error("Missing model");
+    return m;
+  };
+};
+export default {fetch() {
+  const schema = {user:{modelName:"user"},session:{modelName:"session"}};
+  const a = makeResolver({schema,usePlural:false});
+  const b = makeResolver({schema:{account:{modelName:"account"}},usePlural:false});
+  return Response.json({a:a("user"),b:b("account"),again:a("user"),
+    plural:makeResolver({schema,usePlural:true})("users"),
+    custom:makeResolver({schema:{user:{modelName:"members"}},usePlural:false})("members")});
+}};`;
+
+
+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-model-resolver-"));
+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, "model-resolver.generated.js");
+  const binary = join(workdir, "model-resolver-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 response: Response | undefined;
+  for (let attempt = 0; attempt < 50; attempt++) {
+    try {
+      response = await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(500) });
+      break;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(response, "compiled streams handler did not start");
+  assert.equal(response.status, 200);
+  assert.deepEqual(await response.json(), expected);
+  console.log("Native model resolvers preserve lexical function types, plural aliases and schema names");
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-streams.ts

@@ -0,0 +1,107 @@
+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";
+
+const expected = { chunks: ["a", "b"], transformed: ["X", "Y"], first: { value: "hello", done: false },
+  done: true, locked: false, lockError: true, cancelReason: "stop", error: "broken",
+  tee: [[1, 2], [1, 2]], pulled: [3, 4], pending: "later", bytes: [7, 8], byob: [9, 10] };
+const handler = `export default { async fetch(request) {
+  if (new URL(request.url).pathname === "/null") return new Response(null);
+  const stream = new ReadableStream({start(c){c.enqueue("hello");c.close();}});
+  const reader = stream.getReader(); let lockError = false;
+  try { stream.getReader(); } catch { lockError = true; }
+  const first = await reader.read(); const done = (await reader.read()).done;
+  reader.releaseLock();
+  const chunks = []; await ReadableStream.from(["a", "b"]).pipeTo(new WritableStream({write(x){chunks.push(x);}}));
+  const transformed = [];
+  await ReadableStream.from(["x", "y"]).pipeThrough(new TransformStream({transform(x,c){c.enqueue(x.toUpperCase());}}))
+    .pipeTo(new WritableStream({write(x){transformed.push(x);}}));
+  let cancelReason; await new ReadableStream({cancel(reason){cancelReason=reason;}}).cancel("stop");
+  let error; const broken = new ReadableStream({start(c){c.error(new Error("broken"));}}).getReader();
+  try { await broken.read(); } catch(e) { error=e.message; }
+  const branches=ReadableStream.from([1,2]).tee(); const tee=[[],[]];
+  await Promise.all(branches.map((branch,i)=>branch.pipeTo(new WritableStream({write(x){tee[i].push(x);}}))));
+  let value=3; const pulled=[];
+  await new ReadableStream({pull(c){if(value===5)c.close();else c.enqueue(value++);}})
+    .pipeTo(new WritableStream({write(x){pulled.push(x);}}));
+  let controller; const pendingReader=new ReadableStream({start(c){controller=c;}}).getReader();
+  const read=pendingReader.read(); controller.enqueue("later");controller.close();const pending=(await read).value;
+  const byteReader=new ReadableStream({type:"bytes",start(c){c.enqueue(new Uint8Array([7,8]));c.close();}}).getReader();
+  const bytes=Array.from((await byteReader.read()).value);
+  const byobReader=new ReadableStream({type:"bytes",start(c){c.enqueue(new Uint8Array([9,10]));c.close();}}).getReader({mode:"byob"});
+  const byob=Array.from((await byobReader.read(new Uint8Array(2))).value);
+  return Response.json({bytes,byob,chunks, transformed, first, done, locked:stream.locked,lockError,cancelReason,error,tee,pulled,pending});
+} };`;
+
+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-streams-"));
+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, "streams.generated.js");
+  const binary = join(workdir, "streams-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 response: Response | undefined;
+  for (let attempt = 0; attempt < 50; attempt++) {
+    try {
+      response = await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(500) });
+      break;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(response, "compiled streams handler did not start");
+  assert.equal(response.status, 200);
+  assert.deepEqual(await response.json(), expected);
+  const empty = await fetch(`http://127.0.0.1:${port}/null`);
+  assert.equal(empty.status, 200);
+  assert.equal(await empty.text(), "");
+  console.log("Native Web Streams pass reads, locks, cancellation, errors, piping, transforms, tee and pulls");
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-timers.ts

@@ -0,0 +1,89 @@
+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";
+
+const expected = { fired: 7, cancelled: false, ticks: 2 };
+const handler = `export default {async fetch() {
+  let cancelled = false;
+  const timer = globalThis.setTimeout(() => { cancelled = true; }, 1);
+  globalThis.clearTimeout(timer);
+  const fired = await new Promise(resolve => globalThis.setTimeout(resolve, 1, 7));
+  let ticks = 0;
+  await new Promise(resolve => {
+    const interval = globalThis.setInterval(() => {
+      ticks++;
+      if (ticks === 2) { globalThis.clearInterval(interval); resolve(); }
+    }, 1);
+  });
+  return Response.json({fired, cancelled, ticks});
+}};`;
+
+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-timers-"));
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  const porffor = await ensurePorffor();
+  const node = Bun.which("node");
+  if (!node) throw new Error("native timers 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, "timers.generated.js");
+  const binary = join(workdir, "timers-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 response: Response | undefined;
+  for (let attempt = 0; attempt < 50; attempt++) {
+    try {
+      response = await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(500) });
+      break;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(response, "compiled timers handler did not start");
+  assert.equal(response.status, 200);
+  assert.deepEqual(await response.json(), expected);
+  console.log("Native global timers preserve callbacks, arguments, cancellation and intervals");
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}