@sproutboat/runtime 0.6.2 → 0.6.3

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @sproutboat/runtime
 
+## 0.6.3
+
+### Patch Changes
+
+- Fix two compounding performance regressions in the `#181` fix, caught after
+  it went live and made sproutboat.com's homepage take 2.6-2.8s per request:
+  
+  1. `__sbRawBodyResponse` decoded eagerly at construction, paying the cost of
+     `__sbFromUtf8` on every asset/proxied response regardless of whether the
+     handler ever called `.text()`/`.json()` on it (the common case is a
+     response handed straight back to the client, never read as text). Now
+     decodes lazily on first call and memoizes.
+  
+  2. `__sbFromUtf8` built its result with repeated `out +=`. Porffor's strings
+     have no rope/cons optimization, so `+=` in a loop copies the whole
+     accumulated string on every append, making a large decode `O(n^2)`.
+     Measured directly against the real broker-sourced 43KB homepage body,
+     each successive 8000-character chunk took visibly longer than the last.
+     Now builds into an array and joins once.
+  
+  Together these took the homepage from ~2.7s to ~25ms (measured via the
+  runtime's own `x-sb-cpu-ms` header, confirming real CPU time, not I/O wait).
+  Every other route was already unaffected by fix 1 alone, since they never
+  call `.text()`. Verified against a real compiled `porf native` binary with
+  the actual page content, and end to end on sproutboat-site's own deployment.
+
 ## 0.6.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "license": "MIT",
   "type": "module",
   "main": "./src/index.ts",

package/src/native-fetch-prelude.js

@@ -339,7 +339,15 @@ function __sbBufFrom(latin1) {
 // regardless of whether it holds real Latin-1 text or raw bytes, so this
 // decode is only safe where the caller already knows which one it has.
 function __sbFromUtf8(bytes) {
-  let out = "";
+  // Collected into an array and joined once at the end, not built with
+  // repeated `out +=` -- Porffor's strings have no rope/cons optimization, so
+  // `+=` in a loop copies the whole accumulated string on every append,
+  // making the naive version O(n^2). Measured on the real 43KB homepage
+  // (dynamic, wire-sourced content, not a compile-time constant): each
+  // successive 8000-character chunk took visibly longer than the last, ~2.8s
+  // total -- a real, shipped performance regression on sproutboat.com.
+  // `Array.prototype.join` builds the result in one pass.
+  const out = [];
   const len = bytes.length;
   const cont = (j) => {
     const b = bytes.charCodeAt(j) & 0xff;
@@ -348,13 +356,13 @@ function __sbFromUtf8(bytes) {
   for (let i = 0; i < len; i++) {
     const b0 = bytes.charCodeAt(i) & 0xff;
     if (b0 < 0x80) {
-      out += String.fromCharCode(b0);
+      out.push(String.fromCharCode(b0));
       continue;
     }
     if ((b0 & 0xe0) == 0xc0 && i + 1 < len) {
       const c1 = cont(i + 1);
       if (c1 >= 0) {
-        out += String.fromCharCode(((b0 & 0x1f) << 6) | c1);
+        out.push(String.fromCharCode(((b0 & 0x1f) << 6) | c1));
         i += 1;
         continue;
       }
@@ -362,7 +370,7 @@ function __sbFromUtf8(bytes) {
       const c1 = cont(i + 1);
       const c2 = cont(i + 2);
       if (c1 >= 0 && c2 >= 0) {
-        out += String.fromCharCode(((b0 & 0x0f) << 12) | (c1 << 6) | c2);
+        out.push(String.fromCharCode(((b0 & 0x0f) << 12) | (c1 << 6) | c2));
         i += 2;
         continue;
       }
@@ -373,16 +381,16 @@ function __sbFromUtf8(bytes) {
       if (c1 >= 0 && c2 >= 0 && c3 >= 0) {
         let cp = ((b0 & 0x07) << 18) | (c1 << 12) | (c2 << 6) | c3;
         cp -= 0x10000;
-        out += String.fromCharCode(0xd800 + (cp >> 10), 0xdc00 + (cp & 0x3ff));
+        out.push(String.fromCharCode(0xd800 + (cp >> 10), 0xdc00 + (cp & 0x3ff)));
         i += 3;
         continue;
       }
     }
     // no lead byte matched, or its continuation bytes weren't 10xxxxxx:
     // pass the single byte through rather than guessing
-    out += String.fromCharCode(b0);
+    out.push(String.fromCharCode(b0));
   }
-  return out;
+  return out.join("");
 }
 // sproutboat #181 — wrap a Response built from raw wire bytes (the assets
 // binding, outbound fetch(), service-binding fetch(): the three `x-sb-raw-
@@ -395,12 +403,24 @@ function __sbFromUtf8(bytes) {
 // safely can't decode by default). Overriding just these three instances,
 // which sproutboat itself builds and knows are bytes, fixes the read side
 // without touching Porffor's generic Response/Request classes at all.
+// Decoded lazily, on first .text()/.json() call, and memoized after that --
+// most raw-body responses (a static asset, a proxied fetch()) are handed
+// straight back to the client and never read as text at all, and Porffor's
+// strings have no rope/cons optimization: `+=`-building a decoded copy costs
+// real time proportional to the body size (measured ~116ms for a 44KB
+// all-ASCII body). Decoding unconditionally at construction paid that cost
+// on every asset request regardless of whether anything used it -- this was
+// a real, shipped performance regression on sproutboat.com, caught after
+// the fact by unexpectedly slow page loads.
 function __sbRawBodyResponse(body, init) {
   const resp = new Response(body == null ? "" : body, init);
   if (body != null) {
-    const decoded = __sbFromUtf8(body);
-    resp.text = () => decoded;
-    resp.json = () => JSON.parse(decoded);
+    let decoded = null;
+    resp.text = () => {
+      if (decoded === null) decoded = __sbFromUtf8(body);
+      return decoded;
+    };
+    resp.json = () => JSON.parse(resp.text());
   }
   return resp;
 }

package/src/utf8-decode.test.js

@@ -50,3 +50,57 @@ test("empty and pure-ASCII strings are untouched", () => {
   expect(__sbFromUtf8("")).toBe("");
   expect(__sbFromUtf8("hello world")).toBe("hello world");
 });
+
+// __sbFromUtf8 builds its result via an array + one join(),
+// not repeated `out +=`. Porffor's strings have no rope/cons optimization, so
+// `+=` in a loop copies the whole accumulated string on every append,
+// making a large decode O(n^2) -- measured as a real ~2.6s stall decoding a
+// 43KB page on sproutboat.com, gone after the array+join rewrite. This is a
+// correctness check (long input still round-trips exactly), not a timing
+// assertion -- CI timing thresholds are flaky; the real perf verification
+// happened against a real compiled binary, documented in the fix commit.
+test("a long, multi-chunk body round-trips exactly", () => {
+  const chunk = "porffor · src/index.js → 1.25 MB · x86_64-musl ✓ café 🌱 ";
+  const text = chunk.repeat(800); // ~46KB, comparable to the real homepage
+  expect(__sbFromUtf8(toBytestring(text))).toBe(text);
+});
+
+// __sbRawBodyResponse must decode lazily: eagerly decoding at construction
+// paid the cost of __sbFromUtf8 on every asset/proxied response regardless of
+// whether the handler ever reads it as text, a real perf regression shipped
+// and caught on sproutboat.com (most such responses are handed straight to
+// the client and .text()/.json() are never called).
+const rbrStart = src.indexOf("function __sbRawBodyResponse(");
+const rbrEnd = src.indexOf("// Constant-time compare of two latin1 byte strings.");
+if (rbrStart === -1 || rbrEnd === -1 || rbrEnd < rbrStart) {
+  throw new Error("__sbRawBodyResponse block not found in prelude");
+}
+// oxlint-disable-next-line no-function-constructor -- lifting a pure block out of the text-only prelude for test
+const loadRbr = new Function(
+  "Response",
+  `${src.slice(start, end)}\n${src.slice(rbrStart, rbrEnd)}\nreturn { __sbRawBodyResponse };`,
+);
+// A minimal Response stand-in: only what __sbRawBodyResponse touches (the
+// constructor call and setting .text/.json on the instance), no Porffor
+// bytestring typing involved.
+class FakeResponse {
+  constructor(body, init) {
+    this.body = body;
+    this.status = (init && init.status) || 200;
+  }
+}
+const { __sbRawBodyResponse } = loadRbr(FakeResponse);
+
+test("__sbRawBodyResponse's text()/json() decode correctly, callable more than once", () => {
+  const bytes = toBytestring("café · 🌱");
+  const resp = __sbRawBodyResponse(bytes, { status: 200 });
+  expect(resp.text()).toBe("café · 🌱");
+  expect(resp.text()).toBe("café · 🌱"); // memoized decode, not re-run per call
+  expect(resp.json).toBeInstanceOf(Function);
+});
+
+test("__sbRawBodyResponse with a null body sets no text()/json() override", () => {
+  const resp = __sbRawBodyResponse(null, { status: 404 });
+  expect(resp.text).toBeUndefined();
+  expect(resp.json).toBeUndefined();
+});