@sproutboat/runtime 0.34.3 → 0.34.5

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @sproutboat/runtime
 
+## 0.34.5
+
+### Patch Changes
+
+- e62b600: The client address is folded to plain IPv4 once per distinct address instead of on every request: a request read `x-sb-remote-addr` and, for an IPv4-mapped IPv6 peer, lowercased, split and hex-parsed it each time. The last address and its result are kept; a different address takes the same path as before.
+- 0b12b94: A strict D1 query hands its rows to JavaScript with fewer copies: the text of every cell goes into one arena instead of one `malloc` per cell, and a cell that is plain ASCII becomes its JS string in one copy (it used to go through a UTF-16 buffer, an 8-bit buffer and a third copy, three `malloc`s each). Non-ASCII text still takes the old path, so the strings are unchanged.
+
+## 0.34.4
+
+### Patch Changes
+
+- 5bd4a25: Cheaper JWT verification. `atob` decodes in C for the usual input (no whitespace, valid characters, correct padding) and falls back to the existing JavaScript for everything else, so what throws and what it throws is unchanged. `TextEncoder.encode` sizes and fills the Uint8Array in two C passes instead of two `charCodeAt` loops (a lone surrogate is still U+FFFD). The ArrayBuffer returned by `crypto.subtle.sign` and `digest` is copied in with one `memcpy`, and the constant-time compare behind `verify` runs in C. A typical `authenticate()` (three base64url decodes, two `JSON.parse`, one `TextEncoder.encode`, one HMAC verify) goes from 21.5 to 7 us on an M-series host. New native test `test:native-jwt`: RFC 4231 HMAC vectors, the RFC 7515 and jwt.io tokens, wrong key, tampered header, payload and signature, short, long and missing signatures, bad base64url, typed-array windows and ArrayBuffers as verify input, and seeded random `atob`, `TextEncoder` and HMAC (SHA-256, 384, 512) inputs compared with Bun and node:crypto.
+
 ## 0.34.3
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.34.3",
+  "version": "0.34.5",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/native-fetch-prelude.js

@@ -3645,7 +3645,12 @@ if (globalThis.crypto.getRandomValues == null) {
   for (let i = 0; i < 128; i++) sextet.push(255);
   for (let i = 0; i < alphabet.length; i++) sextet[alphabet.charCodeAt(i)] = i;
   globalThis.atob = function (data) {
-    let text = String(data).replace(/[\t\n\f\r ]/g, "");
+    // One C pass for the usual input (no whitespace, valid characters); the JS below
+    // takes everything else, so it alone decides what throws.
+    const input = String(data);
+    const fast = __sbAtobNative(input);
+    if (fast !== "") return fast;
+    let text = input.replace(/[\t\n\f\r ]/g, "");
     if (text.length % 4 === 0) text = text.replace(/==?$/, "");
     if (text.length % 4 === 1) throw invalidCharacter("atob: the string is not valid base64");
     const parts = [];
@@ -4058,6 +4063,7 @@ function __sbToBytes(input) {
 }
 function __sbBufFrom(latin1) {
   const b = new Uint8Array(latin1.length);
+  if (__sbFillBytes(latin1, b)) return b.buffer;
   for (let i = 0; i < latin1.length; i++) b[i] = latin1.charCodeAt(i) & 0xff;
   return b.buffer;
 }
@@ -4190,6 +4196,8 @@ function __sbRawBodyResponse(body, init) {
 // Constant-time compare of two latin1 byte strings.
 function __sbEqCt(a, b) {
   if (a.length !== b.length) return false;
+  const native = __sbEqCtNative(a, b);
+  if (native >= 0) return native === 1;
   let diff = 0;
   for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
   return diff === 0;
@@ -4805,6 +4813,21 @@ static size_t sb_utf8_encode_units(const uint16_t* s, size_t len, unsigned char*
   return k;
 }
 
+// Unit I of a string held as UTF-16 (WIDE) or one unit per byte.
+static unsigned sb_unit(const unsigned char* s, int wide, size_t i) {
+  return wide ? (unsigned)((const uint16_t*)s)[i] : (unsigned)s[i];
+}
+
+// Base64 sextet of a character, or -1.
+static int sb_b64_val(unsigned c) {
+  if (c >= 'A' && c <= 'Z') return (int)(c - 'A');
+  if (c >= 'a' && c <= 'z') return (int)(c - 'a') + 26;
+  if (c >= '0' && c <= '9') return (int)(c - '0') + 52;
+  if (c == '+') return 62;
+  if (c == '/') return 63;
+  return -1;
+}
+
 `;
 
 // sproutd #22: __sbFromUtf8 for a string of bytes (one byte per unit) or a Uint8Array, in C.
@@ -4905,6 +4928,91 @@ function __sbToBytesNative(input) {
   return out;
 }
 
+// Constant-time equality of two equal-length bytestrings in C: 1 equal, 0 different, -1 when
+// either is not a bytestring (the caller then compares in JS).
+// oxlint-disable-next-line no-unused-vars -- `a` and `b` are read inside the RawC block below, not by JS.
+function __sbEqCtNative(a, b) {
+  let result = -1;
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    if (a.type == 195 && b.type == 195) {
+      const size_t __n = (size_t)*(u32*)(MEM + (u32)a.val);
+      if (__n == (size_t)*(u32*)(MEM + (u32)b.val)) {
+        const unsigned char* __x = (const unsigned char*)(MEM + (u32)a.val + 4);
+        const unsigned char* __y = (const unsigned char*)(MEM + (u32)b.val + 4);
+        unsigned char __diff = 0;
+        for (size_t __i = 0; __i < __n; __i++) __diff |= __x[__i] ^ __y[__i];
+        result = (f64)(__diff == 0 ? 1 : 0);
+      }
+    }
+  `;
+  return result;
+}
+
+// Copies a bytestring (one unit per byte) into the front of a Uint8Array.
+// Returns false (writing nothing) when it cannot.
+// oxlint-disable-next-line no-unused-vars -- `bytes` and `view` are read inside the RawC block below, not by JS.
+function __sbFillBytes(bytes, view) {
+  let ok = 0;
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    if (bytes.type == 195 && view.type == 81 && *(int32_t*)(MEM + (u32)view.val) >= 0) {
+      const u32 __p = (u32)bytes.val;
+      const u32 __v = (u32)view.val;
+      const size_t __n = (size_t)*(u32*)(MEM + __p);
+      if (__n <= (size_t)*(int32_t*)(MEM + __v)) {
+        memcpy(MEM + *(u32*)(MEM + __v + 4) + 4, MEM + __p + 4, __n);
+        ok = (f64)1;
+      }
+    }
+  `;
+  return ok === 1;
+}
+
+// atob for the common case: no whitespace, only base64 characters, `=` padding
+// only where the spec allows it. Returns the decoded bytestring, or "" for
+// anything else (including an empty result), so the caller's JS path decides
+// and throws.
+// oxlint-disable-next-line no-unused-vars -- `text` is read inside the RawC block below, not by JS.
+function __sbAtobNative(text) {
+  let out = "";
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    if (text.type == 195 || text.type == 67) {
+      const u32 __p = (u32)text.val;
+      const int __wide = text.type == 67;
+      size_t __n = (size_t)*(u32*)(MEM + __p);
+      const unsigned char* __s = (const unsigned char*)(MEM + __p + 4);
+      if (__n % 4 == 0) {
+        if (__n > 0 && sb_unit(__s, __wide, __n - 1) == '=') __n--;
+        if (__n > 0 && sb_unit(__s, __wide, __n - 1) == '=' && __n % 4 != 0) __n--;
+      }
+      if (__n > 0 && __n % 4 != 1) {
+        const size_t __cap = __n / 4 * 3 + 3;
+        unsigned char __stack[768];
+        unsigned char* __o = __cap <= sizeof(__stack) ? __stack : (unsigned char*)malloc(__cap);
+        if (__o) {
+          size_t __k = 0, __i = 0;
+          int __bad = 0;
+          uint32_t __acc = 0;
+          int __bits = 0;
+          for (; __i < __n; __i++) {
+            const unsigned __c = sb_unit(__s, __wide, __i);
+            const int __v = __c < 128 ? sb_b64_val(__c) : -1;
+            if (__v < 0) { __bad = 1; break; }
+            __acc = (__acc << 6) | (uint32_t)__v;
+            __bits += 6;
+            if (__bits >= 8) { __bits -= 8; __o[__k++] = (unsigned char)((__acc >> __bits) & 0xff); }
+          }
+          if (!__bad) out = porf_box((f64)porf_native_fetch_alloc_bytestring((const char*)__o, __k), 195);
+          if (__o != __stack) free(__o);
+        }
+      }
+    }
+  `;
+  return out;
+}
+
 // TRANSPORT: wrap.ts splices one of transport-broker.js / transport-embedded.js here.
 
 // `nStr` is the decimal byte count as a string (same string-param pattern as
@@ -7851,8 +7959,19 @@ function __sbParseHex(s) {
 // uWS hands back IPv4-mapped IPv6 for IPv4 clients on a dual-stack socket
 // (`::ffff:1.2.3.4`, or fully expanded `0:0:0:0:0:ffff:0102:0304`). Fold those
 // to the dotted IPv4 so CIDR matching and `clientIp` see a plain address.
+// The last address folded and its result: a client keeps the same address from one request to the
+// next, and folding an IPv6 text costs a lowercase, a split and eight hex parses.
+let __sbIpRaw = "";
+let __sbIpFolded = "";
 function __sbNormalizeIp(ip) {
   const s = String(ip || "");
+  if (s === __sbIpRaw) return __sbIpFolded;
+  const folded = __sbFoldIp(s);
+  __sbIpRaw = s;
+  __sbIpFolded = folded;
+  return folded;
+}
+function __sbFoldIp(s) {
   if (s.indexOf(":") === -1) return s;
   const low = s.toLowerCase();
   const dotted = low.indexOf("::ffff:");

package/src/r2-object.test.js

@@ -31,7 +31,7 @@ const load = new Function(
   "__sbRpc",
   "__sbR2MultipartPut",
   // __sbIsStr and __sbToBytes (for uploadPart's values), with the C fast paths stubbed out.
-  `function __sbFromUtf8Native() { return ""; }\nfunction __sbToBytesNative() { return ""; }\n${src.slice(isStrStart, isStrEnd)}\n${src.slice(bytesStart, utf8Start)}\n${src.slice(utf8Start, utf8End)}\n${src.slice(rawStart, rawEnd)}\n${src.slice(r2Start, r2End)}\nreturn { __sbR2Object, __sbR2Multipart };`,
+  `function __sbFromUtf8Native() { return ""; }\nfunction __sbToBytesNative() { return ""; }\nfunction __sbFillBytes() { return false; }\n${src.slice(isStrStart, isStrEnd)}\n${src.slice(bytesStart, utf8Start)}\n${src.slice(utf8Start, utf8End)}\n${src.slice(rawStart, rawEnd)}\n${src.slice(r2Start, r2End)}\nreturn { __sbR2Object, __sbR2Multipart };`,
 );
 const calls = [];
 const rpc = (op, value) => {

package/src/transport-embedded.js

@@ -2162,13 +2162,33 @@ static char* sb_sql_error(sqlite3* db, const char* message, int code, int skip)
 // A strict D1 query can hand its rows back as cells instead of JSON text: the caller turns
 // them into JS arrays, with no JSON written here and none parsed there. t is 0 NULL,
 // 1 number, 2 TEXT (UTF-8 in p), 3 BLOB (bytes in p).
-typedef struct { unsigned char t; double d; char* p; int n; } sb_cell;
-typedef struct { sb_cell* c; size_t n; size_t cap; int ncol; int used; } sb_cells;
+// The text and blob bytes of every cell share one arena (a cell holds an offset into it), and a
+// TEXT cell says whether it is all ASCII: that one becomes a JS string with a single copy.
+typedef struct { unsigned char t; unsigned char ascii; double d; size_t off; int n; } sb_cell;
+typedef struct { sb_cell* c; size_t n; size_t cap; int ncol; int used; char* a; size_t alen; size_t acap; } sb_cells;
 static void sb_cells_free(sb_cells* cs) {
   if (!cs) return;
-  for (size_t i = 0; i < cs->n; i++) free(cs->c[i].p);
   free(cs->c);
-  cs->c = 0; cs->n = cs->cap = 0;
+  free(cs->a);
+  cs->c = 0; cs->a = 0; cs->n = cs->cap = cs->alen = cs->acap = 0;
+}
+// Copies n bytes into the arena and returns their offset, or (size_t)-1 when out of memory.
+static size_t sb_cells_bytes(sb_cells* cs, const unsigned char* src, size_t n, unsigned char* ascii) {
+  if (cs->alen + n + 1 > cs->acap) {
+    size_t cap = cs->acap ? cs->acap * 2 : 1024;
+    while (cap < cs->alen + n + 1) cap *= 2;
+    char* grown = (char*)realloc(cs->a, cap);
+    if (!grown) return (size_t)-1;
+    cs->a = grown; cs->acap = cap;
+  }
+  const size_t off = cs->alen;
+  unsigned char high = 0;
+  for (size_t i = 0; i < n; i++) high |= src[i];
+  if (n) memcpy(cs->a + off, src, n);
+  cs->a[off + n] = 0;
+  cs->alen = off + n + 1;
+  *ascii = high < 0x80;
+  return off;
 }
 static sb_cell* sb_cells_add(sb_cells* cs) {
   if (cs->n == cs->cap) {
@@ -2178,7 +2198,7 @@ static sb_cell* sb_cells_add(sb_cells* cs) {
     cs->c = grown; cs->cap = cap;
   }
   sb_cell* cell = &cs->c[cs->n++];
-  cell->t = 0; cell->d = 0; cell->p = 0; cell->n = 0;
+  cell->t = 0; cell->ascii = 0; cell->d = 0; cell->off = 0; cell->n = 0;
   return cell;
 }
 static char* sb_sql_run_x(const char* path, const char* sql, const char* params, sb_cells* cells) {
@@ -2226,10 +2246,8 @@ static char* sb_sql_run_x(const char* path, const char* sql, const char* params,
         int n = sqlite3_column_bytes(st, i);
         cell->t = t == 4 ? 3 : 2;
         cell->n = txt ? n : 0;
-        cell->p = (char*)malloc((size_t)cell->n + 1);
-        if (!cell->p) { cells->used = -1; break; }
-        if (cell->n) memcpy(cell->p, txt, (size_t)cell->n);
-        cell->p[cell->n] = 0;
+        cell->off = sb_cells_bytes(cells, txt, (size_t)cell->n, &cell->ascii);
+        if (cell->off == (size_t)-1) { cells->used = -1; break; }
       }
       if (cells->used < 0) break;
       continue;
@@ -4261,12 +4279,14 @@ function __sbSqlRowsRaw(path, sql, paramsJson) {
           const sb_cell* __cell = &__cells.c[__r * __ncol + __c];
           jsval __v = porf_box(0.0, 7);
           if (__cell->t == 1) __v = porf_box_num(__cell->d);
-          else if (__cell->t == 2) {
+          else if (__cell->t == 2 && __cell->ascii) {
+            __v = porf_box((f64)porf_native_fetch_alloc_bytestring(__cells.a + __cell->off, (size_t)__cell->n), 195);
+          } else if (__cell->t == 2) {
             const size_t __n = (size_t)__cell->n;
             uint16_t* __u = (uint16_t*)malloc(__n * 2 + 2);
             if (__u) {
               int __wide = 0;
-              const size_t __k = sb_text_units((const unsigned char*)__cell->p, __n, __u, &__wide);
+              const size_t __k = sb_text_units((const unsigned char*)(__cells.a + __cell->off), __n, __u, &__wide);
               if (__wide) {
                 const u32 __str = porf_native_fetch_alloc((u32)(4 + __k * 2), 67);
                 *(u32*)(MEM + __str) = (u32)__k;
@@ -4284,7 +4304,7 @@ function __sbSqlRowsRaw(path, sql, paramsJson) {
             }
           } else if (__cell->t == 3) {
             const u32 __bytes = porf_arr_new((i32)__cell->n, (i32)__cell->n);
-            for (int __i = 0; __i < __cell->n; __i++) porf_arr_set(__bytes, (u32)__i, porf_box_num((f64)(unsigned char)__cell->p[__i]));
+            for (int __i = 0; __i < __cell->n; __i++) porf_arr_set(__bytes, (u32)__i, porf_box_num((f64)(unsigned char)__cells.a[__cell->off + __i]));
             __v = porf_box((f64)__bytes, 72);
           }
           porf_arr_set(__row, (u32)__c, __v);

package/test/native-d1.ts

@@ -67,12 +67,12 @@ int main(void) {
           else if (x->t == 1) printf("%.17g", x->d);
           else if (x->t == 2) {
             uint16_t* u = (uint16_t*)malloc((size_t)x->n * 2 + 2); int wide = 0;
-            size_t k = sb_text_units((const unsigned char*)x->p, (size_t)x->n, u, &wide);
+            size_t k = sb_text_units((const unsigned char*)(cs.a + x->off), (size_t)x->n, u, &wide);
             printf("\\"");
             for (size_t i = 0; i < k; i++) printf("\\\\u%04x", u[i]);
             printf("\\"");
             free(u);
-          } else { printf("{\\"$blob\\":\\""); for (int i = 0; i < x->n; i++) printf("%02x", (unsigned char)x->p[i]); printf("\\"}"); }
+          } else { printf("{\\"$blob\\":\\""); for (int i = 0; i < x->n; i++) printf("%02x", (unsigned char)cs.a[x->off + i]); printf("\\"}"); }
         }
         printf("]");
       }

package/test/native-http.ts

@@ -0,0 +1,280 @@
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { connect } from "node:net";
+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";
+
+// The native HTTP server's wire behaviour with raw sockets: keep-alive, pipelining (responses in
+// order, also when a request arrives in pieces), a response bigger than the socket buffer to a slow
+// reader (partial writes), a large request body, and many connections at once. Run once with a
+// collection after every request (SB_GC_EVERY=1) and once with the default interval, so the
+// collection schedule is shown not to disturb any of it.
+const handler = `export default {async fetch(request) {
+  const url = new URL(request.url);
+  const path = url.pathname;
+  if (path.startsWith("/n/")) return new Response("n=" + path.slice(3), { headers: { "x-n": path.slice(3) } });
+  if (path === "/echo") { const b = await request.arrayBuffer(); return new Response("len=" + b.byteLength + " first=" + (b.byteLength ? new Uint8Array(b)[0] : -1) + " last=" + (b.byteLength ? new Uint8Array(b)[b.byteLength - 1] : -1)); }
+  if (path === "/big") {
+    const size = Number(url.searchParams.get("size"));
+    const out = new Uint8Array(size);
+    for (let i = 0; i < size; i++) out[i] = (i * 31 + 7) & 255;
+    return new Response(out);
+  }
+  if (path === "/garbage") { const rows = []; for (let i = 0; i < 2000; i++) rows.push({ i, s: "x".repeat(i % 50) }); return new Response(JSON.stringify(rows).length + ""); }
+  return new Response("not found", { status: 404 });
+}};`;
+
+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;
+}
+
+type Parsed = { status: number; headers: Map<string, string>; body: Buffer };
+
+// Parses as many whole Content-Length responses as `buffer` holds; returns them and the rest.
+type ParsedBatch = { done: Parsed[]; rest: Buffer };
+function parseResponses(buffer: Buffer): ParsedBatch {
+  const done: Parsed[] = [];
+  let rest = buffer;
+  for (;;) {
+    const end = rest.indexOf("\r\n\r\n");
+    if (end < 0) break;
+    const head = rest.subarray(0, end).toString("latin1").split("\r\n");
+    const status = Number(head[0].split(" ")[1]);
+    const headers = new Map<string, string>();
+    for (const line of head.slice(1)) {
+      const at = line.indexOf(":");
+      headers.set(line.slice(0, at).toLowerCase(), line.slice(at + 1).trim());
+    }
+    const length = Number(headers.get("content-length") ?? 0);
+    if (rest.length < end + 4 + length) break;
+    done.push({ status, headers, body: rest.subarray(end + 4, end + 4 + length) });
+    rest = rest.subarray(end + 4 + length);
+  }
+  return { done, rest };
+}
+
+// Writes `chunks` (with `gapMs` between them), then reads until `want` responses arrived.
+// `readDelayMs` holds the socket paused first, so the server's send buffer fills.
+async function exchange(
+  port: number,
+  chunks: Buffer[],
+  want: number,
+  opts: { gapMs?: number; readDelayMs?: number; timeoutMs?: number } = {},
+): Promise<Parsed[]> {
+  return new Promise((resolveExchange, reject) => {
+    const socket = connect(port, "127.0.0.1");
+    let pending = Buffer.alloc(0);
+    const responses: Parsed[] = [];
+    const timer = setTimeout(() => {
+      socket.destroy();
+      reject(new Error(`timed out with ${responses.length} of ${want} responses`));
+    }, opts.timeoutMs ?? 30_000);
+    socket.on("error", reject);
+    socket.on("data", (data) => {
+      pending = Buffer.concat([pending, data]);
+      const { done, rest } = parseResponses(pending);
+      pending = rest;
+      responses.push(...done);
+      if (responses.length >= want) {
+        clearTimeout(timer);
+        socket.destroy();
+        resolveExchange(responses);
+      }
+    });
+    socket.on("connect", async () => {
+      if (opts.readDelayMs) {
+        socket.pause();
+        setTimeout(() => socket.resume(), opts.readDelayMs);
+      }
+      for (const chunk of chunks) {
+        socket.write(chunk);
+        if (opts.gapMs) await Bun.sleep(opts.gapMs);
+      }
+    });
+  });
+}
+
+const get = (path: string, close = false) =>
+  Buffer.from(`GET ${path} HTTP/1.1\r\nHost: t\r\n${close ? "Connection: close\r\n" : ""}\r\n`);
+const post = (path: string, body: Buffer) =>
+  Buffer.concat([Buffer.from(`POST ${path} HTTP/1.1\r\nHost: t\r\nContent-Length: ${body.length}\r\n\r\n`), body]);
+
+async function suite(port: number, label: string) {
+  // Keep-alive: sequential requests on one connection, each answered before the next is sent.
+  {
+    const socket = connect(port, "127.0.0.1");
+    await new Promise<void>((r) => socket.once("connect", () => r()));
+    let pending = Buffer.alloc(0);
+    for (let i = 0; i < 5; i++) {
+      socket.write(get(`/n/${i}`));
+      let got: Parsed | undefined;
+      while (!got) {
+        const data = await new Promise<Buffer>((r) => socket.once("data", r));
+        pending = Buffer.concat([pending, data]);
+        const parsed = parseResponses(pending);
+        pending = parsed.rest;
+        got = parsed.done[0];
+      }
+      assert.equal(got.body.toString(), `n=${i}`, `${label}: keep-alive response ${i}`);
+    }
+    socket.destroy();
+  }
+
+  // Pipelining: 60 requests in one write come back complete and in order.
+  {
+    const all = Buffer.concat(Array.from({ length: 60 }, (_, i) => get(`/n/${i}`)));
+    const got = await exchange(port, [all], 60);
+    assert.deepEqual(
+      got.map((r) => r.body.toString()),
+      Array.from({ length: 60 }, (_, i) => `n=${i}`),
+      `${label}: pipelined order`,
+    );
+  }
+
+  // Pipelining with requests cut at every awkward place: one byte at a time for the first two.
+  {
+    const bytes = Buffer.concat([get("/n/a"), post("/echo", Buffer.from("hello")), get("/n/b")]);
+    const chunks: Buffer[] = [];
+    for (let i = 0; i < 40; i++) chunks.push(bytes.subarray(i, i + 1));
+    chunks.push(bytes.subarray(40));
+    const got = await exchange(port, chunks, 3, { gapMs: 2 });
+    assert.deepEqual(
+      got.map((r) => r.body.toString()),
+      ["n=a", "len=5 first=104 last=111", "n=b"],
+      `${label}: pipelined requests split across packets`,
+    );
+  }
+
+  // A POST whose body arrives in pieces, followed by a pipelined GET.
+  {
+    const body = Buffer.alloc(300_000, 0x61);
+    body[0] = 0x62;
+    const request = Buffer.concat([post("/echo", body), get("/n/after")]);
+    const chunks: Buffer[] = [];
+    for (let at = 0; at < request.length; at += 40_000) chunks.push(request.subarray(at, at + 40_000));
+    const got = await exchange(port, chunks, 2, { gapMs: 3 });
+    assert.equal(got[0].body.toString(), "len=300000 first=98 last=97", `${label}: large request body`);
+    assert.equal(got[1].body.toString(), "n=after", `${label}: request after a large body`);
+  }
+
+  // Partial writes: 12 MB to a reader that does not read for 400 ms, then a pipelined small response
+  // that must still arrive after it, in order.
+  {
+    const size = 12 * 1024 * 1024;
+    const got = await exchange(port, [get(`/big?size=${size}`), get("/n/last")], 2, {
+      readDelayMs: 400,
+      timeoutMs: 60_000,
+    });
+    assert.equal(got[0].body.length, size, `${label}: big body length`);
+    const expected = Buffer.alloc(size);
+    for (let i = 0; i < size; i++) expected[i] = (i * 31 + 7) & 255;
+    assert.equal(
+      createHash("sha256").update(got[0].body).digest("hex"),
+      createHash("sha256").update(expected).digest("hex"),
+      `${label}: big body bytes`,
+    );
+    assert.equal(got[1].body.toString(), "n=last", `${label}: response after a partial write`);
+  }
+
+  // Connection: close ends the connection after the response.
+  {
+    const got = await exchange(port, [get("/n/close", true)], 1);
+    assert.equal(got[0].body.toString(), "n=close");
+  }
+
+  // 150 connections at once, 4 pipelined requests each, with garbage-heavy requests mixed in.
+  {
+    const results = await Promise.all(
+      Array.from({ length: 150 }, async (_, c) => {
+        const chunks = [get(`/n/${c}-0`), get("/garbage"), get(`/n/${c}-2`), get(`/n/${c}-3`)];
+        return exchange(port, [Buffer.concat(chunks)], 4);
+      }),
+    );
+    results.forEach((got, c) => {
+      assert.deepEqual(
+        [got[0].body.toString(), got[2].body.toString(), got[3].body.toString()],
+        [`n=${c}-0`, `n=${c}-2`, `n=${c}-3`],
+        `${label}: connection ${c}`,
+      );
+      assert.equal(got[1].status, 200);
+    });
+  }
+}
+
+const workdir = await mkdtemp(join(tmpdir(), "sb-native-http-"));
+const servers: Array<ReturnType<typeof Bun.spawn>> = [];
+try {
+  const porffor = await ensurePorffor();
+  const node = Bun.which("node");
+  if (!node) throw new Error("native http 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, "http.generated.js");
+  const binary = join(workdir, "http-native");
+  await writeFile(
+    generated,
+    wrapNativeFetchHandler(
+      handler,
+      core.replace(TRANSPORT_MARKER, broker),
+      undefined,
+      undefined,
+      undefined,
+      "2026-10-21",
+    ),
+  );
+  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}`);
+
+  for (const every of ["1", "8"]) {
+    const port = freePort();
+    const server = Bun.spawn([binary], {
+      cwd: workdir,
+      env: { ...process.env, PORT: String(port), SB_GC_EVERY: every },
+      stdout: "ignore",
+      stderr: "inherit",
+    });
+    servers.push(server);
+    let ready = false;
+    for (let attempt = 0; attempt < 50 && !ready; attempt++) {
+      try {
+        await fetch(`http://127.0.0.1:${port}/n/0`, { signal: AbortSignal.timeout(500) });
+        ready = true;
+      } catch {
+        if (server.exitCode !== null) break;
+        await Bun.sleep(100);
+      }
+    }
+    assert(ready, "compiled handler did not start");
+    await suite(port, `SB_GC_EVERY=${every}`);
+    // The server is still answering after all of it.
+    assert.equal(await (await fetch(`http://127.0.0.1:${port}/n/z`)).text(), "n=z");
+  }
+  console.log(
+    "Native HTTP: keep-alive, pipelining, split requests, large bodies, partial writes and 150 connections hold at SB_GC_EVERY=1 and 8",
+  );
+} finally {
+  for (const server of servers) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-jwt.ts

@@ -0,0 +1,333 @@
+import assert from "node:assert/strict";
+import { createHmac } from "node:crypto";
+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";
+
+// The pieces of a JWT check (base64url decode, TextEncoder, HMAC verify) against values that do
+// not come from the runtime under test: RFC 4231 and RFC 7515 vectors, the jwt.io example, and
+// Bun / node:crypto on seeded random inputs.
+
+let seed = 0x2545f491;
+const rand = (n: number): number => {
+  seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0;
+  return seed % n;
+};
+const randomBytes = (n: number): Uint8Array => Uint8Array.from({ length: n }, () => rand(256));
+const toB64Url = (b: Uint8Array): string => Buffer.from(b).toString("base64url");
+
+// atob: valid, padded and unpadded, with whitespace, and the inputs it must reject.
+const atobInputs: string[] = [];
+for (let n = 0; n <= 40; n++) {
+  const padded = Buffer.from(randomBytes(n)).toString("base64");
+  atobInputs.push(padded, padded.replace(/=+$/, ""), padded.replace(/(.{3})/, "$1 \n"), ` ${padded}\t`);
+}
+atobInputs.push(
+  Buffer.from(randomBytes(5000)).toString("base64"),
+  Buffer.from(randomBytes(769)).toString("base64"),
+  "a",
+  "abcde",
+  "ab$c",
+  "=abc",
+  "ab=c",
+  "a===",
+  "====",
+  "==",
+  "abc==",
+  "YQ=",
+  "YQ===",
+  "YQ==YQ==",
+  " ",
+  "\n",
+  "",
+  "-_",
+  "abéd",
+  "abŁd",
+  "QUJDé",
+  "Ł",
+  "YWJj\0",
+);
+
+// TextEncoder: each length, every kind of unit, lone surrogates in every position.
+const pieces = ["a", "Z", "é", "ÿ", "Ā", "߿", "ࠀ", "东", "🚤", "\ud800", "\udc00", "\udbff", "\udfff", "�", "\0"];
+const encodeInputs: string[] = [];
+for (let n = 0; n <= 60; n++) encodeInputs.push(Array.from({ length: n }, () => pieces[rand(pieces.length)]).join(""));
+encodeInputs.push(
+  "\ud83d",
+  "\ud83dx",
+  "x\udea4",
+  "\udea4\ud83d",
+  "\ud83d🚤",
+  "🚤\udea4",
+  "é".repeat(3000),
+  "🚤".repeat(5000),
+  "x".repeat(70000),
+);
+
+// HMAC: every key and message length around the SHA-256 and SHA-512 block sizes, high bytes included.
+const hmacCases: { key: number[]; data: number[]; hash: string }[] = [];
+for (const [klen, dlen] of [
+  [0, 0],
+  [1, 1],
+  [20, 8],
+  [32, 55],
+  [64, 56],
+  [64, 64],
+  [65, 119],
+  [131, 54],
+  [200, 300],
+  [16, 1000],
+]) {
+  for (const hash of ["SHA-256", "SHA-384", "SHA-512"]) {
+    hmacCases.push({ key: Array.from(randomBytes(klen)), data: Array.from(randomBytes(dlen)), hash });
+  }
+}
+const nodeHash = (h: string): string => h.replace("-", "").toLowerCase();
+const hexOf = (b: Uint8Array | Buffer): string => Buffer.from(b).toString("hex");
+
+// Published vectors.
+const rfc4231 = [
+  {
+    key: "0b".repeat(20),
+    data: Buffer.from("Hi There").toString("hex"),
+    mac: "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7",
+  },
+  {
+    key: Buffer.from("Jefe").toString("hex"),
+    data: Buffer.from("what do ya want for nothing?").toString("hex"),
+    mac: "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
+  },
+  {
+    key: "aa".repeat(131),
+    data: Buffer.from("Test Using Larger Than Block-Size Key - Hash Key First").toString("hex"),
+    mac: "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54",
+  },
+];
+const rfc7515Key = "AyM1SysPpbyDfgZld3umj1qzKObwVMkoqQ-EstJQLr_T-1qS0gZH75aKtMN3Yj0iPS4hcgUuTwjAzZr1Z9CAow";
+const rfc7515 =
+  "eyJ0eXAiOiJKV1QiLA0KICJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJqb2UiLA0KICJleHAiOjEzMDA4MTkzODAsDQogImh0dHA6Ly9leGFtcGxlLmNvbS9pc19yb290Ijp0cnVlfQ.dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
+const jwtIo =
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c";
+const jwtIoKey = "your-256-bit-secret";
+
+const handler = `
+const codes = (s) => Array.from(s, (c) => c.charCodeAt(0));
+const hex = (buffer) => {
+  const bytes = new Uint8Array(buffer);
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) out += (bytes[i] + 0x100).toString(16).slice(1);
+  return out;
+};
+const fromHex = (h) => {
+  const out = new Uint8Array(h.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
+  return out;
+};
+const b64urlBytes = (s) => {
+  let b = s.replace(/-/g, "+").replace(/_/g, "/");
+  while (b.length % 4) b += "=";
+  const bin = atob(b);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+};
+const hmacKey = (bytes, hash, usages) => crypto.subtle.importKey("raw", bytes, { name: "HMAC", hash }, false, usages || ["sign", "verify"]);
+// The check an API server writes: split, decode the signature, verify over the signing input.
+const verifyJwt = async (token, keyBytes) => {
+  const dot = token.lastIndexOf(".");
+  const key = await hmacKey(keyBytes, "SHA-256", ["verify"]);
+  let sig;
+  try { sig = b64urlBytes(token.slice(dot + 1)); } catch (e) { return "bad-base64:" + e.name; }
+  return crypto.subtle.verify("HMAC", key, sig, new TextEncoder().encode(token.slice(0, dot)));
+};
+export default {
+  async fetch() {
+    const input = JSON.parse(${JSON.stringify(JSON.stringify({ atobInputs, encodeInputs, hmacCases, rfc4231, rfc7515Key, rfc7515, jwtIo, jwtIoKey }))});
+    const out = {};
+    out.atob = input.atobInputs.map((s) => { try { return codes(atob(s)); } catch (e) { return e.name; } });
+    // The same strings as UTF-16 storage: built from a JSON escape, so not literals.
+    out.atobWide = input.atobInputs.slice(0, 12).map((s) => { const w = JSON.parse(JSON.stringify(s + "\\u0141")); try { return codes(atob(w.slice(0, -1))); } catch (e) { return e.name; } });
+    out.encode = input.encodeInputs.map((s) => Array.from(new TextEncoder().encode(s)));
+    out.encodeWide = input.encodeInputs.slice(0, 12).map((s) => Array.from(new TextEncoder().encode(JSON.parse(JSON.stringify(s)))));
+    out.hmac = [];
+    for (const c of input.hmacCases) {
+      const key = await hmacKey(Uint8Array.from(c.key), c.hash);
+      const mac = await crypto.subtle.sign("HMAC", key, Uint8Array.from(c.data));
+      const ok = await crypto.subtle.verify("HMAC", key, mac, Uint8Array.from(c.data));
+      const bad = await crypto.subtle.verify("HMAC", key, mac, Uint8Array.from(c.data.concat([0])));
+      out.hmac.push({ mac: hex(mac), ok, bad });
+    }
+    out.rfc4231 = [];
+    for (const v of input.rfc4231) {
+      const key = await hmacKey(fromHex(v.key), "SHA-256");
+      out.rfc4231.push(hex(await crypto.subtle.sign("HMAC", key, fromHex(v.data))));
+    }
+    const sigOf = (token) => token.slice(token.lastIndexOf(".") + 1);
+    const flip = (token, at) => token.slice(0, at) + (token[at] === "A" ? "B" : "A") + token.slice(at + 1);
+    const k1 = b64urlBytes(input.rfc7515Key);
+    const k2 = new TextEncoder().encode(input.jwtIoKey);
+    out.jwt = {
+      rfc7515: await verifyJwt(input.rfc7515, k1),
+      jwtIo: await verifyJwt(input.jwtIo, k2),
+      wrongKey: await verifyJwt(input.jwtIo, new TextEncoder().encode("your-256-bit-secreT")),
+      emptyKey: await verifyJwt(input.jwtIo, new Uint8Array(0)),
+      tamperedSignature: await verifyJwt(flip(input.jwtIo, input.jwtIo.length - 3), k2),
+      tamperedPayload: await verifyJwt(flip(input.jwtIo, 40), k2),
+      tamperedHeader: await verifyJwt(flip(input.jwtIo, 5), k2),
+      shortSignature: await verifyJwt(input.jwtIo.slice(0, -4), k2),
+      longSignature: await verifyJwt(input.jwtIo + "AAAA", k2),
+      noSignature: await verifyJwt(input.jwtIo.slice(0, input.jwtIo.lastIndexOf(".") + 1), k2),
+      badBase64url: await verifyJwt(input.jwtIo.slice(0, -2) + "\\u0021\\u0021", k2),
+      badBase64urlLength: await verifyJwt(input.jwtIo.slice(0, -3), k2),
+    };
+    // Typed-array windows and ArrayBuffers as verify input, not only whole Uint8Arrays.
+    const key = await hmacKey(k2, "SHA-256", ["verify"]);
+    const signingInput = new TextEncoder().encode(input.jwtIo.slice(0, input.jwtIo.lastIndexOf(".")));
+    const sig = b64urlBytes(sigOf(input.jwtIo));
+    const padded = new Uint8Array(signingInput.length + 7);
+    padded.set(signingInput, 3);
+    const sigPadded = new Uint8Array(sig.length + 5);
+    sigPadded.set(sig, 2);
+    out.views = {
+      arrayBuffer: await crypto.subtle.verify("HMAC", key, sig.buffer, signingInput.buffer),
+      window: await crypto.subtle.verify("HMAC", key, sigPadded.subarray(2, 34), padded.subarray(3, 3 + signingInput.length)),
+      wrongWindow: await crypto.subtle.verify("HMAC", key, sigPadded.subarray(1, 33), padded.subarray(3, 3 + signingInput.length)),
+      string: await crypto.subtle.verify("HMAC", key, sig, input.jwtIo.slice(0, input.jwtIo.lastIndexOf("."))),
+    };
+    out.keyInfo = { type: key.type, extractable: key.extractable, usages: key.usages, algorithm: key.algorithm };
+    return Response.json(out);
+  },
+};`;
+
+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 codes = (s: string): number[] => Array.from(s, (c) => c.charCodeAt(0));
+const expectedAtob = (s: string): number[] | string => {
+  try {
+    return codes(atob(s));
+  } catch (e) {
+    return e instanceof Error ? e.name : "unknown";
+  }
+};
+const expected = {
+  atob: atobInputs.map(expectedAtob),
+  atobWide: atobInputs.slice(0, 12).map((s) => expectedAtob(s)),
+  encode: encodeInputs.map((s) => Array.from(new TextEncoder().encode(s))),
+  encodeWide: encodeInputs.slice(0, 12).map((s) => Array.from(new TextEncoder().encode(s))),
+  hmac: hmacCases.map((c) => ({
+    mac: hexOf(createHmac(nodeHash(c.hash), Buffer.from(c.key)).update(Buffer.from(c.data)).digest()),
+    ok: true,
+    bad: false,
+  })),
+  rfc4231: rfc4231.map((v) => v.mac),
+  jwt: {
+    rfc7515: true,
+    jwtIo: true,
+    wrongKey: false,
+    emptyKey: false,
+    tamperedSignature: false,
+    tamperedPayload: false,
+    tamperedHeader: false,
+    shortSignature: false,
+    longSignature: false,
+    noSignature: false,
+    badBase64url: "bad-base64:InvalidCharacterError",
+    badBase64urlLength: false,
+  },
+  views: { arrayBuffer: true, window: true, wrongWindow: false, string: true },
+  keyInfo: {
+    type: "secret",
+    extractable: false,
+    usages: ["verify"],
+    algorithm: { name: "HMAC", hash: { name: "SHA-256" }, length: 152 },
+  },
+};
+// The published vectors must hold in Bun too, or the test itself is wrong.
+for (const v of rfc4231)
+  assert.equal(
+    hexOf(createHmac("sha256", Buffer.from(v.key, "hex")).update(Buffer.from(v.data, "hex")).digest()),
+    v.mac,
+  );
+assert.equal(
+  toB64Url(
+    createHmac("sha256", Buffer.from(rfc7515Key, "base64url"))
+      .update(rfc7515.slice(0, rfc7515.lastIndexOf(".")))
+      .digest(),
+  ),
+  rfc7515.slice(rfc7515.lastIndexOf(".") + 1),
+);
+assert.equal(
+  toB64Url(
+    createHmac("sha256", jwtIoKey)
+      .update(jwtIo.slice(0, jwtIo.lastIndexOf(".")))
+      .digest(),
+  ),
+  jwtIo.slice(jwtIo.lastIndexOf(".") + 1),
+);
+
+const workdir = await mkdtemp(join(tmpdir(), "sb-native-jwt-"));
+let server: ReturnType<typeof Bun.spawn> | undefined;
+try {
+  const porffor = await ensurePorffor();
+  const node = Bun.which("node");
+  if (!node) throw new Error("native jwt 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, "jwt.generated.js");
+  const binary = join(workdir, "jwt-native");
+  await writeFile(generated, wrapNativeFetchHandler(handler, prelude));
+
+  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 < 100; attempt++) {
+    try {
+      response = await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(20000) });
+      break;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  assert(response, "compiled jwt handler did not start");
+  assert.equal(response.status, 200);
+  const actual: typeof expected = await response.json();
+  assert.deepEqual(actual, expected);
+  console.log("Native JWT pieces (atob, TextEncoder, HMAC verify) match RFC 4231, RFC 7515, jwt.io and Bun");
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}