@sproutboat/runtime 0.14.0 → 0.15.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @sproutboat/runtime
 
+## 0.15.0
+
+### Minor Changes
+
+- Pin and vendor Porffor alpha-16 (43087d4). Enable Proxy and revocable Proxy in handler validation, add native regression coverage for traps and iterators, and drop three typed-array patches now implemented upstream. URLSearchParams and FormData now provide live, self-iterable keys, values and entries iterators. See PORFFOR_ALPHA16.md for the complete change audit and remaining package compatibility limits.
+
 ## 0.14.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "license": "MIT",
   "type": "module",
   "repository": {

package/src/native-fetch-prelude.js

@@ -93,6 +93,22 @@ function __sbTagCpu(res, t0) {
   return res;
 }
 
+// Live iterators use the current collection on each next(), including mutations.
+function __sbCollectionIterator(owner, kind, formData) {
+  let index = 0;
+  return {
+    next() {
+      const length = formData ? owner._entries.length : owner._keys.length;
+      if (index >= length) return { value: undefined, done: true };
+      const key = formData ? owner._entries[index][0] : owner._keys[index];
+      const value = formData ? owner._entries[index][1] : owner._vals[index];
+      index++;
+      return { value: kind === 0 ? key : kind === 1 ? value : [key, value], done: false };
+    },
+    [Symbol.iterator]() { return this; },
+  };
+}
+
 class __SproutboatURLSearchParams {
   constructor(init) {
     this._keys = [];
@@ -165,11 +181,15 @@ class __SproutboatURLSearchParams {
     this._vals = idx.map((i) => this._vals[i]);
   }
   keys() {
-    return this._keys.slice();
+    return __sbCollectionIterator(this, 0, false);
   }
   values() {
-    return this._vals.slice();
+    return __sbCollectionIterator(this, 1, false);
+  }
+  entries() {
+    return __sbCollectionIterator(this, 2, false);
   }
+  [Symbol.iterator]() { return this.entries(); }
   get size() {
     return this._keys.length;
   }
@@ -318,24 +338,22 @@ if (globalThis.FormData == null) {
       for (let i = 0; i < this._entries.length; i++) cb(this._entries[i][1], this._entries[i][0], this);
     }
     keys() {
-      return this._entries.map((e) => e[0]);
+      return __sbCollectionIterator(this, 0, true);
     }
     values() {
-      return this._entries.map((e) => e[1]);
+      return __sbCollectionIterator(this, 1, true);
     }
     entries() {
-      return this._entries.map((e) => [e[0], e[1]]);
+      return __sbCollectionIterator(this, 2, true);
     }
   }
+  __SproutboatFormData.prototype[Symbol.iterator] = __SproutboatFormData.prototype.entries;
   globalThis.FormData = __SproutboatFormData;
 }
 
 function __sbParseUrlencodedFormData(text) {
   const fd = new FormData();
-  // forEach, not keys()/values() — those are spec'd as iterators, not
-  // arrays, and this shim's own URLSearchParams.keys()/values() return
-  // arrays as an implementation shortcut, so relying on either shape here
-  // would break against whichever kind actually ends up installed.
+  // forEach handles both the native API and the local shim.
   new URLSearchParams(text).forEach((value, key) => fd.append(key, value));
   return fd;
 }

package/src/source.ts

@@ -25,14 +25,7 @@ const alwaysForbidden: Array<[RegExp, string]> = [
   // match would also flag it appearing in an ordinary string a dependency
   // happens to construct (a doc link, a log message).
   [/['"`]node:/, "Node, Bun, and Deno APIs are not supported"],
-  // The Porffor pin compiles `new Proxy(...)` and then ignores the handler: a
-  // trapped property reads back as `undefined`, with no throw. Rejecting it
-  // here is the difference between a build error and a 502 nobody can explain.
-  // It is why itty-router and other Proxy-based routers do not work yet.
-  [
-    /\bnew\s+Proxy\s*\(|\bProxy\s*\.\s*revocable\s*\(/,
-    "Proxy is not supported by the compiler: its traps are silently ignored and the property reads back as undefined",
-  ],
+
 ];
 
 export function validateHttpSyncSource(source: string): SourceValidation {

package/test/native-iterators.ts

@@ -0,0 +1,103 @@
+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 = {
+  query: [["a", "1"], ["a", "2"], ["b", "3"]],
+  keys: ["a", "a", "b"], values: ["1", "2", "3"],
+  live: ["x", "y", true], form: [["x", "1"], ["x", "2"]],
+  formLive: ["x", "y", true], self: true,
+};
+const handler = `export default { fetch(request) {
+  if (new URL(request.url).pathname === "/null") return new Response(null);
+  const params = new URLSearchParams("a=1&a=2&b=3");
+  const query = [];
+  for (const pair of params) query.push(pair);
+  const liveParams = new URLSearchParams("x=1");
+  const iterator = liveParams.keys();
+  const first = iterator.next().value;
+  liveParams.append("y", "2");
+  const second = iterator.next().value;
+  const done = iterator.next().done;
+  const fd = new FormData(); fd.append("x", "1"); fd.append("x", "2");
+  const form = []; for (const pair of fd) form.push(pair);
+  const liveForm = new FormData(); liveForm.append("x", "1");
+  const formIterator = liveForm.keys(); const f1 = formIterator.next().value;
+  liveForm.append("y", "2"); const f2 = formIterator.next().value;
+  return Response.json({ query, keys: Array.from(params.keys()), values: Array.from(params.values()),
+    live: [first, second, done], form, formLive: [f1, f2, formIterator.next().done],
+    self: iterator[Symbol.iterator]() === iterator });
+} };`;
+
+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-iterators-"));
+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 iterators 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, "iterators.generated.js");
+  const binary = join(workdir, "iterators-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 iterators 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 API iterators preserve entries, duplicate keys and live mutations");
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}