@sproutboat/runtime 0.34.1 → 0.34.3

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @sproutboat/runtime
 
+## 0.34.3
+
+### Patch Changes
+
+- 49ac7df: Faster `atob`: each character is looked up in a 128-entry table instead of `indexOf` over the alphabet, and the same pass validates, so the regex test over the whole input is gone. Same output and same `InvalidCharacterError` cases (checked against the platform `atob` on 9,000 random inputs and edge cases).
+  
+  A JWT check decodes three base64url parts. On one pinned x86 core at a fixed rate, CPU per request: like 854 to 761 us, create 922 to 866 us; feed and post reads do not call `atob`.
+- 745f94c: Faster D1 in standalone builds: a D1 call no longer goes through `JSON.stringify` and `JSON.parse` on both sides of the in-process dispatch. The request object is handed straight to the dispatcher and the reply object comes straight back (the C layer still returns its own JSON, parsed once). Same results, same error messages, no change under the broker transport.
+  
+  On one pinned x86 core at a fixed rate, CPU per request against a 500,000-row feed API: feed (20 rows) 1,418 to 1,133 us, post read 394 to 332 us, like 854 to 728 us, create 922 to 857 us, the realistic mix 670 to 580 us.
+- 88c7bff: Faster strict D1 queries in standalone builds (compatibility date 2026-10-24 and later): the rows of a result are built as JS arrays in C, straight from the SQLite cells, instead of being written as JSON text in C and parsed again in JS. NULL, numbers, text (UTF-8 decoded exactly as the JSON path decoded it, including invalid sequences), BLOBs (byte arrays) and empty results are unchanged. Only a small header (columns, changes, last row id) still goes through JSON. Older compatibility dates and non-D1 operations keep the JSON path.
+  
+  On one pinned x86 core at a fixed rate, CPU per request against a 500,000-row feed API, see the PR for numbers.
+
+## 0.34.2
+
+### Patch Changes
+
+- a0ba6a3: Faster requests: about 57% of a request's CPU was Porffor's `globalThis` getter.
+  
+  - **Toolchain, the root cause.** Porffor's `#get_globalThis` re-synced every top-level function and `var` of the module into the global object on every read, one hashed write per binding (about 20 µs with the prelude's ~120 bindings, so every `globalThis.x` in user code paid it too). Every binding is now written when the object is built, and a later read rewrites only the bindings whose value changed (a packed copy of the last value written is kept per binding: an unchanged binding costs one compare). 20,000 reads with 600 top-level functions: 9,300 ms before, a few ms after.
+  - **Runtime and toolchain, the request path.** The runtime's `globalThis.__sbCompat` / `globalThis.env` reads go through accessors over module-level `let`s that the app tail sets once, and `Request`/`Response` cache the class lookups and take the date and WebSocketPair state from statics the runtime sets. Until the tail has run (the shared template, unit tests) everything reads `globalThis` as before.
+  - **Client IP.** `request.cf` no longer reads and splits `SB_TRUSTED_PROXIES` four times a request: it is read once per process, and with no trusted proxy (the usual case) the peer is the client and the forwarded-header lookups are skipped.
+  - **`x-sb-cpu-ms`.** The stamp is appended to the handler's own Response instead of building a second Response with a copy of every header. The same responses are stamped, with the same headers and body.
+  
+  A 404 on one pinned x86 core, CPU per request when saturated, standalone: 319 µs before, 127 µs with the getter patch alone, 113 µs with the request-path change, 81 µs with the client-IP and stamp changes.
+
 ## 0.34.1
 
 ### Patch Changes

package/package.json

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

package/src/client-ip.test.js

@@ -17,7 +17,7 @@ const load = new Function(
   "__envMap",
   `${src.slice(start, end)}
    const __sbEnv = (k) => __envMap[k];
-   return { __sbNormalizeIp, __sbIpInCidr, __sbIpTrusted, __sbClientIp, __sbSplitList, __sbTrustedProxyHeader };`,
+   return { __sbNormalizeIp, __sbIpInCidr, __sbIpTrusted, __sbClientIp, __sbSplitList, __sbTrustedProxyHeader, __sbTrustedProxiesOnce };`,
 );
 const H = load(new Proxy({}, { get: (_, k) => env[k] }));
 
@@ -62,7 +62,9 @@ test("__sbClientIp: a trusted peer resolves the rightmost untrusted XFF hop", ()
 
 test("__sbClientIp: an untrusted peer cannot use XFF even if it sends one", () => {
   env = { SB_TRUSTED_PROXIES: "10.0.0.0/8" };
-  expect(H.__sbClientIp(req({ "x-sb-remote-addr": "198.51.100.9", "x-forwarded-for": "1.1.1.1" }))).toBe("198.51.100.9");
+  expect(H.__sbClientIp(req({ "x-sb-remote-addr": "198.51.100.9", "x-forwarded-for": "1.1.1.1" }))).toBe(
+    "198.51.100.9",
+  );
 });
 
 test("__sbTrustedProxyHeader: no trusted proxies configured means the header is ignored", () => {
@@ -83,3 +85,10 @@ test("__sbTrustedProxyHeader: a trusted peer's value passes through, absent stay
   expect(H.__sbTrustedProxyHeader(r, "x-sb-http-protocol")).toBe("HTTP/2");
   expect(H.__sbTrustedProxyHeader(r, "x-sb-tls-cipher")).toBeUndefined();
 });
+
+test("__sbTrustedProxiesOnce reads SB_TRUSTED_PROXIES once and keeps the list", () => {
+  env = { SB_TRUSTED_PROXIES: "10.0.0.0/8, 192.0.2.1" };
+  expect(H.__sbTrustedProxiesOnce()).toEqual(["10.0.0.0/8", "192.0.2.1"]);
+  env = { SB_TRUSTED_PROXIES: "198.51.100.0/24" };
+  expect(H.__sbTrustedProxiesOnce()).toEqual(["10.0.0.0/8", "192.0.2.1"]); // fixed for the process
+});

package/src/ingress-utf8.test.js

@@ -7,7 +7,7 @@ const rawBody = src.slice(src.indexOf("function __sbRawBody("), src.indexOf("fun
 if (!decoder || !ingress || !rawBody) throw new Error("Ingress decoder source not found");
 // oxlint-disable-next-line no-function-constructor -- Exercise the text-only runtime prelude.
 const load = new Function(
-  `// The C fast paths (Porffor.c) cannot run here: the stubs make the JS fallback run.\nfunction __sbFromUtf8Native() { return ""; }\nfunction __sbToBytesNative() { return ""; }\n${decoder}\n${rawBody}\n${ingress}\nreturn __sbDecodeIngress;`,
+  `// The C fast paths (Porffor.c) cannot run here: the stubs make the JS fallback run.\nfunction __sbFromUtf8Native() { return ""; }\nfunction __sbToBytesNative() { return ""; }\nfunction __sbCompatDate() { return undefined; }\n${decoder}\n${rawBody}\n${ingress}\nreturn __sbDecodeIngress;`,
 );
 const decode = load();
 const raw = (text) => Array.from(new TextEncoder().encode(text), (byte) => String.fromCharCode(byte)).join("");

package/src/native-fetch-prelude.js

@@ -1,3 +1,24 @@
+// Reads of globalThis are expensive in Porffor (the getter rebuilds the global object on each read);
+// the app tail (wrap.ts) sets these two once. See sproutd/benchmarks/per-request-2026-10-26.
+let __sbCompatNow;
+let __sbEnvNow;
+function __sbCompatDate() {
+  return __sbCompatNow === undefined ? globalThis.__sbCompat : __sbCompatNow;
+}
+function __sbEnvValue() {
+  return __sbEnvNow === undefined ? globalThis.env : __sbEnvNow;
+}
+// Setters, not bare assignments in the tail: the template and every app must compile the prelude identically.
+function __sbSetCompat(date) {
+  __sbCompatNow = date;
+  Request._cd = date;
+}
+function __sbSetEnv(value) {
+  __sbEnvNow = value;
+}
+// Referenced, so the shared template keeps them: an app tail can only call what the template compiled.
+globalThis.__sbSetCompat = __sbSetCompat;
+globalThis.__sbSetEnv = __sbSetEnv;
 // WEB STREAMS: generated by gen-streams.ts, do not edit.
 /* oxlint-disable -- generated third-party implementation */
 // web-streams-polyfill 4.3.0, MIT, copyright Mattias Buelens (see WEB_STREAMS_LICENSE)
@@ -3095,17 +3116,25 @@ function __sbCpuMs() {
 function __sbTagCpu(res, t0) {
   const cpu = __sbCpuMs() - t0;
   try {
-    const body = __sbRawBody(res);
-    if (__sbIsStr(body) && !res.headers.has("set-cookie")) {
-      const headers = {};
-      res.headers.forEach(function (value, name) {
-        headers[name] = value;
-      });
-      headers["x-sb-cpu-ms"] = (cpu >= 0 ? cpu : 0).toFixed(3);
-      return new Response(body, { status: res.status, headers: headers });
+    // A string body and no Set-Cookie, as before. The native writer reads Headers' flat `_entries`,
+    // so the stamp is appended to the handler's own Response instead of building a second one (a
+    // Headers, a body extraction and a status check, plus a copy of every header); an x-sb-cpu-ms
+    // the handler set itself is replaced by the measured one, as before.
+    const headers = res && res.headers;
+    if (headers && __sbIsStr(__sbRawBody(res)) && !headers.has("set-cookie")) {
+      const stamp = (cpu >= 0 ? cpu : 0).toFixed(3);
+      const entries = headers._entries;
+      let set = false;
+      for (let i = 0; i < entries.length; i += 2) {
+        if (entries[i] === "x-sb-cpu-ms") {
+          entries[i + 1] = stamp;
+          set = true;
+        }
+      }
+      if (!set) headers._push("x-sb-cpu-ms", stamp);
     }
   } catch {
-    /* fall through to the original response */
+    /* the handler's Response goes out unstamped */
   }
   return res;
 }
@@ -3323,7 +3352,7 @@ if (Headers.prototype[Symbol.iterator] == null) Headers.prototype[Symbol.iterato
 // and delete with a TypeError. A copy (new Headers(h), new Response(body, res)) is
 // mutable. The runtime's own writes after the handler lift the guard first.
 function __sbFreezeHeaders(message) {
-  if (globalThis.__sbCompat >= "2026-10-23") message.headers._immutable = true;
+  if (__sbCompatDate() >= "2026-10-23") message.headers._immutable = true;
   return message;
 }
 
@@ -3610,16 +3639,24 @@ if (globalThis.crypto.getRandomValues == null) {
   // so a string held as UTF-16 (one from JSON.parse or TextDecoder, say) decoded to the
   // wrong bytes, and btoa encoded its UTF-16 units.
   const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  // Sextet per character code (255 = not base64): a table read rather than an indexOf over the
+  // alphabet, and one pass that also validates, so no regex test over the whole input.
+  const sextet = [];
+  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, "");
     if (text.length % 4 === 0) text = text.replace(/==?$/, "");
-    if (text.length % 4 === 1 || !/^[A-Za-z0-9+/]*$/.test(text)) throw invalidCharacter("atob: the string is not valid base64");
+    if (text.length % 4 === 1) throw invalidCharacter("atob: the string is not valid base64");
     const parts = [];
     let chunk = "";
     let bits = 0;
     let count = 0;
     for (let i = 0; i < text.length; i++) {
-      bits = (bits << 6) | alphabet.indexOf(text[i]);
+      const code = text.charCodeAt(i);
+      const value = code < 128 ? sextet[code] : 255;
+      if (value === 255) throw invalidCharacter("atob: the string is not valid base64");
+      bits = (bits << 6) | value;
       count += 6;
       if (count >= 8) {
         count -= 8;
@@ -3752,7 +3789,7 @@ if (typeof globalThis.EventTarget !== "function") {
       if (this.aborted) return;
       this.aborted = true;
       // workerd's default reason reads "The operation was aborted" (from 2026-10-23 here).
-      const message = globalThis.__sbCompat >= "2026-10-23" ? "The operation was aborted" : "This operation was aborted";
+      const message = __sbCompatDate() >= "2026-10-23" ? "The operation was aborted" : "This operation was aborted";
       this.reason = reason === undefined ? namedError("AbortError", message) : reason;
       const event = new Event("abort");
       if (typeof this.onabort === "function") this.onabort.call(this, event);
@@ -5007,7 +5044,7 @@ function __sbRpc(op, extra) {
 // pages with limit and cursor and returns each key's expiration and metadata. Earlier
 // dates keep the synchronous shim below.
 function __sbKvStrict() {
-  return globalThis.__sbCompat >= "2026-10-25";
+  return __sbCompatDate() >= "2026-10-25";
 }
 function __sbKvKey(key, verb) {
   const name = String(key);
@@ -5131,7 +5168,7 @@ function __sbMakeKv(ns) {
 // are enforced, errors read "D1_ERROR: ...", and a BLOB comes back as an array of
 // byte values. Earlier dates keep the old behaviour.
 function __sbD1Strict() {
-  return globalThis.__sbCompat >= "2026-10-24";
+  return __sbCompatDate() >= "2026-10-24";
 }
 function __sbD1Param(value, strict) {
   if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
@@ -5144,11 +5181,30 @@ function __sbD1Param(value, strict) {
   // oxlint-disable-next-line anti-slop/no-runtime-typeof -- workerd's D1_TYPE_ERROR names the value's typeof
   throw new Error("D1_TYPE_ERROR: Type '" + typeof value + "' not supported for value '" + String(value) + "'");
 }
+// An embedded (standalone) build sets this to hand the request object straight to its
+// dispatcher. D1 replies are the biggest ones a handler sees (20 rows is 100 cells), and
+// the JSON.stringify and JSON.parse around the in-process call cost more than SQLite did.
+// The broker transport leaves it unset and keeps the string hop. (No initializer: the transport is placed ahead of the prelude, and `= null` would run after its assignment.)
+// oxlint-disable-next-line no-unassigned-vars -- the embedded transport assigns it; the broker transport does not.
+var __sbCallDirect;
+function __sbRpcDirect(op, extra) {
+  if (!__sbCallDirect) return __sbRpc(op, extra);
+  const req = { v: 1, id: ++__sbReqId, op };
+  if (extra) for (const k in extra) req[k] = extra[k];
+  let reply;
+  try {
+    reply = __sbCallDirect(req);
+  } catch (err) {
+    throw new Error(`sproutboat ${op}: ${String((err && err.message) || err) || "failed"}`);
+  }
+  if (reply && reply.ok === false) throw new Error(`sproutboat ${op}: ${reply.error || "failed"}`);
+  return reply;
+}
 function __sbD1Rpc(op, extra, strict) {
-  if (!strict) return __sbRpc(op, extra);
+  if (!strict) return __sbRpcDirect(op, extra);
   extra.strict = true;
   try {
-    return __sbRpc(op, extra);
+    return __sbRpcDirect(op, extra);
   } catch (err) {
     // "sproutboat d1.query: D1_ERROR: ..." -> "D1_ERROR: ...", as workerd words it.
     const message = String((err && err.message) || err);
@@ -5211,7 +5267,8 @@ function __sbD1Meta(meta, started) {
 }
 // Columns and rows of a strict reply (an older broker answers with objects only).
 function __sbD1Table(r) {
-  if (r.columns) return { columns: r.columns, rows: __sbD1Rows(r) };
+  // rows built in C (r.native) already hold BLOBs as byte arrays
+  if (r.columns) return { columns: r.columns, rows: r.native === true ? r.rows : __sbD1Rows(r) };
   const objects = r.results || [];
   const columns = objects.length ? Object.keys(objects[0]) : [];
   const rows = [];
@@ -5449,7 +5506,7 @@ function __sbR2Multipart(bucket, key, uploadId) {
 // cursor, groups by delimiter and returns metadata only when `include` asks for it.
 // Earlier dates keep the synchronous shim below.
 function __sbR2Strict() {
-  return globalThis.__sbCompat >= "2026-10-26";
+  return __sbCompatDate() >= "2026-10-26";
 }
 function __sbR2Key(key, verb) {
   const name = String(key);
@@ -5790,7 +5847,7 @@ function __sbAssetResponse(path, r) {
 // The queue name and consumer settings (bindings.queueConfig, from `queues` in
 // sproutboat.jsonc) apply at every date: they are opt-in.
 function __sbQueuesStrict() {
-  return globalThis.__sbCompat >= "2026-10-31";
+  return __sbCompatDate() >= "2026-10-31";
 }
 
 // binding -> { binding, queue, maxBatchSize?, maxBatchTimeout?, maxRetries?, retryDelay?, deadLetterQueue? }
@@ -6106,7 +6163,7 @@ globalThis.__sbInstallBindings = function (target, bindings) {
       sendBatch(messages, options) {
         // From 2026-10-28 sendBatch(messages, { delaySeconds }) delays every message that
         // sets none of its own, as on Workers; before, the batch option was ignored.
-        const batchDelay = globalThis.__sbCompat >= "2026-10-28" ? (options && options.delaySeconds) || 0 : 0;
+        const batchDelay = __sbCompatDate() >= "2026-10-28" ? (options && options.delaySeconds) || 0 : 0;
         const list = [];
         for (let j = 0; j < (messages || []).length; j++) {
           const m = messages[j];
@@ -6193,7 +6250,7 @@ globalThis.__sbInstallBindings = function (target, bindings) {
     const binding = bindings.services[i].binding;
     const fetcher = {
       fetch(input, init) {
-        if (globalThis.__sbCompat >= "2026-10-22") return __sbServiceFetch(binding, input, init);
+        if (__sbCompatDate() >= "2026-10-22") return __sbServiceFetch(binding, input, init);
         const parts = __sbFetchParts(input, init);
         const msg = { binding, url: parts.url, method: parts.method, headers: parts.headers, ...__sbPartsBody(parts) };
         return __sbUpstreamResponse(globalThis.__sbFetchUpstream("service.fetch", msg));
@@ -6383,7 +6440,7 @@ function __sbHandles(handlers, name) {
 // Callee: the receiver of one request. A default export that is a class (a
 // WorkerEntrypoint) is instantiated per request with its ctx and env, as in workerd.
 function __sbReceiver(handlers, ctx) {
-  return __sbIsFn(handlers) ? new handlers(ctx, globalThis.env) : handlers;
+  return __sbIsFn(handlers) ? new handlers(ctx, __sbEnvValue()) : handlers;
 }
 
 // Callee: runs RPC method `method` of `receiver` with the arguments in the request body.
@@ -6412,7 +6469,7 @@ async function __sbRpcDispatch(handlers, receiver, method, request) {
 // throws), a Request given as init brings its body, GET and HEAD refuse a body, and the
 // method and redirect mode are checked. Before it, the parts are read off the input.
 function __sbFetchParts(input, init) {
-  if (globalThis.__sbCompat >= "2026-10-23") {
+  if (__sbCompatDate() >= "2026-10-23") {
     const request = new Request(input, init);
     const headers = [];
     request.headers.forEach((v, k) => headers.push([k, v]));
@@ -6488,7 +6545,7 @@ function __sbUpstreamResponse(r) {
 function __sbStreamsBody(body) {
   return (
     body instanceof ReadableStream &&
-    globalThis.__sbCompat >= "2026-10-27" &&
+    __sbCompatDate() >= "2026-10-27" &&
     globalThis.__sbBodyStreamable != null &&
     globalThis.__sbBodyStreamable()
   );
@@ -6615,7 +6672,7 @@ function __sbFollowHop(op, msg, label, mode, signal, hops) {
   const step = (res) => {
     const location = res.headers.get("location");
     const redirect = res.status === 301 || res.status === 302 || res.status === 303 || res.status === 307 || res.status === 308;
-    if (!(globalThis.__sbCompat >= "2026-10-22") || mode === "manual" || !redirect || location == null) return res;
+    if (!(__sbCompatDate() >= "2026-10-22") || mode === "manual" || !redirect || location == null) return res;
     if (mode === "error") throw new TypeError(label + ": redirect not allowed (redirect: \"error\")");
     if (hops >= 20) throw new TypeError(label + ": too many redirects");
     const dropped = __sbRawBody(res);
@@ -6652,9 +6709,9 @@ function __sbFollowHop(op, msg, label, mode, signal, hops) {
 // (__sbAsyncAtAnyDate). `always` is for RPC, which has no older behaviour to keep.
 function __sbUpstream(op, msg, label, signal, always) {
   if (signal) signal.throwIfAborted();
-  const promised = always || globalThis.__sbCompat >= "2026-10-22" || __sbAsyncAtAnyDate();
+  const promised = always || __sbCompatDate() >= "2026-10-22" || __sbAsyncAtAnyDate();
   if (!__sbHttpAsyncEnabled() || !promised) return __sbUpstreamResponse(globalThis.__sbFetchUpstream(op, msg));
-  if (globalThis.__sbCompat >= "2026-10-22") return __sbUpstreamStreamed(op, msg, label, signal);
+  if (__sbCompatDate() >= "2026-10-22") return __sbUpstreamStreamed(op, msg, label, signal);
   return new Promise((resolve, reject) => {
     let onAbort = null;
     const settled = () => {
@@ -6701,7 +6758,7 @@ globalThis.__sbInstallFetch = function () {
       parts = __sbFetchParts(input, init);
     } catch (error) {
       // From 2026-10-23 an invalid request rejects, as in workerd; before it, it threw.
-      if (globalThis.__sbCompat >= "2026-10-23") return Promise.reject(error);
+      if (__sbCompatDate() >= "2026-10-23") return Promise.reject(error);
       throw error;
     }
     if (__sbWsOutboundOn() && __sbWsIsUpgrade(parts)) return __sbWsFetchUpgrade(parts);
@@ -6762,7 +6819,7 @@ function __sbMakeDONamespace(binding, className) {
           let req;
           // From 2026-10-23 the object gets the Request Fetch makes of input and init, as in
           // workerd: method, headers and body survive, and the input's body is used up.
-          if (globalThis.__sbCompat >= "2026-10-23") {
+          if (__sbCompatDate() >= "2026-10-23") {
             req = new Request(input, init);
           } else if (__sbIsObj(input) && __sbIsStr(input.url) && !init) {
             req = input;
@@ -6814,7 +6871,7 @@ function __sbMakeDONamespace(binding, className) {
 // The object runs in this sprout on every transport (see above), so an RPC call is a
 // direct call; only its storage goes to the broker.
 function __sbDOv2() {
-  return globalThis.__sbCompat >= "2026-10-29";
+  return __sbCompatDate() >= "2026-10-29";
 }
 
 function __sbDOSha(text) {
@@ -7060,7 +7117,7 @@ function __sbGetDOInstance(cls, idText, idObj) {
     // The hibernation API, from 2026-10-30 (where WebSocketPair exists).
     const holder = { inst: null, auto: null, cls, id, restored: [] };
     if (__sbWsEnabled()) __sbDOWebSocketState(state, holder);
-    inst = new Ctor(state, globalThis.env);
+    inst = new Ctor(state, __sbEnvValue());
     holder.inst = inst;
     inst.__sbTasks = __sbTasks;
     inst.__sbGate = gate;
@@ -7154,7 +7211,7 @@ function __sbDOStorage(cls, id) {
 // Values written in the new format start with __sbDOTag (no JSON text starts with "#"),
 // so either side reads both.
 function __sbDOGated() {
-  return globalThis.__sbCompat >= "2026-10-28";
+  return __sbCompatDate() >= "2026-10-28";
 }
 
 function __sbDOMakeGate() {
@@ -8436,7 +8493,7 @@ function __sbWsHostResponse(r) {
   }
   // The compatibility date goes along: a standalone or platform server carries client sockets
   // from 2026-11-01 only (sproutd, whose bridge ignores it, from 2026-10-30).
-  const id = Number(__sbWsOp("o", 0, globalThis.__sbCompat, 0));
+  const id = Number(__sbWsOp("o", 0, __sbCompatDate(), 0));
   if (!(id > 0)) return new Response("WebSockets are not supported by this host yet", { status: 501 });
   ws._host = id;
   if (ws._peer !== null && ws._peer._hib !== null && __sbWsHibOn()) __sbWsHibRegister(ws._peer, id);
@@ -8496,7 +8553,7 @@ function __sbWsPump(ws) {
 // described at __sbWsOp, ids with the top bit set. Returning that Response from a handler
 // relays the socket to the client through a pair.
 function __sbWsOutboundOn() {
-  return globalThis.__sbCompat >= "2026-11-01";
+  return __sbCompatDate() >= "2026-11-01";
 }
 let __sbWsWakeable = -1;
 function __sbWsCanWake() {
@@ -8783,7 +8840,7 @@ function __sbWsProxy(r, upstream) {
 // their tags and attachments) and the event is dispatched as webSocketMessage/webSocketClose.
 let __sbWsHibHost = -1;
 function __sbWsHibOn() {
-  if (globalThis.__sbCompat < "2026-11-01" || !__sbDOGated()) return false;
+  if (__sbCompatDate() < "2026-11-01" || !__sbDOGated()) return false;
   if (__sbWsHibHost < 0 && __sbWsOp("H", 0, "", 0) === "1") __sbWsHibHost = 1;
   return __sbWsHibHost === 1;
 }
@@ -8915,7 +8972,9 @@ function __sbWsRestoreSocket(id) {
 }
 
 function __sbInstallWebSockets() {
-  if (globalThis.__sbCompat < "2026-10-30") return;
+  Request._hasWsp = false;
+  if (__sbCompatDate() < "2026-10-30") return;
+  Request._hasWsp = true;
   globalThis.WebSocketPair = __SbWebSocketPair;
   globalThis.WebSocket = __SbWebSocket;
   globalThis.WebSocketRequestResponsePair = __SbWebSocketRequestResponsePair;
@@ -8978,7 +9037,7 @@ function __sbBindingCallIngress(request) {
   if (vouched) {
     const url = headers.get("x-sb-url");
     // The callee sees its caller's URL from compatibility date 2026-10-22, as in workerd.
-    if (url && URL.canParse(url) && globalThis.__sbCompat >= "2026-10-22") request.url = url;
+    if (url && URL.canParse(url) && __sbCompatDate() >= "2026-10-22") request.url = url;
     headers.delete("x-sb-remote-addr");
   }
   for (const name of ["x-sb-binding-call", "x-sb-url", "x-sb-edge-token"]) {
@@ -9078,7 +9137,7 @@ function __sbReqBodyOp(op, id, data) {
 // Turns streaming on in the native server, from 2026-10-27. Called once at startup, after
 // the compatibility date is set (__sbInstallFetch).
 function __sbIngressStreamingSetup() {
-  if (globalThis.__sbCompat >= "2026-10-27") __sbReqBodyOp("e", 0, "");
+  if (__sbCompatDate() >= "2026-10-27") __sbReqBodyOp("e", 0, "");
 }
 
 // request.body for a streamed request: chunks as the server receives them.
@@ -9155,7 +9214,7 @@ function __sbIngressStream(request, id) {
 // handing the request to user code. Request.text() in Porffor otherwise treats
 // the raw bytes as already-decoded characters and corrupts Unicode/HMAC input.
 function __sbDecodeIngress(request) {
-  const streamed = globalThis.__sbCompat >= "2026-10-27" ? Number(__sbReqBodyOp("t", 0, "")) : 0;
+  const streamed = __sbCompatDate() >= "2026-10-27" ? Number(__sbReqBodyOp("t", 0, "")) : 0;
   if (streamed > 0) {
     __sbIngressStream(request, streamed);
     return;
@@ -9164,7 +9223,7 @@ function __sbDecodeIngress(request) {
   if (raw == null) return;
   // A GET or HEAD has no body, as in workerd (from 2026-10-23): request.body is null, and
   // new Request(request) copies none. Before it, the body is the empty string.
-  if (raw === "" && (request.method === "GET" || request.method === "HEAD") && globalThis.__sbCompat >= "2026-10-23") {
+  if (raw === "" && (request.method === "GET" || request.method === "HEAD") && __sbCompatDate() >= "2026-10-23") {
     request.body = null;
     return;
   }
@@ -9181,6 +9240,14 @@ function __sbDecodeIngress(request) {
   };
 }
 
+// SB_TRUSTED_PROXIES is fixed for the life of a process (a sproutd worker gets its own after the fork,
+// and this runs per request, never before it), so it is read and split once, not four times a request.
+let __sbTrustedCache;
+function __sbTrustedProxiesOnce() {
+  if (__sbTrustedCache === undefined) __sbTrustedCache = __sbSplitList(__sbEnv("SB_TRUSTED_PROXIES"));
+  return __sbTrustedCache;
+}
+
 globalThis.__sbEntry = function (handlers, request) {
   __sbDecodeIngress(request);
   const trigger = request.headers.get("x-sb-trigger");
@@ -9191,13 +9258,18 @@ globalThis.__sbEntry = function (handlers, request) {
     // are only set when a trusted front proxy forwarded them; colo, ASN and
     // geo fields stay absent everywhere (#128 explicitly rejects faking them).
     const __cf = request.cf || {};
-    __cf.clientIp = __sbClientIp(request);
-    const __httpProtocol = __sbTrustedProxyHeader(request, "x-sb-http-protocol");
-    if (__httpProtocol) __cf.httpProtocol = __httpProtocol;
-    const __tlsVersion = __sbTrustedProxyHeader(request, "x-sb-tls-version");
-    if (__tlsVersion) __cf.tlsVersion = __tlsVersion;
-    const __tlsCipher = __sbTrustedProxyHeader(request, "x-sb-tls-cipher");
-    if (__tlsCipher) __cf.tlsCipher = __tlsCipher;
+    if (__sbTrustedProxiesOnce().length === 0) {
+      // No trusted proxy (the usual case): the peer is the client and no forwarded header counts.
+      __cf.clientIp = __sbNormalizeIp(request.headers.get("x-sb-remote-addr") || "");
+    } else {
+      __cf.clientIp = __sbClientIp(request);
+      const __httpProtocol = __sbTrustedProxyHeader(request, "x-sb-http-protocol");
+      if (__httpProtocol) __cf.httpProtocol = __httpProtocol;
+      const __tlsVersion = __sbTrustedProxyHeader(request, "x-sb-tls-version");
+      if (__tlsVersion) __cf.tlsVersion = __tlsVersion;
+      const __tlsCipher = __sbTrustedProxyHeader(request, "x-sb-tls-cipher");
+      if (__tlsCipher) __cf.tlsCipher = __tlsCipher;
+    }
     request.cf = __cf;
     // The edge's headers are gone: from 2026-10-23 the handler cannot change the rest.
     __sbFreezeHeaders(request);
@@ -9227,8 +9299,8 @@ globalThis.__sbEntry = function (handlers, request) {
       if (rpc == null && !__sbHandles(handlers, "fetch")) throw new Error("Handler does not export a fetch() function.");
       __res = rpc != null
         ? __sbRpcDispatch(handlers, receiver, rpc, request)
-        : globalThis.__sbCompat >= "2026-09-28"
-          ? receiver.fetch(request, globalThis.env, ctx)
+        : __sbCompatDate() >= "2026-09-28"
+          ? receiver.fetch(request, __sbEnvValue(), ctx)
           : receiver.fetch(request, ctx);
     } catch (error) {
       // #179 — a synchronous throw anywhere in the handler must not take the
@@ -9260,8 +9332,8 @@ globalThis.__sbEntry = function (handlers, request) {
     try {
       const event = { cron: body.cron || "", scheduledTime: body.scheduledTime || Date.now(), noRetry() {} };
       const receiver = __sbReceiver(handlers, ctx);
-      __sres = globalThis.__sbCompat >= "2026-09-28"
-        ? receiver.scheduled(event, globalThis.env, ctx)
+      __sres = __sbCompatDate() >= "2026-09-28"
+        ? receiver.scheduled(event, __sbEnvValue(), ctx)
         : receiver.scheduled(event, ctx);
     } catch (error) {
       // #179 — same rule as fetch: don't let a throw here crash the process.
@@ -9389,8 +9461,8 @@ async function __sbRunQueueBatch(handlers, body, ctx) {
     };
   }
   try {
-    const __qres = globalThis.__sbCompat >= "2026-09-28"
-      ? handlers.queue(batch, globalThis.env, ctx)
+    const __qres = __sbCompatDate() >= "2026-09-28"
+      ? handlers.queue(batch, __sbEnvValue(), ctx)
       : handlers.queue(batch, ctx);
     // Was fire-and-forget: an async `queue()` had this default-ack pass run (and
     // the response go out) before its own `await`s did, so any ack()/retry()

package/src/transport-embedded.js

@@ -1352,6 +1352,43 @@ static void sb_putjson(sb_buf* b, const char* s, size_t n) {
 // doesn't start a valid sequence passes through as \u00XX, the same rule as
 // the prelude's __sbFromUtf8. Raw byte producers (the HTTP client's body,
 // BLOB columns) keep sb_putjson.
+// The UTF-16 units sb_putjson_text would write as u-escapes, for a TEXT cell handed over as
+// a JS string: same validity rules (an invalid lead byte is its own unit, an overlong form, a
+// surrogate or a value above U+10FFFF is not decoded). OUT has room for n units. *wide is set
+// when a unit is above 0xff.
+static size_t sb_text_units(const unsigned char* s, size_t n, uint16_t* out, int* wide) {
+  size_t k = 0;
+  *wide = 0;
+  for (size_t i = 0; i < n; i++) {
+    unsigned char c = s[i];
+    if (c < 0x80) { out[k++] = c; continue; }
+    unsigned int cp = 0, min = 0;
+    size_t len = 0;
+    if ((c & 0xe0) == 0xc0) { cp = c & 0x1f; len = 2; min = 0x80; }
+    else if ((c & 0xf0) == 0xe0) { cp = c & 0x0f; len = 3; min = 0x800; }
+    else if ((c & 0xf8) == 0xf0) { cp = c & 0x07; len = 4; min = 0x10000; }
+    int ok = len > 0 && i + len <= n;
+    for (size_t j = 1; ok && j < len; j++) {
+      unsigned char cc = s[i + j];
+      if ((cc & 0xc0) != 0x80) ok = 0;
+      else cp = (cp << 6) | (cc & 0x3f);
+    }
+    if (ok && (cp < min || cp > 0x10ffff || (cp >= 0xd800 && cp <= 0xdfff))) ok = 0;
+    if (!ok) { out[k++] = c; if (c > 0xff) *wide = 1; continue; }
+    if (cp >= 0x10000) {
+      cp -= 0x10000;
+      out[k++] = (uint16_t)(0xd800 + (cp >> 10));
+      out[k++] = (uint16_t)(0xdc00 + (cp & 0x3ff));
+      *wide = 1;
+    } else {
+      out[k++] = (uint16_t)cp;
+      if (cp > 0xff) *wide = 1;
+    }
+    i += len - 1;
+  }
+  return k;
+}
+
 static void sb_putjson_text(sb_buf* b, const char* s, size_t n) {
   sb_put(b, "\"", 1);
   for (size_t i = 0; i < n; i++) {
@@ -2122,7 +2159,29 @@ static char* sb_sql_error(sqlite3* db, const char* message, int code, int skip)
 //   {"ok":true,"cols":[...],"rows":[[...]],"changes":n,"rowid":n}
 // or {"ok":false,"error":"...","code":n,"offset":n}. In a D1 database (a path under
 // /d1/) a BLOB comes back as {"$blob":"HEX"}; elsewhere as one char per byte.
-static char* sb_sql_run(const char* path, const char* sql, const char* params) {
+// 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;
+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;
+}
+static sb_cell* sb_cells_add(sb_cells* cs) {
+  if (cs->n == cs->cap) {
+    size_t cap = cs->cap ? cs->cap * 2 : 64;
+    sb_cell* grown = (sb_cell*)realloc(cs->c, cap * sizeof(sb_cell));
+    if (!grown) return 0;
+    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;
+  return cell;
+}
+static char* sb_sql_run_x(const char* path, const char* sql, const char* params, sb_cells* cells) {
   sb_buf b = { 0, 0, 0 };
   int idx = sb_db_for(path);
   if (idx < 0 && sb_db_capture_failed(path)) return sb_sql_error(0, SB_LTX_FAILED, 10, 0);
@@ -2151,8 +2210,30 @@ static char* sb_sql_run(const char* path, const char* sql, const char* params) {
     sb_putjson_text(&b, name ? name : "", name ? strlen(name) : 0);
   }
   sb_puts(&b, "],\"rows\":[");
+  // Cells only for a strict D1 statement: its BLOBs are byte arrays either way.
+  const int native = cells && strict && d1;
+  if (native) { cells->ncol = ncol; cells->used = 1; }
   int rc, first = 1;
   while ((rc = sqlite3_step(st)) == SB_SQLITE_ROW) {
+    if (native) {
+      for (int i = 0; i < ncol; i++) {
+        sb_cell* cell = sb_cells_add(cells);
+        if (!cell) { cells->used = -1; break; }
+        int t = sqlite3_column_type(st, i);
+        if (t == 5) continue;
+        if (t == 1 || t == 2) { cell->t = 1; cell->d = sqlite3_column_double(st, i); continue; }
+        const unsigned char* txt = t == 4 ? (const unsigned char*)sqlite3_column_blob(st, i) : sqlite3_column_text(st, i);
+        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;
+      }
+      if (cells->used < 0) break;
+      continue;
+    }
     if (!first) sb_puts(&b, ",");
     first = 0;
     sb_puts(&b, "[");
@@ -2188,6 +2269,7 @@ static char* sb_sql_run(const char* path, const char* sql, const char* params) {
   // Reset, don't finalize: the statement stays compiled in sb_stmt_cache. Reset
   // now (not just on next reuse) so a SELECT stops holding its read transaction.
   sqlite3_reset(st);
+  if (cells && cells->used < 0) { free(b.p); sb_cells_free(cells); return sb_sql_error(db, "out of memory", 7, 0); }
   // The statement's own error, kept before LTX capture runs: capture executes statements
   // of its own, after which SQLite reports "not an error".
   char failure[512] = { 0 };
@@ -2200,11 +2282,15 @@ static char* sb_sql_run(const char* path, const char* sql, const char* params) {
   if (capture_failed) rc = 10;
   if (rc != SB_SQLITE_DONE && rc != SB_SQLITE_ROW) {
     free(b.p);
+    if (cells) sb_cells_free(cells);
     if (capture_failed) return sb_sql_error(db, SB_LTX_FAILED, 10, 0);
     return sb_sql_error(db, failure, failure_code, 0);
   }
   return b.p;
 }
+static char* sb_sql_run(const char* path, const char* sql, const char* params) {
+  return sb_sql_run_x(path, sql, params, 0);
+}
 
 // The storage quota (docs: an app's data directory is capped): bytes in regular files under
 // dir, symlinks not followed. Bounded by depth; an unreadable entry counts as 0.
@@ -4131,6 +4217,85 @@ function __sbSqlRaw(path, sql, paramsJson) {
   return res;
 }
 
+// One strict D1 statement: [header JSON, rows]. The header is {"ok":true,"cols":[...],"changes":n,
+// "rowid":n} (or the error reply) and rows is an array of row arrays built here from the
+// cells, BLOBs as byte arrays, so no JSON for the rows is written or parsed. rows is
+// undefined when the reply is not a result.
+// oxlint-disable-next-line no-unused-vars -- read inside the RawC block below, not by JS.
+function __sbSqlRowsRaw(path, sql, paramsJson) {
+  let res = "";
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    const char* __p; size_t __pl; char* __po = 0;
+    porf_native_fetch_read_value(path, &__p, &__pl, &__po);
+    char* __path = (char*)malloc(__pl + 1); memcpy(__path, __p, __pl); __path[__pl] = 0;
+    if (__po) free(__po);
+
+    const char* __s; size_t __sl; char* __so = 0;
+    porf_native_fetch_read_value(sql, &__s, &__sl, &__so);
+    char* __sql = (char*)malloc(__sl + 1); memcpy(__sql, __s, __sl); __sql[__sl] = 0;
+    if (__so) free(__so);
+
+    const char* __a; size_t __al; char* __ao = 0;
+    porf_native_fetch_read_value(paramsJson, &__a, &__al, &__ao);
+    char* __args = (char*)malloc(__al + 1); memcpy(__args, __a, __al); __args[__al] = 0;
+    if (__ao) free(__ao);
+
+    sb_cells __cells = { 0, 0, 0, 0, 0 };
+    char* __out = sb_sql_run_x(__path, __sql, __args, &__cells);
+    free(__path); free(__sql); free(__args);
+    const u32 __pair = porf_arr_new(2, 2);
+    res = porf_box((f64)__pair, 72);
+    if (!__out) __out = strdup("{\"ok\":false,\"error\":\"no result\"}");
+    porf_arr_set(__pair, 0, porf_box((f64)porf_native_fetch_alloc_bytestring(__out, strlen(__out)), 195));
+    free(__out);
+    if (__cells.used == 1) {
+      const size_t __ncol = (size_t)__cells.ncol;
+      const size_t __nrow = __ncol ? __cells.n / __ncol : 0;
+      const u32 __rows = porf_arr_new(0, (i32)(__nrow ? __nrow : 1));
+      porf_arr_set(__pair, 1, porf_box((f64)__rows, 72));
+      for (size_t __r = 0; __r < __nrow; __r++) {
+        const u32 __row = porf_arr_new((i32)__ncol, (i32)__ncol);
+        porf_arr_set(__rows, (u32)__r, porf_box((f64)__row, 72));
+        for (size_t __c = 0; __c < __ncol; __c++) {
+          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) {
+            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);
+              if (__wide) {
+                const u32 __str = porf_native_fetch_alloc((u32)(4 + __k * 2), 67);
+                *(u32*)(MEM + __str) = (u32)__k;
+                memcpy(MEM + __str + 4, __u, __k * 2);
+                __v = porf_box((f64)__str, 67);
+              } else {
+                unsigned char* __b = (unsigned char*)malloc(__k + 1);
+                if (__b) {
+                  for (size_t __i = 0; __i < __k; __i++) __b[__i] = (unsigned char)__u[__i];
+                  __v = porf_box((f64)porf_native_fetch_alloc_bytestring((const char*)__b, __k), 195);
+                  free(__b);
+                }
+              }
+              free(__u);
+            }
+          } 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]));
+            __v = porf_box((f64)__bytes, 72);
+          }
+          porf_arr_set(__row, (u32)__c, __v);
+        }
+      }
+    }
+    sb_cells_free(&__cells);
+  `;
+  return res;
+}
+
 // --- the op dispatch, in JS -------------------------------------------------
 // Deliberately the same SQL and the same partition keys as broker.ts. When one
 // changes the other has to, and the conformance suite is what says so.
@@ -4621,7 +4786,7 @@ function __sbEmbeddedDispatch(msg) {
     __sbD1Quota(path);
     if (op === "d1.batch") return { ok: true, results: __sbD1Batch(path, msg.statements || [], strict) };
     const one = __sbD1Run(path, msg.sql, msg.params, strict);
-    return { ok: true, results: one.results, columns: one.columns, rows: one.rows, meta: one.meta, success: true };
+    return { ok: true, results: one.results, columns: one.columns, rows: one.rows, native: one.native, meta: one.meta, success: true };
   }
 
   // Durable Objects storage.sql (compatibility date 2026-10-29): one database per object,
@@ -5168,6 +5333,14 @@ function __sbD1Bytes(cell) {
   return out;
 }
 function __sbD1Run(path, sql, params, strict) {
+  if (strict) {
+    // Rows come back as arrays, built in C (see __sbSqlRowsRaw); the header is small JSON.
+    const pair = __sbSqlRowsRaw(path, "/*sb-d1-strict*/" + String(sql), JSON.stringify(params || []));
+    const head = JSON.parse(pair[0]);
+    if (head.ok === false) throw __sbD1Error(head);
+    const rows = pair[1];
+    return { columns: head.cols, rows, native: true, meta: { changes: head.changes, last_row_id: head.rowid, rows_read: rows.length } };
+  }
   const r = JSON.parse(__sbSqlRaw(path, (strict ? "/*sb-d1-strict*/" : "") + String(sql), JSON.stringify(params || [])));
   if (r.ok === false) throw strict ? __sbD1Error(r) : new Error("sqlite: " + r.error);
   const meta = { changes: r.changes, last_row_id: r.rowid, rows_read: r.rows.length };
@@ -5323,7 +5496,7 @@ function __sbLtxConfigure() {
 }
 
 function __sbCall(reqJson) {
-  if (globalThis.__sbCompat >= "2026-10-22") __sbLtxConfigure();
+  if (__sbCompatDate() >= "2026-10-22") __sbLtxConfigure();
   try {
     return JSON.stringify(__sbEmbeddedDispatch(JSON.parse(reqJson)));
   } catch (err) {
@@ -5331,6 +5504,12 @@ function __sbCall(reqJson) {
   }
 }
 
+// The same dispatch without the JSON text either side: D1 calls take this (see __sbRpcDirect).
+__sbCallDirect = function (req) {
+  if (__sbCompatDate() >= "2026-10-22") __sbLtxConfigure();
+  return __sbEmbeddedDispatch(req);
+};
+
 // --- local triggers ---------------------------------------------------------
 // A deployed sprout is driven by the broker: it POSTs x-sb-trigger for cron
 // ticks, queue batches and DO alarms. An embedded binary has no broker, so the
@@ -5710,8 +5889,8 @@ globalThis.__sbStartLocalTriggers = function (handlers, bindings) {
           try {
             const receiver = __sbReceiver(handlers, ctx);
             const event = { cron: crons[i], scheduledTime: now.getTime(), noRetry() {} };
-            const res = globalThis.__sbCompat >= "2026-09-28"
-              ? receiver.scheduled(event, globalThis.env, ctx)
+            const res = __sbCompatDate() >= "2026-09-28"
+              ? receiver.scheduled(event, __sbEnvValue(), ctx)
               : receiver.scheduled(event, ctx);
             if (res && __sbIsFn(res.then)) await res;
           } catch (error) {

package/src/wrap.ts

@@ -234,7 +234,7 @@ export function wrapNativeFetchHandler(
     );
   }
 
-  const env = `const env = ${JSON.stringify(vars)};\nglobalThis.env = env;\n`;
+  const env = `const env = ${JSON.stringify(vars)};\nglobalThis.env = env;\n__sbSetEnv(env);\n`;
   const versionMetadataLine = versionMetadata
     ? `env[${JSON.stringify(versionMetadata.binding)}] = ${JSON.stringify({
         id: versionMetadata.id,
@@ -246,6 +246,7 @@ export function wrapNativeFetchHandler(
   // not be able to change the semantics it was compiled against at runtime.
   const compat =
     `globalThis.__sbCompat = ${JSON.stringify(compatibilityDate)};\n` +
+    `__sbSetCompat(${JSON.stringify(compatibilityDate)});\n` +
     // #15 — the embedded transport derives its default data directory from this.
     `globalThis.__sbAppName = ${JSON.stringify(appName)};\n` +
     (assets ? `globalThis.__sbAssets = ${JSON.stringify(assets)};\n` : "");

package/test/native-cpu-stamp.ts

@@ -0,0 +1,129 @@
+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";
+
+// The x-sb-cpu-ms stamp is added to the handler's own Response (it used to build a second one),
+// and request.cf's client IP skips the trusted-proxy work when no proxy is configured. What goes on
+// the wire must not change: which responses are stamped, the headers and the body, the client IP.
+const handler = `export default {fetch(request) {
+  const path = new URL(request.url).pathname;
+  if (path === "/text") return new Response("hello");
+  if (path === "/json") return new Response('{"a":1}', { status: 201, headers: { "content-type": "application/json", "x-a": "1" } });
+  if (path === "/bytes") return new Response(new Uint8Array([1, 2, 3]));
+  if (path === "/cookies") {
+    const h = new Headers(); h.append("set-cookie", "a=1"); h.append("set-cookie", "b=2");
+    return new Response("c", { headers: h });
+  }
+  if (path === "/own") return new Response("own", { headers: { "x-sb-cpu-ms": "mine" } });
+  if (path === "/ip") return new Response(JSON.stringify({ ip: request.cf.clientIp, proto: request.cf.httpProtocol ?? null }));
+  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;
+}
+
+const workdir = await mkdtemp(join(tmpdir(), "sb-native-cpu-stamp-"));
+const servers: ReturnType<typeof Bun.spawn>[] = [];
+async function start(binary: string, env: Record<string, string>): Promise<number> {
+  const port = freePort();
+  const server = Bun.spawn([binary], {
+    cwd: workdir,
+    env: { ...process.env, ...env, PORT: String(port) },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  servers.push(server);
+  for (let attempt = 0; attempt < 50; attempt++) {
+    try {
+      await fetch(`http://127.0.0.1:${port}/text`, { signal: AbortSignal.timeout(500) });
+      return port;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  throw new Error("compiled handler did not start");
+}
+try {
+  const porffor = await ensurePorffor();
+  const node = Bun.which("node");
+  if (!node) throw new Error("native cpu stamp 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, "stamp.generated.js");
+  const binary = join(workdir, "stamp-native");
+  await writeFile(generated, wrapNativeFetchHandler(handler, core.replace(TRANSPORT_MARKER, broker)));
+  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 = await start(binary, {});
+  const get = (path: string, headers: Record<string, string> = {}, p = port) =>
+    fetch(`http://127.0.0.1:${p}${path}`, { headers });
+
+  const text = await get("/text");
+  assert.equal(await text.text(), "hello");
+  assert.match(text.headers.get("x-sb-cpu-ms") ?? "", /^\d+\.\d{3}$/, "a string body is stamped");
+  assert.equal(text.headers.get("content-type"), "text/plain;charset=UTF-8");
+
+  const json = await get("/json");
+  assert.equal(json.status, 201);
+  assert.equal(await json.text(), '{"a":1}');
+  assert.equal(json.headers.get("x-a"), "1");
+  assert.equal(json.headers.get("content-type"), "application/json");
+  assert.match(json.headers.get("x-sb-cpu-ms") ?? "", /^\d+\.\d{3}$/);
+
+  const notFound = await get("/missing");
+  assert.equal(notFound.status, 404);
+  assert.match(notFound.headers.get("x-sb-cpu-ms") ?? "", /^\d+\.\d{3}$/);
+
+  const bytes = await get("/bytes");
+  assert.deepEqual([...new Uint8Array(await bytes.arrayBuffer())], [1, 2, 3]);
+  assert.equal(bytes.headers.get("x-sb-cpu-ms"), null, "a binary body is not stamped");
+
+  const cookies = await get("/cookies");
+  assert.equal(await cookies.text(), "c");
+  assert.deepEqual(cookies.headers.getSetCookie(), ["a=1", "b=2"]);
+  assert.equal(cookies.headers.get("x-sb-cpu-ms"), null, "a Set-Cookie response is not stamped");
+
+  const own = await get("/own");
+  assert.match(own.headers.get("x-sb-cpu-ms") ?? "", /^\d+\.\d{3}$/, "the measured value replaces a handler-set one");
+
+  for (let i = 0; i < 5; i++) assert.equal(await (await get("/text")).text(), "hello");
+
+  // No trusted proxy: the peer is the client, forwarded headers do not count.
+  const plain = await (await get("/ip", { "x-forwarded-for": "203.0.113.9", "x-sb-http-protocol": "h2" })).json();
+  assert.deepEqual(plain, { ip: "127.0.0.1", proto: null });
+  // The peer is a trusted proxy: the forwarded client and protocol count.
+  const proxied = await start(binary, { SB_TRUSTED_PROXIES: "127.0.0.1" });
+  const forwarded = await (
+    await get("/ip", { "x-forwarded-for": "203.0.113.9", "x-sb-http-protocol": "h2" }, proxied)
+  ).json();
+  assert.deepEqual(forwarded, { ip: "203.0.113.9", proto: "h2" });
+  console.log("Native x-sb-cpu-ms stamp and client IP: same responses on the wire, no second Response");
+} finally {
+  for (const server of servers) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}

package/test/native-d1.ts

@@ -51,6 +51,33 @@ int main(void) {
     char* params = strchr(sql, '\\t'); if (!params) return 2; *params++ = 0;
     if (!strncmp(line, ":db ", 4)) { int r = sql[0] == 'p' ? sb_db_page_size(line + 4) : sb_db_quota_freeze(line + 4, sql[0] == 'c' ? -1 : sql[0] == 'f'); printf("{\\"n\\":%d}\\n", r); fflush(stdout); continue; }
     if (!strncmp(line, ":bytes ", 7)) { line[strcspn(line, "\\t")] = 0; printf("{\\"n\\":%lld}\\n", sb_dir_bytes(line + 7, 0)); fflush(stdout); continue; }
+    // ":cells PATH": the same statement through sb_sql_run_x with cells, printed as JSON the test
+    // can compare with sb_sql_run's rows: TEXT as \\uXXXX units (sb_text_units), BLOB as {"$blob":hex}.
+    if (!strncmp(line, ":cells ", 7)) {
+      sb_cells cs = { 0, 0, 0, 0, 0 };
+      char* head = sb_sql_run_x(line + 7, sql, params, &cs);
+      printf("{\\"head\\":%s,\\"rows\\":[", head);
+      size_t nrow = cs.ncol ? cs.n / (size_t)cs.ncol : 0;
+      for (size_t r = 0; r < nrow; r++) {
+        printf(r ? ",[" : "[");
+        for (int c = 0; c < cs.ncol; c++) {
+          sb_cell* x = &cs.c[r * (size_t)cs.ncol + (size_t)c];
+          if (c) printf(",");
+          if (x->t == 0) printf("null");
+          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);
+            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("\\"}"); }
+        }
+        printf("]");
+      }
+      printf("]}\\n"); fflush(stdout); sb_cells_free(&cs); free(head); continue;
+    }
     // ":script PATH" runs SQL as a script (sb_sql_script, what exec() uses).
     char* out = !strncmp(line, ":script ", 8) ? sb_sql_script(line + 8, sql) : sb_sql_run(line, sql, params); puts(out); fflush(stdout); free(out);
   }
@@ -91,6 +118,59 @@ int main(void) {
   );
   assert.equal(other.rows[0][0], String(other.rows[0][0]), "outside D1 a BLOB is still one char per byte, not hex");
 
+  // Strict rows handed over as cells (the JS arrays are built from them in C) hold exactly what
+  // the JSON rows hold: NULL, integers, floats, ASCII, Latin-1, BMP and astral text, every kind
+  // of invalid UTF-8, a BLOB, and no rows at all.
+  const cellRun = (sql: string, params: unknown[] = []) => {
+    const input = `:cells ${d1}\t/*sb-d1-strict*/${sql}\t${JSON.stringify(params)}\n${d1}\t/*sb-d1-strict*/${sql}\t${JSON.stringify(params)}\n`;
+    const out = Bun.spawnSync([binary], { stdin: Buffer.from(input) });
+    assert.equal(out.exitCode, 0, out.stderr.toString());
+    const [cells, json] = out.stdout
+      .toString()
+      .trim()
+      .split("\n")
+      .map((l) => JSON.parse(l));
+    return { cells, json };
+  };
+  const bad = [
+    "x'80'",
+    "x'c0af'",
+    "x'c3'",
+    "x'e282'",
+    "x'f09f9880'",
+    "x'f0'",
+    "x'eda080'",
+    "x'f4908080'",
+    "x'e0809a'",
+    "x'41c342'",
+    "x'ffff'",
+    "x'c3a9e282'",
+  ];
+  const texts = [
+    "''",
+    "'plain ascii'",
+    "'caf\u00e9'",
+    "'\u4e1c\u4eac'",
+    "'x\u{1F680}y'",
+    "'\u00ff\u0100'",
+    "char(113, 34, 92, 10, 9, 1, 127)",
+    ...bad.map((b) => `CAST(${b} AS TEXT)`),
+  ];
+  for (const t of texts) {
+    const { cells, json } = cellRun(`SELECT ${t} AS t, 7 AS i, 2.5 AS f, NULL AS n, x'00ff7f' AS b, ${t} || 'z' AS u`);
+    assert.equal(cells.head.ok, true);
+    assert.deepEqual(cells.rows, json.rows, `cells equal the JSON rows for ${t}`);
+    assert.deepEqual(cells.head.cols, json.cols);
+    assert.equal(cells.head.changes, json.changes);
+  }
+  const empty = cellRun("SELECT a FROM t WHERE 0");
+  assert.deepEqual(empty.cells.rows, []);
+  assert.deepEqual(empty.json.rows, []);
+  const wide = cellRun("SELECT * FROM t");
+  assert.deepEqual(wide.cells.rows, wide.json.rows, "a table with a BLOB and NULLs");
+  const failed = cellRun("SELECT nope FROM nowhere");
+  assert.equal(failed.cells.head.ok, false);
+
   // An object that is not a blob binds NULL and the parse carries on (a "}" in a string included).
   const [, kept] = run([
     [d1, "INSERT INTO t VALUES (?1, ?2, ?3)", [{ a: "}{" }, 5, "x"]],
@@ -172,12 +252,23 @@ int main(void) {
   };
   // oxlint-disable-next-line no-function-constructor -- lifting a block out of the text-only transport
   const scriptRaw = (path: string, text: string) => sqlRaw(":script " + path, text, "[]");
+  // __sbSqlRowsRaw as the transport's C block gives it: [header JSON, rows], BLOBs as byte arrays.
+  const rowsOf =
+    (raw: (path: string, text: string, params: string) => string) => (path: string, text: string, params: string) => {
+      const r = JSON.parse(raw(":cells " + path, text, params));
+      if (r.head.ok === false) return [JSON.stringify(r.head), undefined];
+      const rows = r.rows.map((row: unknown[]) =>
+        row.map((c) => (c instanceof Object && "$blob" in c ? [...Buffer.from(String(c.$blob), "hex")] : c)),
+      );
+      return [JSON.stringify(r.head), rows];
+    };
   const ops = new Function(
     "__sbSqlRaw",
     "__sbSql",
     "__sbSqlScriptRaw",
+    "__sbSqlRowsRaw",
     `${transport.slice(opsStart, opsEnd)}\nreturn { __sbD1Run, __sbD1Batch, __sbD1Open, __sbD1ExecLines };`,
-  )(sqlRaw, sql, scriptRaw);
+  )(sqlRaw, sql, scriptRaw, rowsOf(sqlRaw));
   // The storage quota, lifted from "The storage quota" to __sbStore, for DIR and LIMIT.
   const quotaStart = transport.indexOf("// The storage quota: an app's data directory");
   const quotaEnd = transport.indexOf("function __sbStore() {");
@@ -233,8 +324,9 @@ int main(void) {
       "__sbSqlRaw",
       "__sbSql",
       "__sbSqlScriptRaw",
+      "__sbSqlRowsRaw",
       `${transport.slice(opsStart, opsEnd)}\nreturn { __sbD1Run, __sbD1Batch, __sbD1Open, __sbD1ExecLines };`,
-    )(raw, run, (path: string, text: string) => raw(":script " + path, text, "[]"));
+    )(raw, run, (path: string, text: string) => raw(":script " + path, text, "[]"), rowsOf(raw));
     const lift = (dir: string, limit: number) =>
       // oxlint-disable-next-line no-function-constructor -- lifting a block out of the text-only transport
       new Function(
@@ -312,7 +404,7 @@ int main(void) {
       "D1_ERROR: FOREIGN KEY constraint failed: SQLITE_CONSTRAINT (extended: SQLITE_CONSTRAINT_FOREIGNKEY)",
   );
   const strictRow = ops.__sbD1Run(db2, "SELECT 1 AS a, ?1 AS a", [{ $blob: "0a" }], true);
-  assert.deepEqual([strictRow.columns, strictRow.rows], [["a", "a"], [[1, { $blob: "0a" }]]]);
+  assert.deepEqual([strictRow.columns, strictRow.rows], [["a", "a"], [[1, [10]]]]);
   assert.throws(
     () => ops.__sbD1Run(db2, "SELEC 1", [], true),
     (e: Error) => e.message === 'D1_ERROR: near "SELEC": syntax error at offset 0: SQLITE_ERROR',
@@ -413,6 +505,7 @@ int main(void) {
     "__sbSqlRaw",
     "__sbSql",
     "__sbSqlScriptRaw",
+    "__sbSqlRowsRaw",
     `${transport.slice(opsStart, opsEnd)}\nreturn { __sbD1Run, __sbD1Batch };`,
   )(
     (path: string, text: string, params: string) => {
@@ -421,6 +514,7 @@ int main(void) {
     },
     sql,
     scriptRaw,
+    rowsOf(sqlRaw),
   );
   const LTX_FAILED =
     "D1_ERROR: LTX capture failed: the transaction may be committed locally but is not durable in the replication log; writes are refused until restart: SQLITE_IOERR";

package/test/native-json-strings.ts

@@ -0,0 +1,131 @@
+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";
+
+// JSON.stringify of strings as the spec defines it (Bun is the reference): quotes and backslash,
+// every control character, U+2028 and U+2029 (not escaped), DEL, Latin-1 and wider text, astral
+// characters, and lone or misordered surrogates (escaped as \\udXXX). Each input is built from
+// code units in the handler, so the compiled string has whatever layout concatenation gives it.
+const units = (s: string) => Array.from({ length: s.length }, (_, i) => s.charCodeAt(i));
+const everyControl = Array.from({ length: 0x20 }, (_, i) => String.fromCharCode(i)).join("");
+const INPUTS: string[] = [
+  "",
+  "abc",
+  'a"b\\c"',
+  everyControl,
+  "x" + everyControl + "y",
+  "\u007f\u0080\u00ff",
+  "caf\u00e9",
+  "line\u2028sep\u2029end",
+  "\u0100",
+  "\u4e1c\u4eac",
+  "x\u{1F680}y",
+  "\u{1F680}".repeat(40),
+  "\ud800",
+  "\udc00",
+  "\ud800x",
+  "x\udc00",
+  "\udc00\ud800",
+  "\ud800\ud800\udc00",
+  "a\ud83dz",
+  "\ud83d\ude80\ud83d",
+  "tab\there\nnewline\r\f\b",
+  "plain ascii text that is long enough to run the loop for a while. ".repeat(60),
+  'mix \u00e9\u4e1c\u{1F680}"\\\n\ud800 '.repeat(50),
+];
+const handler = `export default {fetch() {
+  const inputs = ${JSON.stringify(INPUTS.map(units))};
+  const out = [];
+  for (let n = 0; n < inputs.length; n++) {
+    let s = "";
+    for (let i = 0; i < inputs[n].length; i++) s += String.fromCharCode(inputs[n][i]);
+    out.push(JSON.stringify(s));
+    out.push(JSON.stringify({ [s]: s, list: [s, 1, null], nested: { k: s } }));
+  }
+  return new Response(out.join("\\u0001"));
+}};`;
+const want = INPUTS.flatMap((s) => [
+  JSON.stringify(s),
+  JSON.stringify({ [s]: s, list: [s, 1, null], nested: { k: s } }),
+]);
+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-json-strings-"));
+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, "json-strings.generated.js");
+  const binary = join(workdir, "json-strings-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");
+  const got = (await (await fetch(`http://127.0.0.1:${port}/`)).text()).split("\u0001");
+  assert.equal(got.length, want.length, "one result per case");
+  const diffs = want.flatMap((w, i) =>
+    got[i] === w
+      ? []
+      : [
+          `case ${i >> 1} (${i & 1 ? "object" : "string"})\n    want ${w.slice(0, 200)}\n    got  ${got[i].slice(0, 200)}`,
+        ],
+  );
+  assert.deepEqual(
+    diffs,
+    [],
+    `JSON.stringify differs from the spec in ${diffs.length} of ${want.length} cases:\n${diffs.join("\n")}`,
+  );
+  console.log(`Native JSON.stringify of strings is byte-identical to the spec in all ${want.length} cases`);
+} finally {
+  if (server) {
+    server.kill(9);
+    await server.exited;
+  }
+  await rm(workdir, { recursive: true, force: true });
+}