@sproutboat/toolchain 0.7.0 → 0.8.1

package/src/patch.ts

@@ -15,6 +15,15 @@
 import { readFile, realpath, writeFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { patchUnicode } from "./unicode";
+import { URL_CLASS_SOURCE } from "./url-class";
+import { TEXT_DECODER_SOURCE } from "./text-decoder";
+import { CASE_LOWER_RUNS, CASE_UPPER_RUNS } from "./case-map";
+import { HEADERS_CLASS_SOURCE } from "./headers-class";
+import { BLOB_CLASS_SOURCE, REQUEST_CLASS_SOURCE, RESPONSE_BYTES_ANCHOR, RESPONSE_BYTES_INJECT, RESPONSE_CLASS_SOURCE } from "./fetch-classes";
+import * as streaming from "./streaming";
+import { PORFFOR_COMMIT_FULL } from "./pin";
+import { PATCH_FINGERPRINT } from "./fingerprint";
+import { version as TOOLCHAIN_VERSION } from "../package.json" with { type: "json" };
 
 // --- compiler/render.js: the native-fetch server, rendered as C text ---
 
@@ -47,7 +56,12 @@ const CONSOLE_MARKER = "sproutboat #165";
 /** render.js edits: `[marker, anchor, inject, what]`, each inserted after its anchor. */
 const RENDER_EDITS = [
   [PORT_MARKER, PORT_ANCHOR, PORT_INJECT, "$PORT support"],
-  [CONSOLE_MARKER, CONSOLE_ANCHOR, CONSOLE_INJECT, "console output sink (#165)"],
+  [
+    CONSOLE_MARKER,
+    CONSOLE_ANCHOR,
+    CONSOLE_INJECT,
+    "console output sink (#165)",
+  ],
 ] as const;
 
 /**
@@ -131,15 +145,24 @@ const READ_RAW_INJECT =
   READ_RAW_ANCHOR;
 const READ_RAW_MARKER = "porf_native_fetch_read_raw_bytes(jsval value";
 
-
 /**
  * render.js full-block replacements: `[marker, anchor, inject, what]`, each a
  * complete swap of the matched region (unlike `RENDER_EDITS`, which only ever
  * inserts after its anchor).
  */
 const RENDER_REPLACEMENTS = [
-  [BYTESTRING_MARKER, BYTESTRING_ANCHOR, BYTESTRING_INJECT, "bytestring UTF-8 encoding (#172)"],
-  [READ_RAW_MARKER, READ_RAW_ANCHOR, READ_RAW_INJECT, "raw bytestring passthrough function (#176)"],
+  [
+    BYTESTRING_MARKER,
+    BYTESTRING_ANCHOR,
+    BYTESTRING_INJECT,
+    "bytestring UTF-8 encoding (#172)",
+  ],
+  [
+    READ_RAW_MARKER,
+    READ_RAW_ANCHOR,
+    READ_RAW_INJECT,
+    "raw bytestring passthrough function (#176)",
+  ],
 ] as const;
 
 // #15 — no `--port` flag: Porffor's native-fetch entry point calls
@@ -266,8 +289,10 @@ const CFLAGS_MARKER = "SB_EXTRA_CFLAGS";
 // into one FMA on arm64, rounding once where JavaScript rounds twice. A seeded
 // LCG (seed * 1103515245 + 12345, past 2^53) diverged from V8 at step 23.
 // Every compiled unit keeps JS's separate roundings with contraction off.
-const FP_CONTRACT_ANCHOR = "      '-fno-ident', '-ffunction-sections', '-fdata-sections',\n";
-const FP_CONTRACT_INJECT = "      '-ffp-contract=off', // sproutboat #235: JS rounds a * b + c twice\n";
+const FP_CONTRACT_ANCHOR =
+  "      '-fno-ident', '-ffunction-sections', '-fdata-sections',\n";
+const FP_CONTRACT_INJECT =
+  "      '-ffp-contract=off', // sproutboat #235: JS rounds a * b + c twice\n";
 const FP_CONTRACT_MARKER = "sproutboat #235";
 
 // baronunread/sproutboat#236: uWebSockets answers any request line that isn't
@@ -313,14 +338,17 @@ export const sbPatchHttp10 = uwsDir => {
 };
 `;
 const HTTP10_IMPORT_ANCHOR = "import { hashId } from './modules.js';\n";
-const HTTP10_IMPORT_INJECT = "import { sbPatchHttp10 } from './sb-http10.js'; // sproutboat #236\n";
+const HTTP10_IMPORT_INJECT =
+  "import { sbPatchHttp10 } from './sb-http10.js'; // sproutboat #236\n";
 const HTTP10_IMPORT_MARKER = "./sb-http10.js";
-const HTTP10_CALL_ANCHOR = "      const uwsDir = uwebsockets.ensureUWebSockets();\n";
+const HTTP10_CALL_ANCHOR =
+  "      const uwsDir = uwebsockets.ensureUWebSockets();\n";
 const HTTP10_CALL_INJECT = "      sbPatchHttp10(uwsDir);\n";
 const HTTP10_CALL_MARKER = "sbPatchHttp10(uwsDir)";
 // The shim is content-cached, so a header edit alone would never recompile it.
 // This line changes the shim once, which rebuilds it against the edited header.
-const HTTP10_SHIM_ANCHOR = 'export const makeUWebSocketsShimSource = () => `\n#include "App.h"\n';
+const HTTP10_SHIM_ANCHOR =
+  'export const makeUWebSocketsShimSource = () => `\n#include "App.h"\n';
 const HTTP10_SHIM_INJECT =
   'export const makeUWebSocketsShimSource = () => `\n#include "App.h"\n// sproutboat #236: built against an HttpParser.h that accepts HTTP/1.0\n';
 const HTTP10_SHIM_MARKER = "sproutboat #236: built against";
@@ -361,56 +389,6 @@ const REPLACE_ALL_EDITS = [
 ] as const;
 const REPLACE_ALL_MARKER = "sproutboat #237: pieces joined once";
 
-// baronunread/sproutboat#238: typed-array element reads and writes had no
-// bounds check. A read past the end returned whatever sat in the next
-// allocation instead of undefined (uuid's SHA-1 reads past its buffer, so v5
-// UUIDs changed run to run) and a[-1] / a[1.5] broke outright. Reuse the
-// plain-array index check and compare against the typed array's length.
-// Builtins keep the unchecked read: they index within bounds, and the check
-// broke typed-array join/toString when compiled into them. Writes need the same
-// guard, but builtins such as the constructor and fill() store elements before
-// they set the length, so that is left for a follow-up.
-const TA_GET_ANCHOR =
-  "  const taGet = (ctype, size, signed = true) => () => {\n" +
-  "    const loaded = Load(ctype, taAddr(size), 4);\n" +
-  "    const f = ctype === 'f32' || ctype === 'f64' ? loaded : Convert(T.f64, loaded, signed ? CONVERT_SIGNED : 0);\n" +
-  "    return Box(f, Const(T.i32, TYPES.number));\n" +
-  "  };";
-const TA_GET_INJECT =
-  "  const taGet = (ctype, size, signed = true) => () => {\n" +
-  "    // sproutboat #238: only a valid in-range integer index reads; anything else is undefined.\n" +
-  "    // User code only: builtins (precompiled) index within bounds themselves and\n" +
-  "    // typed-array join/toString misbehave with the extra check.\n" +
-  "    if (globalThis.precompile) {\n" +
-  "      const raw = Load(ctype, taAddr(size), 4);\n" +
-  "      return Box(ctype === 'f32' || ctype === 'f64' ? raw : Convert(T.f64, raw, signed ? CONVERT_SIGNED : 0), Const(T.i32, TYPES.number));\n" +
-  "    }\n" +
-  "    const { idx, valid } = denseArrayIndexKey(scope, prop);\n" +
-  "    const loaded = Load(ctype, Bin('+', T.u32, Load('u32', JvPtr(obj), 4), size === 1 ? idx : Bin('*', T.u32, idx, Const(T.u32, size))), 4);\n" +
-  "    const f = ctype === 'f32' || ctype === 'f64' ? loaded : Convert(T.f64, loaded, signed ? CONVERT_SIGNED : 0);\n" +
-  "    return Select(Bin('&&', T.i32, valid, Bin('<', T.i32, idx, Load('u32', JvPtr(obj), 0))),\n" +
-  "      Box(f, Const(T.i32, TYPES.number)), valUndefined());\n" +
-  "  };";
-const TA_GET_MARKER = "sproutboat #238: only a valid in-range integer index reads";
-// baronunread/sproutboat#241: a typed-array write outside the array stored into
-// whatever memory followed it (and a[-1] = x wrote a[0], via the saturating
-// index conversion). ECMA-262 ignores the write. Same check as taGet, in user
-// code only: builtins such as the constructor store elements before they set
-// the length, and they only write in bounds anyway. Alpha-14 fixed the store's
-// conversion upstream (ToUint32, which our #238 patch used to add); the bounds
-// check is still missing there.
-const TA_SET_BOUNDS_ANCHOR =
-  "      stmt(scope, Store(ctype, addr, 4, ctype === 'f64' || ctype === 'f32' ? f : toUint32(scope, f)));";
-const TA_SET_BOUNDS_INJECT =
-  "      const store = () => stmt(scope, Store(ctype, addr, 4, ctype === 'f64' || ctype === 'f32' ? f : toUint32(scope, f)));\n" +
-  "      // sproutboat #241: a write outside the array is ignored, not stored into the next allocation.\n" +
-  "      if (globalThis.precompile) store();\n" +
-  "      else {\n" +
-  "        const { idx: sbIdx, valid: sbValid } = denseArrayIndexKey(scope, prop);\n" +
-  "        emitIf(scope, Bin('&&', T.i32, sbValid, Bin('<', T.i32, sbIdx, Load('u32', JvPtr(obj), 0))), store);\n" +
-  "      }";
-const TA_SET_BOUNDS_MARKER = "sproutboat #241: a write outside the array is ignored";
-
 // Porffor alpha 9 treats +02:00 as two milliseconds and adds offset hours
 // instead of subtracting them. Count fields even when they contain zero, and
 // apply the signed offset after parsing the local wall-clock fields.
@@ -512,7 +490,8 @@ const DATE_PARSER_INJECT = `  // sproutboat: ISO timezone offset
  * The default stays 1 MiB: a larger body is held in memory whole, so raising it
  * is a decision about this deployment's memory, not something to inherit.
  */
-const BODY_ANCHOR = "static const size_t REQUEST_BODY_MAX_BYTES = 1024u * 1024u;";
+const BODY_ANCHOR =
+  "static const size_t REQUEST_BODY_MAX_BYTES = 1024u * 1024u;";
 const BODY_INJECT = `static size_t sb_request_body_max(void) {
   static size_t cached = 0;
   if (cached == 0) {
@@ -538,7 +517,8 @@ const BODY_MARKER = "sb_request_body_max";
  * the sole caller feeds it straight to `writeStatus`, which copies synchronously).
  * Known codes keep their proper reason phrase.
  */
-const STATUS_SIG_ANCHOR = "static std::string_view lookup_status_line(i32 status) {";
+const STATUS_SIG_ANCHOR =
+  "static std::string_view lookup_status_line(i32 status) {";
 const STATUS_SIG_INJECT = "static std::string lookup_status_line(i32 status) {";
 const STATUS_SIG_MARKER = "static std::string lookup_status_line(i32 status) {";
 // 303 is the one this was reported for (POST-redirect-GET); give it the real
@@ -548,7 +528,8 @@ const STATUS_303_INJECT =
   '    case 302: return "302 Found";\n    case 303: return "303 See Other";\n';
 const STATUS_303_MARKER = 'case 303: return "303 See Other";';
 const STATUS_DEFAULT_ANCHOR = "    default: return {};";
-const STATUS_DEFAULT_INJECT = '    default: return std::to_string(status) + " Status";';
+const STATUS_DEFAULT_INJECT =
+  '    default: return std::to_string(status) + " Status";';
 const STATUS_DEFAULT_MARKER = 'std::to_string(status) + " Status"';
 
 /**
@@ -564,7 +545,8 @@ const STATUS_DEFAULT_MARKER = 'std::to_string(status) + " Status"';
 const HDR_SIG_ANCHOR = "static i32 collect_headers(uWS::HttpRequest* req) {\n";
 const HDR_SIG_INJECT =
   "static i32 collect_headers(uWS::HttpRequest* req, uWS::HttpResponse<false>* res) {\n";
-const HDR_SIG_MARKER = "collect_headers(uWS::HttpRequest* req, uWS::HttpResponse";
+const HDR_SIG_MARKER =
+  "collect_headers(uWS::HttpRequest* req, uWS::HttpResponse";
 
 const HDR_CALL_ANCHOR = "const i32 headers_ptr = collect_headers(req);";
 const HDR_CALL_INJECT = "const i32 headers_ptr = collect_headers(req, res);";
@@ -582,7 +564,8 @@ const HDR_SKIP_INJECT =
   '    if (key == "x-sb-remote-addr") continue; // #163: reserved, the server sets it below\n';
 const HDR_SKIP_MARKER = 'key == "x-sb-remote-addr"';
 
-const HDR_APPEND_ANCHOR = "  *((i32*)(porf_mem + headers_ptr)) = slot;\n\n  return headers_ptr;";
+const HDR_APPEND_ANCHOR =
+  "  *((i32*)(porf_mem + headers_ptr)) = slot;\n\n  return headers_ptr;";
 const HDR_APPEND_INJECT =
   "  {\n" +
   "    const std::string_view __sb_peer = res ? res->getRemoteAddressAsText() : std::string_view();\n" +
@@ -611,7 +594,8 @@ const READ_RAW_DECL_ANCHOR =
 const READ_RAW_DECL_INJECT =
   "int porf_native_fetch_read_value(struct jsval value, const char** out_buf, size_t* out_len, char** out_owned);\n" +
   "int porf_native_fetch_read_raw_bytes(struct jsval value, const char** out_buf, size_t* out_len);";
-const READ_RAW_DECL_MARKER = "porf_native_fetch_read_raw_bytes(struct jsval value";
+const READ_RAW_DECL_MARKER =
+  "porf_native_fetch_read_raw_bytes(struct jsval value";
 
 const FORBIDDEN_HDR_ANCHOR =
   "static bool is_forbidden_response_header(std::string_view key) {\n" +
@@ -707,8 +691,16 @@ const WRITE_RESPONSE_INJECT =
   "  const char* body_buf = nullptr;\n" +
   "  size_t body_len = 0;\n" +
   "  char* body_owned = nullptr;\n" +
-  "  if (raw_body) porf_native_fetch_read_raw_bytes(body_value, &body_buf, &body_len);\n" +
-  "  else porf_native_fetch_read_value(body_value, &body_buf, &body_len, &body_owned);\n" +
+  "  if (raw_body && porf_native_fetch_read_raw_bytes(body_value, &body_buf, &body_len) != 0 && body_value.type == 67) {\n" +
+  "    // Raw bytes can also arrive as a UTF-16 string (a fetch() response body parsed\n" +
+  "    // from JSON), one byte per unit: narrow each unit, as the R2 upload path does.\n" +
+  "    const u32 body_ptr = (u32)body_value.val;\n" +
+  "    body_len = (size_t)*((u32*)(porf_mem + body_ptr));\n" +
+  "    body_owned = (char*)malloc(body_len + 1);\n" +
+  "    const unsigned short* units = (const unsigned short*)(porf_mem + body_ptr + 4);\n" +
+  "    for (size_t i = 0; i < body_len; i++) body_owned[i] = (char)(units[i] & 0xff);\n" +
+  "    body_buf = body_owned;\n" +
+  "  } else if (!raw_body || !body_buf) porf_native_fetch_read_value(body_value, &body_buf, &body_len, &body_owned);\n" +
   "\n" +
   "  if (!aborted || !*aborted) {\n" +
   "    res->cork([res, status, headers_entries_ptr, body_buf, body_len]() {\n" +
@@ -751,7 +743,8 @@ const WRITE_RESPONSE_MARKER = "porf_native_fetch_read_raw_bytes(body_value";
 // #195: reserve a direct-transfer ticket before native-fetch allocates the
 // ordinary in-memory PendingRequest. uWS then gives each wire chunk directly
 // to the runtime C ABI, which owns the temporary object file.
-const R2_TRANSFER_ANCHOR = "static void on_request(uWS::HttpResponse<false>* res, uWS::HttpRequest* req) {\n";
+const R2_TRANSFER_ANCHOR =
+  "static void on_request(uWS::HttpResponse<false>* res, uWS::HttpRequest* req) {\n";
 const R2_TRANSFER_INJECT = `extern "C" {
   struct sb_r2_transfer_ctx;
   int sb_r2_transfer_open(const char*, const char*, size_t, sb_r2_transfer_ctx**);
@@ -819,7 +812,7 @@ static bool try_handle_r2_transfer(uWS::HttpResponse<false>* res, uWS::HttpReque
     struct Download { sb_r2_transfer_ctx* ctx; uintmax_t base; uintmax_t size; uintmax_t sent = 0; bool closed = false; char chunk[65536]; };
     auto state = std::make_shared<Download>(Download{download, first, last - first + 1});
     auto pump = std::make_shared<std::function<bool()>>();
-    *pump = [res, state, pump]() {
+    *pump = [res, state]() {
       if (state->closed) return false;
       for (;;) {
         const size_t want = state->size - state->sent < sizeof(state->chunk) ? (size_t)(state->size - state->sent) : sizeof(state->chunk);
@@ -829,11 +822,14 @@ static bool try_handle_r2_transfer(uWS::HttpResponse<false>* res, uWS::HttpReque
         if (!result.first) {
           res->onWritable([res, state](uintmax_t offset) {
             if (state->closed) return true;
-            const size_t want = state->size - offset < sizeof(state->chunk) ? (size_t)(state->size - offset) : sizeof(state->chunk);
-            const size_t bytes = sb_r2_transfer_download_read(state->ctx, (size_t)(state->base + offset), state->chunk, want);
-            const auto resumed = res->tryEnd(std::string_view(state->chunk, bytes), state->size);
-            if (resumed.second || bytes == 0) { sb_r2_transfer_download_close(state->ctx); state->closed = true; return true; }
-            return resumed.first;
+            for (;;) {
+              const size_t want = state->size - offset < sizeof(state->chunk) ? (size_t)(state->size - offset) : sizeof(state->chunk);
+              const size_t bytes = sb_r2_transfer_download_read(state->ctx, (size_t)(state->base + offset), state->chunk, want);
+              const auto resumed = res->tryEnd(std::string_view(state->chunk, bytes), state->size);
+              if (resumed.second || bytes == 0) { sb_r2_transfer_download_close(state->ctx); state->closed = true; return true; }
+              if (!resumed.first) return false;
+              offset += bytes;
+            }
           });
           return false;
         }
@@ -870,16 +866,19 @@ static bool try_handle_r2_transfer(uWS::HttpResponse<false>* res, uWS::HttpReque
 static void on_request(uWS::HttpResponse<false>* res, uWS::HttpRequest* req) {
 `;
 const R2_TRANSFER_MARKER = "sb_r2_transfer_path(std::string_view path";
-const R2_TRANSFER_CALL_ANCHOR = "  __porffor_js_enter();\n  const i32 url_ptr = alloc_request_url(req);";
+const R2_TRANSFER_CALL_ANCHOR =
+  "  __porffor_js_enter();\n  const i32 url_ptr = alloc_request_url(req);";
 const R2_TRANSFER_CALL_INJECT =
-  "  if (try_handle_r2_transfer(res, req, method)) return;\n" + R2_TRANSFER_CALL_ANCHOR;
+  "  if (try_handle_r2_transfer(res, req, method)) return;\n" +
+  R2_TRANSFER_CALL_ANCHOR;
 const R2_TRANSFER_CALL_MARKER = "try_handle_r2_transfer(res, req, method)";
 const R2_DOWNLOAD_CACHE_MARKER = "sb_r2_transfer_download_v1";
 const R2_RANGE_CACHE_MARKER = "sb_r2_transfer_range_v1";
 const R2_CONDITIONAL_CACHE_MARKER = "sb_r2_transfer_conditional_v1";
 const R2_STREAMING_CACHE_MARKER = "sb_r2_transfer_streaming_v2";
 const R2_RANGE_HEADER_CACHE_MARKER = "sb_r2_transfer_range_header_v2";
-const R2_DOWNLOAD_DECL_ANCHOR = "  void sb_r2_transfer_abort(sb_r2_transfer_ctx*);\n}";
+const R2_DOWNLOAD_DECL_ANCHOR =
+  "  void sb_r2_transfer_abort(sb_r2_transfer_ctx*);\n}";
 const R2_DOWNLOAD_DECL_INJECT =
   "  void sb_r2_transfer_abort(sb_r2_transfer_ctx*);\n" +
   "  int sb_r2_transfer_download_open(const char*, const char*, sb_r2_transfer_ctx**);\n" +
@@ -887,7 +886,8 @@ const R2_DOWNLOAD_DECL_INJECT =
   "  const char* sb_r2_transfer_download_etag(sb_r2_transfer_ctx*);\n" +
   "  size_t sb_r2_transfer_download_read(sb_r2_transfer_ctx*, size_t, char*, size_t);\n" +
   "  void sb_r2_transfer_download_close(sb_r2_transfer_ctx*);\n}";
-const R2_DOWNLOAD_BRANCH_ANCHOR = '  if (method != "PUT") { respond_with_error(res, "405 Method Not Allowed", "R2 transfer requires PUT", true); return true; }';
+const R2_DOWNLOAD_BRANCH_ANCHOR =
+  '  if (method != "PUT") { respond_with_error(res, "405 Method Not Allowed", "R2 transfer requires PUT", true); return true; }';
 const R2_DOWNLOAD_BRANCH_INJECT = `  // sb_r2_transfer_download_v1
   // sb_r2_transfer_range_v1
   // sb_r2_transfer_range_header_v2
@@ -920,7 +920,7 @@ const R2_DOWNLOAD_BRANCH_INJECT = `  // sb_r2_transfer_download_v1
     struct Download { sb_r2_transfer_ctx* ctx; uintmax_t base; uintmax_t size; uintmax_t sent = 0; bool closed = false; char chunk[65536]; };
     auto state = std::make_shared<Download>(Download{download, first, last - first + 1});
     auto pump = std::make_shared<std::function<bool()>>();
-    *pump = [res, state, pump]() {
+    *pump = [res, state]() {
       if (state->closed) return false;
       for (;;) {
         const size_t want = state->size - state->sent < sizeof(state->chunk) ? (size_t)(state->size - state->sent) : sizeof(state->chunk);
@@ -930,11 +930,14 @@ const R2_DOWNLOAD_BRANCH_INJECT = `  // sb_r2_transfer_download_v1
         if (!result.first) {
           res->onWritable([res, state](uintmax_t offset) {
             if (state->closed) return true;
-            const size_t want = state->size - offset < sizeof(state->chunk) ? (size_t)(state->size - offset) : sizeof(state->chunk);
-            const size_t bytes = sb_r2_transfer_download_read(state->ctx, (size_t)(state->base + offset), state->chunk, want);
-            const auto resumed = res->tryEnd(std::string_view(state->chunk, bytes), state->size);
-            if (resumed.second || bytes == 0) { sb_r2_transfer_download_close(state->ctx); state->closed = true; return true; }
-            return resumed.first;
+            for (;;) {
+              const size_t want = state->size - offset < sizeof(state->chunk) ? (size_t)(state->size - offset) : sizeof(state->chunk);
+              const size_t bytes = sb_r2_transfer_download_read(state->ctx, (size_t)(state->base + offset), state->chunk, want);
+              const auto resumed = res->tryEnd(std::string_view(state->chunk, bytes), state->size);
+              if (resumed.second || bytes == 0) { sb_r2_transfer_download_close(state->ctx); state->closed = true; return true; }
+              if (!resumed.first) return false;
+              offset += bytes;
+            }
           });
           return false;
         }
@@ -953,22 +956,67 @@ const done = new Set<string>();
 
 /** Edits to Porffor's uWebSockets shim: `[marker, anchor, inject, what]`. */
 const UWS_EDITS = [
-  [HTTP10_SHIM_MARKER, HTTP10_SHIM_ANCHOR, HTTP10_SHIM_INJECT, "shim rebuild for HTTP/1.0 (#236)"],
+  [
+    HTTP10_SHIM_MARKER,
+    HTTP10_SHIM_ANCHOR,
+    HTTP10_SHIM_INJECT,
+    "shim rebuild for HTTP/1.0 (#236)",
+  ],
   [BODY_MARKER, BODY_ANCHOR, BODY_INJECT, "request body limit"],
-  [STATUS_SIG_MARKER, STATUS_SIG_ANCHOR, STATUS_SIG_INJECT, "status-line return type (#156)"],
-  [STATUS_303_MARKER, STATUS_303_ANCHOR, STATUS_303_INJECT, "status-line 303 case (#156)"],
+  [
+    STATUS_SIG_MARKER,
+    STATUS_SIG_ANCHOR,
+    STATUS_SIG_INJECT,
+    "status-line return type (#156)",
+  ],
+  [
+    STATUS_303_MARKER,
+    STATUS_303_ANCHOR,
+    STATUS_303_INJECT,
+    "status-line 303 case (#156)",
+  ],
   [
     STATUS_DEFAULT_MARKER,
     STATUS_DEFAULT_ANCHOR,
     STATUS_DEFAULT_INJECT,
     "status-line fallback (#156)",
   ],
-  [HDR_SIG_MARKER, HDR_SIG_ANCHOR, HDR_SIG_INJECT, "collect_headers res arg (#163)"],
-  [HDR_CALL_MARKER, HDR_CALL_ANCHOR, HDR_CALL_INJECT, "collect_headers call site (#163)"],
-  [HDR_CAP_MARKER, HDR_CAP_ANCHOR, HDR_CAP_INJECT, "remote-addr header capacity (#163)"],
-  [HDR_SKIP_MARKER, HDR_SKIP_ANCHOR, HDR_SKIP_INJECT, "drop client-sent x-sb-remote-addr (#163)"],
-  [HDR_APPEND_MARKER, HDR_APPEND_ANCHOR, HDR_APPEND_INJECT, "append x-sb-remote-addr (#163)"],
-  [READ_RAW_DECL_MARKER, READ_RAW_DECL_ANCHOR, READ_RAW_DECL_INJECT, "read_raw_bytes decl (#176)"],
+  [
+    HDR_SIG_MARKER,
+    HDR_SIG_ANCHOR,
+    HDR_SIG_INJECT,
+    "collect_headers res arg (#163)",
+  ],
+  [
+    HDR_CALL_MARKER,
+    HDR_CALL_ANCHOR,
+    HDR_CALL_INJECT,
+    "collect_headers call site (#163)",
+  ],
+  [
+    HDR_CAP_MARKER,
+    HDR_CAP_ANCHOR,
+    HDR_CAP_INJECT,
+    "remote-addr header capacity (#163)",
+  ],
+  [
+    HDR_SKIP_MARKER,
+    HDR_SKIP_ANCHOR,
+    HDR_SKIP_INJECT,
+    "drop client-sent x-sb-remote-addr (#163)",
+  ],
+  [
+    HDR_APPEND_MARKER,
+    HDR_APPEND_ANCHOR,
+    HDR_APPEND_INJECT,
+    "append x-sb-remote-addr (#163)",
+  ],
+  [
+    READ_RAW_DECL_MARKER,
+    READ_RAW_DECL_ANCHOR,
+    READ_RAW_DECL_INJECT,
+    "read_raw_bytes decl (#176)",
+  ],
   [
     FORBIDDEN_HDR_MARKER,
     FORBIDDEN_HDR_ANCHOR,
@@ -981,8 +1029,18 @@ const UWS_EDITS = [
     WRITE_RESPONSE_INJECT,
     "detect x-sb-raw-body, steer the body read (#176)",
   ],
-  [R2_TRANSFER_MARKER, R2_TRANSFER_ANCHOR, R2_TRANSFER_INJECT, "native direct R2 transfer ingress (#195)"],
-  [R2_TRANSFER_CALL_MARKER, R2_TRANSFER_CALL_ANCHOR, R2_TRANSFER_CALL_INJECT, "direct R2 transfer dispatch (#195)"],
+  [
+    R2_TRANSFER_MARKER,
+    R2_TRANSFER_ANCHOR,
+    R2_TRANSFER_INJECT,
+    "native direct R2 transfer ingress (#195)",
+  ],
+  [
+    R2_TRANSFER_CALL_MARKER,
+    R2_TRANSFER_CALL_ANCHOR,
+    R2_TRANSFER_CALL_INJECT,
+    "direct R2 transfer dispatch (#195)",
+  ],
 ] as const;
 
 /** The uWebSockets shim source: body limit + the #156 status-line fix. Exported for tests. */
@@ -993,15 +1051,27 @@ export async function patchUwebsockets(root: string): Promise<void> {
   // Upgrade already-patched caches from the initial upload-only bridge. New
   // caches receive the full bridge below; old ones need declarations plus the
   // GET dispatch grafted onto their existing transfer handler.
-  if (src.includes(R2_TRANSFER_MARKER) && !src.includes(R2_DOWNLOAD_CACHE_MARKER)) {
-    if (!src.includes(R2_DOWNLOAD_DECL_ANCHOR) || !src.includes(R2_DOWNLOAD_BRANCH_ANCHOR))
-      throw new Error(`could not upgrade Porffor's direct R2 transfer bridge: anchor not found in ${file}.`);
+  if (
+    src.includes(R2_TRANSFER_MARKER) &&
+    !src.includes(R2_DOWNLOAD_CACHE_MARKER)
+  ) {
+    if (
+      !src.includes(R2_DOWNLOAD_DECL_ANCHOR) ||
+      !src.includes(R2_DOWNLOAD_BRANCH_ANCHOR)
+    )
+      throw new Error(
+        `could not upgrade Porffor's direct R2 transfer bridge: anchor not found in ${file}.`,
+      );
     src = src.replace(R2_DOWNLOAD_DECL_ANCHOR, R2_DOWNLOAD_DECL_INJECT);
     src = src.replace(R2_DOWNLOAD_BRANCH_ANCHOR, R2_DOWNLOAD_BRANCH_INJECT);
     changed = true;
   }
-  if (src.includes(R2_DOWNLOAD_CACHE_MARKER) && !src.includes(R2_RANGE_CACHE_MARKER)) {
-    const stateAnchor = "    struct Download { sb_r2_transfer_ctx* ctx; uintmax_t size; bool closed = false; };\n    auto state = std::make_shared<Download>(Download{download, sb_r2_transfer_download_size(download)});";
+  if (
+    src.includes(R2_DOWNLOAD_CACHE_MARKER) &&
+    !src.includes(R2_RANGE_CACHE_MARKER)
+  ) {
+    const stateAnchor =
+      "    struct Download { sb_r2_transfer_ctx* ctx; uintmax_t size; bool closed = false; };\n    auto state = std::make_shared<Download>(Download{download, sb_r2_transfer_download_size(download)});";
     const range = `    const uintmax_t full_size = sb_r2_transfer_download_size(download);
     uintmax_t first = 0, last = full_size ? full_size - 1 : 0;
     const std::string_view range = req->getHeader("range");
@@ -1017,18 +1087,36 @@ export async function patchUwebsockets(root: string): Promise<void> {
       res->writeStatus("206 Partial Content"); res->writeHeader("Content-Range", content_range);
     }
 `;
-    const state = "    struct Download { sb_r2_transfer_ctx* ctx; uintmax_t base; uintmax_t size; bool closed = false; };\n    auto state = std::make_shared<Download>(Download{download, first, last - first + 1});";
-    if (!src.includes(stateAnchor)) throw new Error(`could not upgrade Porffor's direct R2 range bridge: anchor not found in ${file}.`);
-    src = src.replace("  // sb_r2_transfer_download_v1\n", "  // sb_r2_transfer_download_v1\n  // sb_r2_transfer_range_v1\n");
+    const state =
+      "    struct Download { sb_r2_transfer_ctx* ctx; uintmax_t base; uintmax_t size; bool closed = false; };\n    auto state = std::make_shared<Download>(Download{download, first, last - first + 1});";
+    if (!src.includes(stateAnchor))
+      throw new Error(
+        `could not upgrade Porffor's direct R2 range bridge: anchor not found in ${file}.`,
+      );
+    src = src.replace(
+      "  // sb_r2_transfer_download_v1\n",
+      "  // sb_r2_transfer_download_v1\n  // sb_r2_transfer_range_v1\n",
+    );
     src = src.replace(stateAnchor, range + state);
-    src = src.replace("sb_r2_transfer_download_read(state->ctx, (size_t)offset, chunk, sizeof(chunk))", "sb_r2_transfer_download_read(state->ctx, (size_t)(state->base + offset), chunk, sizeof(chunk))");
+    src = src.replace(
+      "sb_r2_transfer_download_read(state->ctx, (size_t)offset, chunk, sizeof(chunk))",
+      "sb_r2_transfer_download_read(state->ctx, (size_t)(state->base + offset), chunk, sizeof(chunk))",
+    );
     changed = true;
   }
-  if (src.includes(R2_RANGE_CACHE_MARKER) && !src.includes(R2_CONDITIONAL_CACHE_MARKER)) {
-    const declaration = "  size_t sb_r2_transfer_download_size(sb_r2_transfer_ctx*);\n";
-    const declarationReplacement = declaration + "  const char* sb_r2_transfer_download_etag(sb_r2_transfer_ctx*);\n";
-    const anchor = "    const uintmax_t full_size = sb_r2_transfer_download_size(download);\n";
-    const inject = `    // sb_r2_transfer_conditional_v1
+  if (
+    src.includes(R2_RANGE_CACHE_MARKER) &&
+    !src.includes(R2_CONDITIONAL_CACHE_MARKER)
+  ) {
+    const declaration =
+      "  size_t sb_r2_transfer_download_size(sb_r2_transfer_ctx*);\n";
+    const declarationReplacement =
+      declaration +
+      "  const char* sb_r2_transfer_download_etag(sb_r2_transfer_ctx*);\n";
+    const anchor =
+      "    const uintmax_t full_size = sb_r2_transfer_download_size(download);\n";
+    const inject =
+      `    // sb_r2_transfer_conditional_v1
     const std::string etag = sb_r2_transfer_download_etag(download);
     res->writeHeader("ETag", etag); res->writeHeader("Accept-Ranges", "bytes");
     const std::string_view if_none_match = req->getHeader("if-none-match");
@@ -1036,11 +1124,19 @@ export async function patchUwebsockets(root: string): Promise<void> {
       sb_r2_transfer_download_close(download); res->writeStatus("304 Not Modified"); res->end(); return true;
     }
 ` + anchor;
-    if (!src.includes(declaration) || !src.includes(anchor)) throw new Error(`could not upgrade Porffor's direct R2 conditional bridge: anchor not found in ${file}.`);
-    src = src.replace(declaration, declarationReplacement).replace(anchor, inject);
+    if (!src.includes(declaration) || !src.includes(anchor))
+      throw new Error(
+        `could not upgrade Porffor's direct R2 conditional bridge: anchor not found in ${file}.`,
+      );
+    src = src
+      .replace(declaration, declarationReplacement)
+      .replace(anchor, inject);
     changed = true;
   }
-  if (src.includes(R2_CONDITIONAL_CACHE_MARKER) && !src.includes(R2_STREAMING_CACHE_MARKER)) {
+  if (
+    src.includes(R2_CONDITIONAL_CACHE_MARKER) &&
+    !src.includes(R2_STREAMING_CACHE_MARKER)
+  ) {
     const oldPump = `      const uintmax_t offset = res->getWriteOffset();
       char chunk[65536];
       const size_t bytes = sb_r2_transfer_download_read(state->ctx, (size_t)(state->base + offset), chunk, sizeof(chunk));
@@ -1055,15 +1151,28 @@ export async function patchUwebsockets(root: string): Promise<void> {
         if (result.second) { sb_r2_transfer_download_close(state->ctx); state->closed = true; return false; }
         if (!result.first) { res->onWritable([pump](uintmax_t) { return (*pump)(); }); return false; }
       }`;
-    if (!src.includes(oldPump)) throw new Error(`could not upgrade Porffor's direct R2 streaming bridge: anchor not found in ${file}.`);
-    src = src.replace("  // sb_r2_transfer_conditional_v1\n", "  // sb_r2_transfer_conditional_v1\n  // sb_r2_transfer_streaming_v2\n").replace(oldPump, newPump);
+    if (!src.includes(oldPump))
+      throw new Error(
+        `could not upgrade Porffor's direct R2 streaming bridge: anchor not found in ${file}.`,
+      );
+    src = src
+      .replace(
+        "  // sb_r2_transfer_conditional_v1\n",
+        "  // sb_r2_transfer_conditional_v1\n  // sb_r2_transfer_streaming_v2\n",
+      )
+      .replace(oldPump, newPump);
     changed = true;
   }
   // A short-lived v2 cache marker was written before its pump fix. Repair
   // those caches as well as applying the current form to future upgrades.
-  if (src.includes("state->base + offset") && src.includes("uintmax_t size; bool closed = false;")) {
-    const oldState = "struct Download { sb_r2_transfer_ctx* ctx; uintmax_t base; uintmax_t size; bool closed = false; };";
-    const newState = "struct Download { sb_r2_transfer_ctx* ctx; uintmax_t base; uintmax_t size; uintmax_t sent = 0; bool closed = false; };";
+  if (
+    src.includes("state->base + offset") &&
+    src.includes("uintmax_t size; bool closed = false;")
+  ) {
+    const oldState =
+      "struct Download { sb_r2_transfer_ctx* ctx; uintmax_t base; uintmax_t size; bool closed = false; };";
+    const newState =
+      "struct Download { sb_r2_transfer_ctx* ctx; uintmax_t base; uintmax_t size; uintmax_t sent = 0; bool closed = false; };";
     const oldPump = `      const uintmax_t offset = res->getWriteOffset(); char chunk[65536];
         const size_t bytes = sb_r2_transfer_download_read(state->ctx, (size_t)(state->base + offset), chunk, sizeof(chunk));
         const auto result = res->tryEnd(std::string_view(chunk, bytes), state->size);
@@ -1077,52 +1186,130 @@ export async function patchUwebsockets(root: string): Promise<void> {
         if (!result.first) { res->onWritable([pump, state](uintmax_t offset) { state->sent = offset; return (*pump)(); }); return false; }
         state->sent += bytes;
       }`;
-    if (!src.includes(oldState) || !src.includes(oldPump)) throw new Error(`could not repair Porffor's direct R2 streaming bridge: anchor not found in ${file}.`);
+    if (!src.includes(oldState) || !src.includes(oldPump))
+      throw new Error(
+        `could not repair Porffor's direct R2 streaming bridge: anchor not found in ${file}.`,
+      );
     src = src.replace(oldState, newState).replace(oldPump, newPump);
     changed = true;
   }
-  const duplicatePump = "      for (;;) {\n        char chunk[65536];\n      for (;;) {\n";
+  const duplicatePump =
+    "      for (;;) {\n        char chunk[65536];\n      for (;;) {\n";
   if (src.includes(duplicatePump)) {
-    src = src.replace(duplicatePump, "      for (;;) {\n        char chunk[65536];\n");
+    src = src.replace(
+      duplicatePump,
+      "      for (;;) {\n        char chunk[65536];\n",
+    );
     changed = true;
   }
   const unclosedPump = "        state->sent += bytes;\n    };\n";
   if (src.includes(unclosedPump)) {
-    src = src.replace(unclosedPump, "        state->sent += bytes;\n      }\n    };\n");
+    src = src.replace(
+      unclosedPump,
+      "        state->sent += bytes;\n      }\n    };\n",
+    );
     changed = true;
   }
-  if (src.includes(R2_STREAMING_CACHE_MARKER) && !src.includes(R2_RANGE_HEADER_CACHE_MARKER)) {
-    const rangeHeader = "    const std::string_view range = req->getHeader(\"range\");\n";
-    if (!src.includes(rangeHeader)) throw new Error(`could not upgrade Porffor's direct R2 range-header bridge: anchor not found in ${file}.`);
-    src = src.replace("  // sb_r2_transfer_range_v1\n", "  // sb_r2_transfer_range_v1\n  // sb_r2_transfer_range_header_v2\n");
-    src = src.replace(rangeHeader, "    std::string_view range = req->getHeader(\"range\"); if (range.empty()) range = req->getHeader(\"Range\");\n");
+  if (
+    src.includes(R2_STREAMING_CACHE_MARKER) &&
+    !src.includes(R2_RANGE_HEADER_CACHE_MARKER)
+  ) {
+    const rangeHeader =
+      '    const std::string_view range = req->getHeader("range");\n';
+    if (!src.includes(rangeHeader))
+      throw new Error(
+        `could not upgrade Porffor's direct R2 range-header bridge: anchor not found in ${file}.`,
+      );
+    src = src.replace(
+      "  // sb_r2_transfer_range_v1\n",
+      "  // sb_r2_transfer_range_v1\n  // sb_r2_transfer_range_header_v2\n",
+    );
+    src = src.replace(
+      rangeHeader,
+      '    std::string_view range = req->getHeader("range"); if (range.empty()) range = req->getHeader("Range");\n',
+    );
     changed = true;
   }
-  const earlyConditionalHeaders = "    res->writeHeader(\"ETag\", etag); res->writeHeader(\"Accept-Ranges\", \"bytes\");\n";
-  if (src.includes(earlyConditionalHeaders) && src.indexOf(earlyConditionalHeaders) < src.indexOf("    const uintmax_t full_size = sb_r2_transfer_download_size(download);")) {
-    const old304 = "      sb_r2_transfer_download_close(download); res->writeStatus(\"304 Not Modified\"); res->end(); return true;";
-    const new304 = "      sb_r2_transfer_download_close(download); res->writeStatus(\"304 Not Modified\"); res->writeHeader(\"ETag\", etag); res->end(); return true;";
-    const rangeEnd = "      res->writeStatus(\"206 Partial Content\"); res->writeHeader(\"Content-Range\", content_range);\n    }\n";
-    if (!src.includes(old304) || !src.includes(rangeEnd)) throw new Error(`could not repair Porffor's direct R2 response ordering: anchor not found in ${file}.`);
-    src = src.replace(earlyConditionalHeaders, "").replace(old304, new304).replace(rangeEnd, rangeEnd + "    res->writeHeader(\"ETag\", etag); res->writeHeader(\"Accept-Ranges\", \"bytes\");\n");
+  const earlyConditionalHeaders =
+    '    res->writeHeader("ETag", etag); res->writeHeader("Accept-Ranges", "bytes");\n';
+  if (
+    src.includes(earlyConditionalHeaders) &&
+    src.indexOf(earlyConditionalHeaders) <
+      src.indexOf(
+        "    const uintmax_t full_size = sb_r2_transfer_download_size(download);",
+      )
+  ) {
+    const old304 =
+      '      sb_r2_transfer_download_close(download); res->writeStatus("304 Not Modified"); res->end(); return true;';
+    const new304 =
+      '      sb_r2_transfer_download_close(download); res->writeStatus("304 Not Modified"); res->writeHeader("ETag", etag); res->end(); return true;';
+    const rangeEnd =
+      '      res->writeStatus("206 Partial Content"); res->writeHeader("Content-Range", content_range);\n    }\n';
+    if (!src.includes(old304) || !src.includes(rangeEnd))
+      throw new Error(
+        `could not repair Porffor's direct R2 response ordering: anchor not found in ${file}.`,
+      );
+    src = src
+      .replace(earlyConditionalHeaders, "")
+      .replace(old304, new304)
+      .replace(
+        rangeEnd,
+        rangeEnd +
+          '    res->writeHeader("ETag", etag); res->writeHeader("Accept-Ranges", "bytes");\n',
+      );
     changed = true;
   }
   if (src.includes("state->sent") && src.includes(R2_DOWNLOAD_CACHE_MARKER)) {
-    const stateStart = src.indexOf("    struct Download {", src.indexOf(R2_DOWNLOAD_CACHE_MARKER));
-    const stateEnd = src.indexOf("    res->writeHeader(\"Content-Type\"", stateStart);
-    const freshStart = R2_DOWNLOAD_BRANCH_INJECT.indexOf("    struct Download {");
-    const freshEnd = R2_DOWNLOAD_BRANCH_INJECT.indexOf("    res->writeHeader(\"Content-Type\"", freshStart);
-    if (stateStart < 0 || stateEnd < 0 || freshStart < 0 || freshEnd < 0) throw new Error(`could not replace Porffor's direct R2 stream pump: anchor not found in ${file}.`);
-    src = src.slice(0, stateStart) + R2_DOWNLOAD_BRANCH_INJECT.slice(freshStart, freshEnd) + src.slice(stateEnd);
+    const stateStart = src.indexOf(
+      "    struct Download {",
+      src.indexOf(R2_DOWNLOAD_CACHE_MARKER),
+    );
+    const stateEnd = src.indexOf(
+      '    res->writeHeader("Content-Type"',
+      stateStart,
+    );
+    const freshStart = R2_DOWNLOAD_BRANCH_INJECT.indexOf(
+      "    struct Download {",
+    );
+    const freshEnd = R2_DOWNLOAD_BRANCH_INJECT.indexOf(
+      '    res->writeHeader("Content-Type"',
+      freshStart,
+    );
+    if (stateStart < 0 || stateEnd < 0 || freshStart < 0 || freshEnd < 0)
+      throw new Error(
+        `could not replace Porffor's direct R2 stream pump: anchor not found in ${file}.`,
+      );
+    src =
+      src.slice(0, stateStart) +
+      R2_DOWNLOAD_BRANCH_INJECT.slice(freshStart, freshEnd) +
+      src.slice(stateEnd);
     changed = true;
   }
-  if (src.includes("writable_offset") && src.includes(R2_DOWNLOAD_CACHE_MARKER)) {
-    const stateStart = src.indexOf("    struct Download {", src.indexOf(R2_DOWNLOAD_CACHE_MARKER));
-    const stateEnd = src.indexOf("    res->writeHeader(\"Content-Type\"", stateStart);
+  if (
+    src.includes("writable_offset") &&
+    src.includes(R2_DOWNLOAD_CACHE_MARKER)
+  ) {
+    const stateStart = src.indexOf(
+      "    struct Download {",
+      src.indexOf(R2_DOWNLOAD_CACHE_MARKER),
+    );
+    const stateEnd = src.indexOf(
+      '    res->writeHeader("Content-Type"',
+      stateStart,
+    );
     const freshStart = R2_TRANSFER_INJECT.indexOf("    struct Download {");
-    const freshEnd = R2_TRANSFER_INJECT.indexOf("    res->writeHeader(\"Content-Type\"", freshStart);
-    if (stateStart < 0 || stateEnd < 0 || freshStart < 0 || freshEnd < 0) throw new Error(`could not restore Porffor's direct R2 stream pump: anchor not found in ${file}.`);
-    src = src.slice(0, stateStart) + R2_TRANSFER_INJECT.slice(freshStart, freshEnd) + src.slice(stateEnd);
+    const freshEnd = R2_TRANSFER_INJECT.indexOf(
+      '    res->writeHeader("Content-Type"',
+      freshStart,
+    );
+    if (stateStart < 0 || stateEnd < 0 || freshStart < 0 || freshEnd < 0)
+      throw new Error(
+        `could not restore Porffor's direct R2 stream pump: anchor not found in ${file}.`,
+      );
+    src =
+      src.slice(0, stateStart) +
+      R2_TRANSFER_INJECT.slice(freshStart, freshEnd) +
+      src.slice(stateEnd);
     changed = true;
   }
   for (const [marker, anchor, inject, what] of UWS_EDITS) {
@@ -1140,14 +1327,20 @@ export async function patchUwebsockets(root: string): Promise<void> {
 }
 
 const CLASS_SELF_IMPORT_ANCHOR = "import link from './modules.js';";
-const CLASS_SELF_IMPORT_INJECT = "import link from './modules.js';\nimport sbClassSelf from './sb-class-self.js';";
-const CLASS_SELF_CALL_ANCHOR = "  if (ast._ts) globalThis.typedInput = Prefs.optTypes;";
-const CLASS_SELF_CALL_INJECT = "  sbClassSelf(ast); // sproutboat #256\n  if (ast._ts) globalThis.typedInput = Prefs.optTypes;";
+const CLASS_SELF_IMPORT_INJECT =
+  "import link from './modules.js';\nimport sbClassSelf from './sb-class-self.js';";
+const CLASS_SELF_CALL_ANCHOR =
+  "  if (ast._ts) globalThis.typedInput = Prefs.optTypes;";
+const CLASS_SELF_CALL_INJECT =
+  "  sbClassSelf(ast); // sproutboat #256\n  if (ast._ts) globalThis.typedInput = Prefs.optTypes;";
 const CLASS_SELF_MARKER = "sproutboat #256";
 
 /** #256 — see CLASS_SELF_HELPER. */
 export async function patchClassSelfName(root: string): Promise<void> {
-  await writeFile(resolve(root, "compiler/sb-class-self.js"), CLASS_SELF_HELPER);
+  await writeFile(
+    resolve(root, "compiler/sb-class-self.js"),
+    CLASS_SELF_HELPER,
+  );
   const file = resolve(root, "compiler/parse.js");
   let src = await readFile(file, "utf8");
   if (src.includes(CLASS_SELF_MARKER)) return;
@@ -1155,9 +1348,14 @@ export async function patchClassSelfName(root: string): Promise<void> {
     [CLASS_SELF_IMPORT_ANCHOR, "import"],
     [CLASS_SELF_CALL_ANCHOR, "call"],
   ] as const) {
-    if (!src.includes(anchor)) throw new Error(`could not patch Porffor's class self-name rewrite (${what}): anchor not found in ${file}`);
+    if (!src.includes(anchor))
+      throw new Error(
+        `could not patch Porffor's class self-name rewrite (${what}): anchor not found in ${file}`,
+      );
   }
-  src = src.replace(CLASS_SELF_IMPORT_ANCHOR, CLASS_SELF_IMPORT_INJECT).replace(CLASS_SELF_CALL_ANCHOR, CLASS_SELF_CALL_INJECT);
+  src = src
+    .replace(CLASS_SELF_IMPORT_ANCHOR, CLASS_SELF_IMPORT_INJECT)
+    .replace(CLASS_SELF_CALL_ANCHOR, CLASS_SELF_CALL_INJECT);
   await writeFile(file, src);
 }
 
@@ -1169,9 +1367,24 @@ async function patchCompilerArgs(root: string): Promise<void> {
   for (const [marker, anchor, inject, what] of [
     [LINK_MARKER, LINK_ANCHOR, LINK_INJECT, "extra link args"],
     [CFLAGS_MARKER, CFLAGS_ANCHOR, CFLAGS_INJECT, "extra compiler flags"],
-    [FP_CONTRACT_MARKER, FP_CONTRACT_ANCHOR, FP_CONTRACT_INJECT, "floating-point contraction"],
-    [HTTP10_IMPORT_MARKER, HTTP10_IMPORT_ANCHOR, HTTP10_IMPORT_INJECT, "HTTP/1.0 helper import (#236)"],
-    [HTTP10_CALL_MARKER, HTTP10_CALL_ANCHOR, HTTP10_CALL_INJECT, "HTTP/1.0 parser edit (#236)"],
+    [
+      FP_CONTRACT_MARKER,
+      FP_CONTRACT_ANCHOR,
+      FP_CONTRACT_INJECT,
+      "floating-point contraction",
+    ],
+    [
+      HTTP10_IMPORT_MARKER,
+      HTTP10_IMPORT_ANCHOR,
+      HTTP10_IMPORT_INJECT,
+      "HTTP/1.0 helper import (#236)",
+    ],
+    [
+      HTTP10_CALL_MARKER,
+      HTTP10_CALL_ANCHOR,
+      HTTP10_CALL_INJECT,
+      "HTTP/1.0 parser edit (#236)",
+    ],
   ] as const) {
     if (src.includes(marker)) continue;
     const at = src.indexOf(anchor);
@@ -1185,7 +1398,9 @@ async function patchCompilerArgs(root: string): Promise<void> {
     // Porffor's module-build cache includes them in its compiler command.
     src =
       marker !== LINK_MARKER
-        ? src.slice(0, at + anchor.length) + inject + src.slice(at + anchor.length)
+        ? src.slice(0, at + anchor.length) +
+          inject +
+          src.slice(at + anchor.length)
         : src.slice(0, at) + inject + src.slice(at);
     changed = true;
   }
@@ -1197,12 +1412,23 @@ export async function patchDateParser(root: string): Promise<void> {
   const src = await readFile(file, "utf8");
   if (src.includes(DATE_PARSER_MARKER)) return;
   const start = src.indexOf("export const __ecma262_ParseDTSF");
-  const end = src.indexOf("// RFC 7231 or Date.prototype.toString() parser", start);
-  if (start < 0 || end < 0) throw new Error(`could not find Porffor's ISO date parser in ${file}`);
+  const end = src.indexOf(
+    "// RFC 7231 or Date.prototype.toString() parser",
+    start,
+  );
+  if (start < 0 || end < 0)
+    throw new Error(`could not find Porffor's ISO date parser in ${file}`);
   const parser = src.slice(start, end);
   if (!parser.includes(DATE_PARSER_ANCHOR))
-    throw new Error(`could not patch Porffor's ISO date parser: anchor not found in ${file}`);
-  await writeFile(file, src.slice(0, start) + parser.replace(DATE_PARSER_ANCHOR, DATE_PARSER_INJECT) + src.slice(end));
+    throw new Error(
+      `could not patch Porffor's ISO date parser: anchor not found in ${file}`,
+    );
+  await writeFile(
+    file,
+    src.slice(0, start) +
+      parser.replace(DATE_PARSER_ANCHOR, DATE_PARSER_INJECT) +
+      src.slice(end),
+  );
 }
 
 /** #168: keep a promise resolving to null out of the `then` probe. */
@@ -1211,7 +1437,9 @@ export async function patchPromiseResolveNull(root: string): Promise<void> {
   const src = await readFile(file, "utf8");
   if (src.includes(PROMISE_NULL_MARKER)) return;
   if (!src.includes(PROMISE_NULL_ANCHOR))
-    throw new Error(`could not patch Porffor's promise resolve for null: anchor not found in ${file}`);
+    throw new Error(
+      `could not patch Porffor's promise resolve for null: anchor not found in ${file}`,
+    );
   await writeFile(file, src.replace(PROMISE_NULL_ANCHOR, PROMISE_NULL_INJECT));
 }
 
@@ -1221,51 +1449,55 @@ export async function patchReplaceAll(root: string): Promise<void> {
   let src = await readFile(file, "utf8");
   if (src.includes(REPLACE_ALL_MARKER)) return;
   const start = src.indexOf("export const __Porffor_string_replaceAll = ");
-  const end = src.indexOf("export const __String_prototype_replaceAll = ", start);
-  if (start < 0 || end < 0) throw new Error(`could not find Porffor's replaceAll in ${file}`);
+  const end = src.indexOf(
+    "export const __String_prototype_replaceAll = ",
+    start,
+  );
+  if (start < 0 || end < 0)
+    throw new Error(`could not find Porffor's replaceAll in ${file}`);
   let body = src.slice(start, end);
   for (const [anchor, inject] of REPLACE_ALL_EDITS) {
-    if (!body.includes(anchor)) throw new Error(`could not patch Porffor's replaceAll: anchor not found in ${file}`);
+    if (!body.includes(anchor))
+      throw new Error(
+        `could not patch Porffor's replaceAll: anchor not found in ${file}`,
+      );
     body = body.replace(anchor, inject);
   }
   src = src.slice(0, start) + body + src.slice(end);
   await writeFile(file, src);
 }
 
-/** #238: modular typed-array stores. Before the precompile so builtins get it too. */
-export async function patchTypedArrayStore(root: string): Promise<void> {
-  const file = resolve(root, "compiler/codegen.js");
-  let src = await readFile(file, "utf8");
-  let changed = false;
-  for (const [marker, anchor, inject, what] of [
-    [TA_GET_MARKER, TA_GET_ANCHOR, TA_GET_INJECT, "typed-array read bounds"],
-    [TA_SET_BOUNDS_MARKER, TA_SET_BOUNDS_ANCHOR, TA_SET_BOUNDS_INJECT, "typed-array write bounds"],
-  ] as const) {
-    if (src.includes(marker)) continue;
-    if (!src.includes(anchor)) throw new Error(`could not patch Porffor's ${what}: anchor not found in ${file}`);
-    src = src.replace(anchor, inject);
-    changed = true;
-  }
-  if (changed) await writeFile(file, src);
-}
-
 /** Register elided local function expressions so inference uses their lexical binding. */
 export async function patchLocalFunctionTypes(root: string): Promise<void> {
   const file = resolve(root, "compiler/codegen.js");
   let src = await readFile(file, "utf8");
-  const marker = "sproutboat: preserve lexical types for direct-only local functions";
+  const marker =
+    "sproutboat: preserve lexical types for direct-only local functions";
   if (src.includes(marker)) return;
-  const anchor = "if (!hoistRead && directCallOnlyFunctionBinding(scope, kind, name, pattern, func)) {\n        return valUndefined();";
-  if (!src.includes(anchor)) throw new Error(`could not patch Porffor local function types: anchor not found in ${file}`);
-  src = src.replace(anchor,
+  const anchor =
+    "if (!hoistRead && directCallOnlyFunctionBinding(scope, kind, name, pattern, func)) {\n        return valUndefined();";
+  if (!src.includes(anchor))
+    throw new Error(
+      `could not patch Porffor local function types: anchor not found in ${file}`,
+    );
+  src = src.replace(
+    anchor,
     "if (!hoistRead && directCallOnlyFunctionBinding(scope, kind, name, pattern, func)) {\n" +
-    `        // ${marker}\n` +
-    "        bindNamedFunction(scope, name, func);\n        return valUndefined();");
+      `        // ${marker}\n` +
+      "        bindNamedFunction(scope, name, func);\n        return valUndefined();",
+  );
   // resolveNamedFunction already handles unambiguous global fallbacks. Falling
   // back again can infer a type from an unrelated same-named function.
-  const fallback = "const func = resolveNamedFunction(scope, name) ?? funcByName(name);";
-  if (!src.includes(fallback)) throw new Error(`could not patch Porffor local function type fallback: anchor not found in ${file}`);
-  src = src.replace(fallback, "const func = resolveNamedFunction(scope, name);");
+  const fallback =
+    "const func = resolveNamedFunction(scope, name) ?? funcByName(name);";
+  if (!src.includes(fallback))
+    throw new Error(
+      `could not patch Porffor local function type fallback: anchor not found in ${file}`,
+    );
+  src = src.replace(
+    fallback,
+    "const func = resolveNamedFunction(scope, name);",
+  );
   await writeFile(file, src);
 }
 
@@ -1278,10 +1510,16 @@ export async function patchUint8ArrayBase64(root: string): Promise<void> {
   const edits = [
     ["let alphabet: string =", "let alphabet: any ="],
     ["let lastChunkHandling: string =", "let lastChunkHandling: any ="],
-    ["const fullChunks: i32 = (len / 3) * 3;", "const fullChunks: i32 = ((len / 3) | 0) * 3;"],
+    [
+      "const fullChunks: i32 = (len / 3) * 3;",
+      "const fullChunks: i32 = ((len / 3) | 0) * 3;",
+    ],
   ] as const;
   for (const [anchor, replacement] of edits) {
-    if (!src.includes(anchor)) throw new Error(`could not patch Porffor base64: anchor not found in ${file}`);
+    if (!src.includes(anchor))
+      throw new Error(
+        `could not patch Porffor base64: anchor not found in ${file}`,
+      );
     src = src.replaceAll(anchor, replacement);
   }
   await writeFile(file, `// ${marker}\n${src}`);
@@ -1302,8 +1540,12 @@ export async function precompileBuiltins(root: string): Promise<void> {
     new Response(child.stdout).text(),
     new Response(child.stderr).text(),
   ]);
-  if (code !== 0) throw new Error(`could not precompile Porffor's patched builtins: ${stderr || stdout}`);
-  if ((await readFile(table)).length === 0) throw new Error(`Porffor precompile produced an empty ${table}`);
+  if (code !== 0)
+    throw new Error(
+      `could not precompile Porffor's patched builtins: ${stderr || stdout}`,
+    );
+  if ((await readFile(table)).length === 0)
+    throw new Error(`Porffor precompile produced an empty ${table}`);
 }
 
 /** The native-fetch server source: $PORT support + the #165 console sink. Exported for tests. */
@@ -1320,7 +1562,8 @@ export async function patchRenderJs(root: string): Promise<void> {
           "Porffor's native-fetch renderer changed. See https://github.com/baronunread/sproutboat/tree/main/patches/upstream.",
       );
     }
-    src = src.slice(0, at + anchor.length) + inject + src.slice(at + anchor.length);
+    src =
+      src.slice(0, at + anchor.length) + inject + src.slice(at + anchor.length);
     changed = true;
   }
 
@@ -1341,24 +1584,678 @@ export async function patchRenderJs(root: string): Promise<void> {
   if (changed) await writeFile(file, src);
 }
 
+/** Reclaim a burst's dead heap and oversized GC workspace after a quiet period. */
+export async function patchQuietCollection(root: string): Promise<void> {
+  const renderFile = resolve(root, "compiler/render.js");
+  const shimFile = resolve(root, "compiler/uwebsockets.js");
+  let render = await readFile(renderFile, "utf8");
+  let shim = await readFile(shimFile, "utf8");
+  const marker = "// sproutboat: reclaim large idle heaps";
+  if (!render.includes(marker)) {
+    const start = render.indexOf(
+      "void porf_native_fetch_collect_normal_from(void* stack_top) {",
+    );
+    const end = render.indexOf(
+      "\nint porf_native_fetch_should_collect(void)",
+      start,
+    );
+    if (start < 0 || end < 0)
+      throw new Error("Porffor quiet-GC renderer anchor missing");
+    const normal = render.slice(start, end);
+    if (
+      !normal.includes("porf_gc_collect_idle();") ||
+      !normal.includes("  porf_c_stack_top = prev_stack_top;")
+    )
+      throw new Error("Porffor quiet-GC collector changed");
+    const quiet = normal
+      .replace("collect_normal_from", "collect_quiet_from")
+      .replace(
+        "if (porf_heap_base == 0) return;",
+        "if (!porf_native_fetch_needs_quiet_collect()) return;",
+      )
+      .replace("porf_gc_collect_idle();", "porf_gc_collect(0);")
+      .replace(
+        "  porf_c_stack_top = prev_stack_top;",
+        `  // The mark queue is empty after collection; its capacity is scratch, not live roots.
+  if (porf_gc_mark_queue_len == 0 && porf_gc_mark_queue_cap > 4096) {
+    free(porf_gc_mark_queue);
+    porf_gc_mark_queue = NULL;
+    porf_gc_mark_queue_cap = 0;
+  }
+  porf_c_stack_top = prev_stack_top;`,
+      );
+    const needs = `int porf_native_fetch_needs_quiet_collect(void) {
+\${gcEnabled ? '  return porf_heap_base != 0 && ((u64)porf_heap_top - (u64)porf_heap_base > 8ull * 1024ull * 1024ull || porf_gc_mark_queue_cap > 65536);' : '  return 0;'}
+}
+`;
+    render =
+      render.slice(0, end) +
+      "\n" +
+      marker +
+      "\n" +
+      needs +
+      quiet +
+      render.slice(end);
+  }
+  if (!shim.includes(marker)) {
+    const declaration =
+      "void porf_native_fetch_collect_normal_from(void* stack_top);";
+    const start = shim.indexOf("static void collect_after_request(void) {");
+    const end = shim.indexOf("\n}\n", start);
+    if (!shim.includes(declaration) || start < 0 || end < 0)
+      throw new Error("Porffor quiet-GC native shim anchor missing");
+    const original = shim.slice(start, end);
+    if (
+      !original.includes(
+        "porf_native_fetch_collect_normal_from((void*)&porf_stack_anchor);",
+      )
+    )
+      throw new Error("Porffor normal request collection changed");
+    const timer = `${marker}
+static us_timer_t* sb_quiet_gc_timer = nullptr;
+static void sb_collect_quiet(struct us_timer_t*) {
+  volatile int stack_anchor = 0;
+  porf_native_fetch_collect_quiet_from((void*)&stack_anchor);
+}
+`;
+    // Preserve normal request collection unconditionally; only the extra timer is guarded.
+    const schedule = `
+  if (porf_native_fetch_needs_quiet_collect()) {
+    if (!sb_quiet_gc_timer) sb_quiet_gc_timer = us_create_timer((struct us_loop_t*)uWS::Loop::get(), 0, 0);
+    if (sb_quiet_gc_timer) us_timer_set(sb_quiet_gc_timer, sb_collect_quiet, 500, 0);
+  }`;
+    shim = shim.slice(0, start) + timer + original + schedule + shim.slice(end);
+    shim = shim.replace(
+      declaration,
+      declaration +
+        "\nvoid porf_native_fetch_collect_quiet_from(void* stack_top);\nint porf_native_fetch_needs_quiet_collect(void);",
+    );
+  }
+  await Promise.all([writeFile(renderFile, render), writeFile(shimFile, shim)]);
+}
+
 /**
  * Apply every patch to a Porffor checkout at `root` (the directory that holds
  * `compiler/` and `runtime/`). Idempotent per process and per marker, so it is
  * safe to call on every build. Callers pass an explicit root — `ensurePorffor`
  * right after extraction, the compile path against its resolved checkout.
  */
+const RESPONSE_DEFAULTS_MARKER =
+  "// sproutboat: Fetch default content type for text bodies";
+const RESPONSE_DEFAULTS_ANCHOR =
+  "class Response {\n  constructor(body = null, init = undefined) {\n    this.body = body;\n    this.status = Number(init?.status ?? 200);\n    this.headers = new Headers(init?.headers);\n";
+
+/**
+ * Fetch's extract-a-body step gives a string body `text/plain;charset=UTF-8` unless the
+ * caller set a content type (workerd does). Porffor's Response sent none, so
+ * `new Response("hi")` reached clients untyped.
+ */
+export async function patchResponseDefaults(root: string): Promise<void> {
+  const file = resolve(root, "runtime/fetch-globals.js");
+  const src = await readFile(file, "utf8");
+  if (src.includes(RESPONSE_DEFAULTS_MARKER) || src.includes("sproutboat: Fetch-spec Request and Response")) return;
+  if (!src.includes(RESPONSE_DEFAULTS_ANCHOR))
+    throw new Error(
+      `could not patch Porffor's Response defaults: anchor not found in ${file}`,
+    );
+  await writeFile(
+    file,
+    src.replace(
+      RESPONSE_DEFAULTS_ANCHOR,
+      RESPONSE_DEFAULTS_ANCHOR +
+        `    ${RESPONSE_DEFAULTS_MARKER}\n` +
+        "    if (typeof body === 'string' && !this.headers.has('content-type')) this.headers.set('content-type', 'text/plain;charset=UTF-8');\n",
+    ),
+  );
+}
+
+const URL_CLASS_START = "class URL {\n  constructor(input) {\n";
+const URL_CLASS_END = "\nclass Request {";
+const URL_CLASS_MARKER = "sproutboat: WHATWG-style URL";
+
+/**
+ * Replaces Porffor's URL (href, origin, pathname and search only; no base argument, no
+ * setters but pathname, no hash) with the WHATWG-style class in url-class.ts.
+ */
+export async function patchURLClass(root: string): Promise<void> {
+  const file = resolve(root, "runtime/fetch-globals.js");
+  const src = await readFile(file, "utf8");
+  if (src.includes(URL_CLASS_MARKER)) return;
+  const start = src.indexOf(URL_CLASS_START);
+  const end = start === -1 ? -1 : src.indexOf(URL_CLASS_END, start);
+  if (end === -1)
+    throw new Error(`could not patch Porffor's URL: anchor not found in ${file}`);
+  await writeFile(file, src.slice(0, start) + URL_CLASS_SOURCE + src.slice(end + 1));
+}
+
+const HEADERS_ARRAY_ANCHOR =
+  "    if (Porffor.type(init.entries) == Porffor.TYPES.function) {\n      this._entries = Porffor.array.new(8);\n      for (const entry of init.entries()) {";
+const HEADERS_ARRAY_INJECT =
+  "    if (!Array.isArray(init) && Porffor.type(init.entries) == Porffor.TYPES.function) {\n      this._entries = Porffor.array.new(8);\n      for (const entry of init.entries()) {";
+
+/**
+ * `new Headers([["a", "1"]])`: arrays also have entries() (yielding [index, pair]), and
+ * Porffor checked that first, so a list of pairs became headers named "0", "1"...
+ * Arrays now reach the sequence branch below it.
+ */
+export async function patchHeadersArrayInit(root: string): Promise<void> {
+  const file = resolve(root, "runtime/fetch-globals.js");
+  const src = await readFile(file, "utf8");
+  if (src.includes(HEADERS_ARRAY_INJECT) || src.includes("sproutboat: Fetch-spec Headers")) return;
+  if (!src.includes(HEADERS_ARRAY_ANCHOR))
+    throw new Error(
+      `could not patch Porffor's Headers array init: anchor not found in ${file}`,
+    );
+  await writeFile(
+    file,
+    src.replace(HEADERS_ARRAY_ANCHOR, HEADERS_ARRAY_INJECT),
+  );
+}
+
+// baronunread/sproutboat#286: Map.groupBy is missing (Object.groupBy exists). Same
+// shape as __Object_groupBy, keyed by SameValueZero through the Map itself.
+const MAP_GROUPBY_MARKER = "sproutboat #286: Map.groupBy";
+const MAP_GROUPBY_SOURCE =
+  "\n// sproutboat #286: Map.groupBy\n" +
+  "export const __Map_groupBy = (items: any, callbackFn: any): Map => {\n" +
+  "  const out: Map = __Porffor_hashtableNew(true);\n" +
+  "  Porffor.IR.gcBarrier(out, Porffor.TYPES.map);\n" +
+  "  let i: i32 = 0;\n" +
+  "  for (const x of items) {\n" +
+  "    const k: any = callbackFn(x, i++);\n" +
+  "    if (!Porffor.callThis(__Map_prototype_has, out, k)) Porffor.callThis(__Map_prototype_set, out, k, Porffor.array.new(4));\n" +
+  "    Porffor.array.fastPush(Porffor.callThis(__Map_prototype_get, out, k), x);\n" +
+  "  }\n" +
+  "  return out;\n" +
+  "};\n";
+
+/** #286: add Map.groupBy. Before the precompile, which compiles it with the other builtins. */
+export async function patchMapGroupBy(root: string): Promise<void> {
+  const file = resolve(root, "compiler/builtins/map.ts");
+  const src = await readFile(file, "utf8");
+  if (src.includes(MAP_GROUPBY_MARKER)) return;
+  if (!src.includes("export const Map = function (iterable: any): Map {"))
+    throw new Error(`could not patch Porffor's Map.groupBy: anchor not found in ${file}`);
+  if (src.includes("export const __Map_groupBy"))
+    throw new Error(`Porffor now defines Map.groupBy itself: drop patchMapGroupBy (${file})`);
+  await writeFile(file, src.trimEnd() + "\n" + MAP_GROUPBY_SOURCE);
+}
+
+// baronunread/sproutboat#286: a private field (#x) is stored as an ordinary property
+// named "__#x", installed like a public field, so Object.keys, for-in and
+// JSON.stringify listed it. Install private fields the way methods are installed:
+// writable and configurable but not enumerable. Object.getOwnPropertyNames still
+// sees the internal name.
+const PRIVATE_FIELD_MARKER = "sproutboat #286: private fields";
+const PRIVATE_FIELD_EDITS: [string, string][] = [
+  [
+    "        builtinCall(func, '__Porffor_object_class_value', [\n",
+    "        // sproutboat #286: private fields are not enumerable\n" +
+      "        builtinCall(func, x.key?.type === 'PrivateIdentifier' ? '__Porffor_object_class_method' : '__Porffor_object_class_value', [\n",
+  ],
+  [
+    "      if (kind === 'get' || kind === 'set') initKind = kind;\n",
+    "      if (kind === 'get' || kind === 'set') initKind = kind;\n" +
+      "      if (initKind === 'value' && x.key?.type === 'PrivateIdentifier') initKind = 'method'; // sproutboat #286: private fields\n",
+  ],
+];
+
+export async function patchPrivateFieldsHidden(root: string): Promise<void> {
+  const file = resolve(root, "compiler/codegen.js");
+  let src = await readFile(file, "utf8");
+  if (src.includes(PRIVATE_FIELD_MARKER)) return;
+  for (const [anchor, inject] of PRIVATE_FIELD_EDITS) {
+    if (src.split(anchor).length !== 2)
+      throw new Error(`could not patch Porffor's private fields: anchor not found in ${file}`);
+    src = src.replace(anchor, inject);
+  }
+  await writeFile(file, src);
+}
+
+// baronunread/sproutboat#287 (sproutd B9/B13): native-fetch mode runs frequent full
+// collections, and each returned its free pages to the OS (porf_gc_discard_free_runs),
+// so the next large allocation faulted them back in: allocation-heavy handlers ran up
+// to 4x slower than plain Porffor. Full collections under load now keep their free
+// pages, and the idle quiet collection returns them. The idle gate also opens when
+// anything was claimed or promoted since the last full collection, so a small sprout
+// that never reaches the 16 MiB / 8 MiB full-collection triggers still gives back its
+// promoted garbage. Same edits as sproutd's deferred discard and idle return.
+const DEFERRED_DISCARD_MARKER = "static i32 porf_gc_discard_pending = 0;";
+const DEFERRED_DISCARD_EDITS: [string, string][] = [
+  [
+    "static i32 porf_gc_mark_queue_cap = 0;",
+    "static i32 porf_gc_mark_queue_cap = 0;\n// sproutboat #287: discard free runs only in the idle collection\nstatic i32 porf_gc_discard_now = 0;\n" +
+      DEFERRED_DISCARD_MARKER,
+  ],
+  [
+    "    porf_gc_discard_free_runs();\n",
+    "    if (porf_gc_discard_now) porf_gc_discard_free_runs(); else porf_gc_discard_pending = 1;\n",
+  ],
+  [
+    "porf_gc_mark_queue_cap > 65536);' : '  return 0;'",
+    "porf_gc_mark_queue_cap > 65536 || porf_gc_discard_pending || porf_gc_claimed_since_full > 0 || porf_gc_promoted_since_full > 0);' : '  return 0;'",
+  ],
+  [
+    "  porf_c_stack_top = stack_top;\n  porf_gc_collect(0);\n  // The mark queue is empty",
+    "  porf_c_stack_top = stack_top;\n  porf_gc_discard_now = 1;\n  porf_gc_collect(0);\n  porf_gc_discard_now = 0;\n  porf_gc_discard_pending = 0;\n  // The mark queue is empty",
+  ],
+];
+
+/** #287: deferred discard and idle return. After patchQuietCollection, which adds the quiet collector. */
+export async function patchDeferredDiscard(root: string): Promise<void> {
+  const file = resolve(root, "compiler/render.js");
+  let src = await readFile(file, "utf8");
+  if (src.includes(DEFERRED_DISCARD_MARKER)) return;
+  for (const [anchor, inject] of DEFERRED_DISCARD_EDITS) {
+    if (src.split(anchor).length !== 2)
+      throw new Error(`could not patch Porffor's deferred discard: anchor not found in ${file}`);
+    src = src.replace(anchor, inject);
+  }
+  await writeFile(file, src);
+}
+
+// sproutd B16: String.prototype.repeat copied the source once per repetition, so
+// "ab".repeat(300000) made 300,000 two-byte copies (about 60 MB/s; a proof fixture
+// spent 64% of its load time here). Copy once, then double the filled prefix onto
+// itself: log2(count) copies. Same for the UTF-16 and Latin-1 variants, which
+// share the loop text.
+const REPEAT_LOOP =
+  "  for (let i: i32 = 0; i < count; i++) {\n" +
+  "    Porffor.IR.copy(Porffor.IR.ptr(out) + 4 + i * thisLen, Porffor.IR.ptr(this) + 4, thisLen);\n" +
+  "  }\n";
+const REPEAT_MARKER = "sproutboat B16: doubling repeat";
+const REPEAT_DOUBLING =
+  "  // sproutboat B16: doubling repeat\n" +
+  "  const total: i32 = thisLen * count;\n" +
+  "  if (total > 0) {\n" +
+  "    Porffor.IR.copy(Porffor.IR.ptr(out) + 4, Porffor.IR.ptr(this) + 4, thisLen);\n" +
+  "    let filled: i32 = thisLen;\n" +
+  "    while (filled * 2 <= total) {\n" +
+  "      Porffor.IR.copy(Porffor.IR.ptr(out) + 4 + filled, Porffor.IR.ptr(out) + 4, filled);\n" +
+  "      filled *= 2;\n" +
+  "    }\n" +
+  "    if (filled < total) Porffor.IR.copy(Porffor.IR.ptr(out) + 4 + filled, Porffor.IR.ptr(out) + 4, total - filled);\n" +
+  "  }\n";
+
+/** B16: doubling String.prototype.repeat. Before the precompile, which compiles it. */
+export async function patchRepeatDoubling(root: string): Promise<void> {
+  const file = resolve(root, "compiler/builtins/string.ts");
+  const src = await readFile(file, "utf8");
+  if (src.includes(REPEAT_MARKER)) return;
+  if (src.split(REPEAT_LOOP).length !== 3)
+    throw new Error(`could not patch Porffor's String.prototype.repeat: anchor not found twice in ${file}`);
+  await writeFile(file, src.replaceAll(REPEAT_LOOP, REPEAT_DOUBLING));
+}
+
+// JSON.stringify of a cyclic object recursed until the native stack overflowed: the
+// process died (SIGBUS/SIGSEGV) instead of throwing, so one request could take a
+// worker down (found by the W2 conformance suite). The replacer path already checks
+// cycles; the plain serializer now keeps its own ancestor stack and throws the same
+// TypeError. Arrays and objects push on entry and pop on exit; JSON.stringify clears
+// the stack first, so a throw mid-serialization leaves nothing behind.
+const JSON_CYCLE_MARKER = "sproutboat: JSON cycle check";
+const JSON_CYCLE_EDITS: [string, string, number][] = [
+  [
+    "let __Porffor_json_bufLimit: i32 = 0;\n",
+    "let __Porffor_json_bufLimit: i32 = 0;\n" +
+      "// sproutboat: JSON cycle check\n" +
+      "let __Porffor_json_ancestors: any = 0;\n" +
+      "export const __Porffor_json_enter = (value: any): void => {\n" +
+      "  if (__Porffor_json_ancestors === 0) __Porffor_json_ancestors = Porffor.array.new(8);\n" +
+      "  const stack: any[] = __Porffor_json_ancestors;\n" +
+      "  if (stack.includes(value)) {\n" +
+      "    stack.length = 0;\n" +
+      "    throw new TypeError('Converting circular structure to JSON');\n" +
+      "  }\n" +
+      "  Porffor.array.fastPush(stack, value);\n" +
+      "};\n" +
+      "export const __Porffor_json_leave = (): void => {\n" +
+      "  const stack: any[] = __Porffor_json_ancestors;\n" +
+      "  stack.length = stack.length - 1;\n" +
+      "};\n",
+    1,
+  ],
+  ["    depth += 1;\n", "    depth += 1;\n    __Porffor_json_enter(value);\n", 2],
+  ["    depth -= 1;\n", "    __Porffor_json_leave();\n    depth -= 1;\n", 2],
+  [
+    "  let out: i32 = __Porffor_json_serialize(buffer, value, 0, space);\n",
+    "  if (__Porffor_json_ancestors !== 0) (__Porffor_json_ancestors as any[]).length = 0;\n" +
+      "  let out: i32 = __Porffor_json_serialize(buffer, value, 0, space);\n",
+    1,
+  ],
+];
+
+/** JSON.stringify throws on cycles instead of overflowing the stack. Before the precompile. */
+export async function patchJsonCycles(root: string): Promise<void> {
+  const file = resolve(root, "compiler/builtins/json.ts");
+  let src = await readFile(file, "utf8");
+  if (src.includes(JSON_CYCLE_MARKER)) return;
+  for (const [anchor, inject, count] of JSON_CYCLE_EDITS) {
+    if (src.split(anchor).length !== count + 1)
+      throw new Error(`could not patch Porffor's JSON cycle check: anchor not found ${count}x in ${file}`);
+    src = src.replaceAll(anchor, inject);
+  }
+  await writeFile(file, src);
+}
+
+// Object.prototype.toString gave "[object Object]" for typed arrays: their lazily
+// built prototypes have no toStringTag, and the fallback list of builtin tags left
+// them out (W2 conformance; V8 gives "[object Uint8Array]").
+const TA_TAG_MARKER = "sproutboat: typed array toStringTag";
+const TA_TAG_ANCHOR = "  return '[object ' + builtinTag + ']';\n};\n";
+const TA_TAG_INJECT =
+  "  // sproutboat: typed array toStringTag\n" +
+  "  if (Porffor.fastAnd(tag === undefined, t >= Porffor.TYPES.uint8clampedarray, t <= Porffor.TYPES.float64array)) {\n" +
+  "    if (t == Porffor.TYPES.uint8clampedarray) builtinTag = 'Uint8ClampedArray';\n    else if (t == Porffor.TYPES.uint8array) builtinTag = 'Uint8Array';\n    else if (t == Porffor.TYPES.int8array) builtinTag = 'Int8Array';\n    else if (t == Porffor.TYPES.uint16array) builtinTag = 'Uint16Array';\n    else if (t == Porffor.TYPES.int16array) builtinTag = 'Int16Array';\n    else if (t == Porffor.TYPES.uint32array) builtinTag = 'Uint32Array';\n    else if (t == Porffor.TYPES.int32array) builtinTag = 'Int32Array';\n    else if (t == Porffor.TYPES.biguint64array) builtinTag = 'BigUint64Array';\n    else if (t == Porffor.TYPES.bigint64array) builtinTag = 'BigInt64Array';\n    else if (t == Porffor.TYPES.float32array) builtinTag = 'Float32Array';\n    else if (t == Porffor.TYPES.float64array) builtinTag = 'Float64Array';\n" +
+  "  }\n" +
+  TA_TAG_ANCHOR;
+
+/** Typed arrays get their own toString tag. Before the precompile. */
+export async function patchTypedArrayTag(root: string): Promise<void> {
+  const file = resolve(root, "compiler/builtins/object.ts");
+  const src = await readFile(file, "utf8");
+  if (src.includes(TA_TAG_MARKER)) return;
+  if (src.split(TA_TAG_ANCHOR).length !== 2)
+    throw new Error(`could not patch Porffor's typed array toStringTag: anchor not found in ${file}`);
+  await writeFile(file, src.replace(TA_TAG_ANCHOR, TA_TAG_INJECT));
+}
+
+// console.log coloured numbers, booleans and objects with ANSI escapes even when
+// stdout was a file or pipe, so sproutd's per-app logs (B21) and piped sprout output
+// were full of \x1b[33m. Colour only when stdout is a terminal, as Node and Bun do.
+const CONSOLE_COLOR_MARKER = "sproutboat: console colours only on a terminal";
+const CONSOLE_COLOR_ANCHOR = "export const __Porffor_consolePrint = (arg: any): void => {\n";
+const CONSOLE_COLOR_PRINT = "  __Porffor_print(arg);\n};\n";
+const CONSOLE_COLOR_HELPER =
+  "// sproutboat: console colours only on a terminal\n" +
+  "let __Porffor_console_tty: i32 = -1;\n" +
+  "export const __Porffor_consoleColors = (): boolean => {\n" +
+  "  if (__Porffor_console_tty < 0) {\n" +
+  "    let tty: i32 = 0;\n" +
+  "    Porffor.c`tty = isatty(1) ? 1 : 0;`;\n" +
+  "    __Porffor_console_tty = tty;\n" +
+  "  }\n" +
+  "  return __Porffor_console_tty == 1;\n" +
+  "};\n\n";
+
+/** console colours only when stdout is a terminal. Before the precompile. */
+export async function patchConsoleColors(root: string): Promise<void> {
+  const file = resolve(root, "compiler/builtins/console.ts");
+  let src = await readFile(file, "utf8");
+  if (src.includes(CONSOLE_COLOR_MARKER)) return;
+  const at = src.indexOf(CONSOLE_COLOR_ANCHOR);
+  const print = at < 0 ? -1 : src.indexOf(CONSOLE_COLOR_PRINT, at);
+  if (at < 0 || print < 0 || src.split(CONSOLE_COLOR_ANCHOR).length !== 2)
+    throw new Error(`could not patch Porffor's console colours: anchor not found in ${file}`);
+  src =
+    src.slice(0, at) + CONSOLE_COLOR_HELPER + src.slice(at, print) +
+    "  __Porffor_print(arg, __Porffor_consoleColors());\n};\n" + src.slice(print + CONSOLE_COLOR_PRINT.length);
+  await writeFile(file, src);
+}
+
+const TEXT_DECODER_MARKER = "sproutboat: WHATWG UTF-8 decoder";
+/** Replaces Porffor's TextDecoder (text-decoder.ts). After patchURLClass, whose class ends it. */
+export async function patchTextDecoder(root: string): Promise<void> {
+  const file = resolve(root, "runtime/fetch-globals.js");
+  const src = await readFile(file, "utf8");
+  if (src.includes(TEXT_DECODER_MARKER)) return;
+  const start = src.indexOf("class TextDecoder {");
+  const end = start < 0 ? -1 : src.indexOf("\nclass URL {", start);
+  if (start < 0 || end < 0 || src.indexOf("class TextDecoder {", start + 1) >= 0)
+    throw new Error(`could not patch Porffor's TextDecoder: anchor not found in ${file}`);
+  await writeFile(file, src.slice(0, start) + TEXT_DECODER_SOURCE + src.slice(end));
+}
+
+// String.prototype.toLowerCase/toUpperCase mapped ASCII only ("todo: unicode" upstream), so
+// "ÄÖÜ", Greek and Cyrillic came back unchanged, and URL hosts lowercased wrongly (W2).
+// Simple one-to-one BMP mappings from case-map.ts, looked up by binary search for units
+// >= 128. Latin-1 strings keep their own range (À-Þ, à-þ); one-to-many special casing
+// (ß to SS) and Latin-1 µ/ÿ uppercase (which leave Latin-1) are not handled.
+const CASE_MARKER = "sproutboat: Unicode case mapping";
+const caseLiteral = (runs: string) =>
+  "'" + Array.from(runs, (c) => "\\u" + c.charCodeAt(0).toString(16).padStart(4, "0")).join("") + "'";
+const CASE_HELPERS =
+  "// sproutboat: Unicode case mapping\n" +
+  "export const __Porffor_caseFind = (chr: i32, runs: string): i32 => {\n" +
+  "  let lo: i32 = 0, hi: i32 = runs.length / 4 - 1, found: i32 = -1;\n" +
+  "  while (lo <= hi) {\n" +
+  "    const mid: i32 = (lo + hi) >> 1;\n" +
+  "    if (runs.charCodeAt(mid * 4) <= chr) { found = mid; lo = mid + 1; } else hi = mid - 1;\n" +
+  "  }\n" +
+  "  if (found < 0) return chr;\n" +
+  "  const start: i32 = runs.charCodeAt(found * 4);\n" +
+  "  if (chr > runs.charCodeAt(found * 4 + 1)) return chr;\n" +
+  "  if ((chr - start) % runs.charCodeAt(found * 4 + 3) != 0) return chr;\n" +
+  "  return runs.charCodeAt(found * 4 + 2) + (chr - start);\n" +
+  "};\n" +
+  "export const __Porffor_caseLower = (chr: i32): i32 => __Porffor_caseFind(chr, " + caseLiteral(CASE_LOWER_RUNS) + ");\n" +
+  "export const __Porffor_caseUpper = (chr: i32): i32 => __Porffor_caseFind(chr, " + caseLiteral(CASE_UPPER_RUNS) + ");\n\n";
+const CASE_EDITS: [string, string][] = [
+  ["    if (chr >= 97) if (chr <= 122) chr -= 32;\n\n    Porffor.IR.storeU16(j, 4, chr);",
+   "    if (chr < 128) { if (chr >= 97) if (chr <= 122) chr -= 32; } else chr = __Porffor_caseUpper(chr);\n\n    Porffor.IR.storeU16(j, 4, chr);"],
+  ["    if (chr >= 65) if (chr <= 90) chr += 32;\n\n    Porffor.IR.storeU16(j, 4, chr);",
+   "    if (chr < 128) { if (chr >= 65) if (chr <= 90) chr += 32; } else chr = __Porffor_caseLower(chr);\n\n    Porffor.IR.storeU16(j, 4, chr);"],
+  ["    if (chr >= 97) if (chr <= 122) chr -= 32;\n\n    Porffor.IR.storeU8(j++, 4, chr);",
+   "    if (chr >= 97) { if (chr <= 122) chr -= 32; else if (chr >= 224) if (chr <= 254) if (chr != 247) chr -= 32; }\n\n    Porffor.IR.storeU8(j++, 4, chr);"],
+  ["    if (chr >= 65) if (chr <= 90) chr += 32;\n\n    Porffor.IR.storeU8(j++, 4, chr);",
+   "    if (chr >= 65) { if (chr <= 90) chr += 32; else if (chr >= 192) if (chr <= 222) if (chr != 215) chr += 32; }\n\n    Porffor.IR.storeU8(j++, 4, chr);"],
+];
+
+/** Unicode simple case mapping for toLowerCase/toUpperCase. Before the precompile. */
+export async function patchCaseMapping(root: string): Promise<void> {
+  const file = resolve(root, "compiler/builtins/string.ts");
+  let src = await readFile(file, "utf8");
+  if (src.includes(CASE_MARKER)) return;
+  const at = src.indexOf("export const __String_prototype_toUpperCase = function (this: string) {");
+  if (at < 0) throw new Error(`could not patch Porffor's case mapping: anchor not found in ${file}`);
+  for (const [anchor, inject] of CASE_EDITS) {
+    if (src.split(anchor).length !== 2) throw new Error(`could not patch Porffor's case mapping: anchor not found in ${file}`);
+    src = src.replace(anchor, inject);
+  }
+  await writeFile(file, src.slice(0, at) + CASE_HELPERS + src.slice(at));
+}
+
+const HEADERS_CLASS_MARKER = "sproutboat: Fetch-spec Headers";
+/** Replaces Porffor's Headers (headers-class.ts), which also covers patchHeadersArrayInit's fix. */
+export async function patchHeadersClass(root: string): Promise<void> {
+  const file = resolve(root, "runtime/fetch-globals.js");
+  const src = await readFile(file, "utf8");
+  if (src.includes(HEADERS_CLASS_MARKER)) return;
+  const start = src.indexOf("class Headers {");
+  const end = start < 0 ? -1 : src.indexOf("\nfunction setTimeout(", start);
+  if (start < 0 || end < 0) throw new Error(`could not patch Porffor's Headers: anchor not found in ${file}`);
+  await writeFile(file, src.slice(0, start) + HEADERS_CLASS_SOURCE + src.slice(end));
+}
+
+// setTimeout(fn, 0) never fired on Linux: uSockets arms timers with timerfd_settime, where
+// a zero first expiry disarms the timer (kqueue on macOS fires it at once). The same held
+// for setInterval(fn, 0), which also lost its repeat. Arm at least 1 ms.
+const ZERO_TIMER_ANCHOR =
+  "  porf_native_fetch_timer_start(id, (i32)delay_ms, timer->repeat ? (i32)delay_ms : 0);";
+const ZERO_TIMER_INJECT =
+  "  porf_native_fetch_timer_start(id, delay_ms < 1 ? 1 : (i32)delay_ms, timer->repeat ? (delay_ms < 1 ? 1 : (i32)delay_ms) : 0); /* sproutboat: zero-delay timers fire on Linux */";
+
+/** Zero-delay timers are armed at 1 ms, since a zero timerfd expiry disarms them. */
+export async function patchZeroDelayTimers(root: string): Promise<void> {
+  const file = resolve(root, "compiler/render.js");
+  const src = await readFile(file, "utf8");
+  if (src.includes("sproutboat: zero-delay timers fire on Linux")) return;
+  if (src.split(ZERO_TIMER_ANCHOR).length !== 2)
+    throw new Error(`could not patch Porffor's zero-delay timers: anchor not found in ${file}`);
+  await writeFile(file, src.replace(ZERO_TIMER_ANCHOR, ZERO_TIMER_INJECT));
+}
+
+// sproutd links the shared runtime and each app's module as separate shared objects, so
+// Porffor's split output declares module globals without `static`, under their JS names.
+// A global named like a libc symbol then binds to libc: the structuredClone prelude's
+// `clone` made the runtime write a JS value into libc's clone() and every worker crashed
+// on start (SEGV_ACCERR). An app's `const hash` or `let search` would do the same.
+// Porffor's reserved-name list cannot keep up with libc, so split globals get a prefix;
+// Internal __ globals (Porffor's, the prelude's, sproutd's) keep their names: C refers to them.
+const SPLIT_GLOBALS_MARKER = "sproutboat: split globals are prefixed";
+const SPLIT_GLOBALS_EDITS: [string, string][] = [
+  [
+    "  const st = split ? '' : 'static ';\n",
+    "  const st = split ? '' : 'static ';\n" +
+      "  // " + SPLIT_GLOBALS_MARKER + ", so none binds to a libc symbol of the same name\n" +
+      "  const gname = n => sanitize(split && !n.startsWith('__') ? 'pg_' + n : n);\n",
+  ],
+  [
+    "      case K.Global:\n        cur.globals[node[N_A]] = true;\n      case K.Local:\n        return [sanitize(node[N_A]), P_PRIM];",
+    "      case K.Global:\n        cur.globals[node[N_A]] = true;\n        return [gname(node[N_A]), P_PRIM];\n      case K.Local:\n        return [sanitize(node[N_A]), P_PRIM];",
+  ],
+  [
+    "        emit(`${ind()}${sanitize(node[N_A][N_A])} = ${rx(node[N_B], P_COMMA)};\\n`);",
+    "        emit(`${ind()}${node[N_A][N_KIND] === K.Global ? gname(node[N_A][N_A]) : sanitize(node[N_A][N_A])} = ${rx(node[N_B], P_COMMA)};\\n`);",
+  ],
+  [
+    "            ? `${sanitize(update[N_A][N_A])} = ${rx(update[N_B], P_COMMA)}`",
+    "            ? `${update[N_A][N_KIND] === K.Global ? gname(update[N_A][N_A]) : sanitize(update[N_A][N_A])} = ${rx(update[N_B], P_COMMA)}`",
+  ],
+  ["    const t = sanitize(target[N_A]);", "    const t = target[N_KIND] === K.Global ? gname(target[N_A]) : sanitize(target[N_A]);"],
+  ["${st}${CT[g.type]} ${sanitize(g.name)}", "${st}${CT[g.type]} ${gname(g.name)}"],
+  ["      const name = sanitize(g.name);", "      const name = gname(g.name);"],
+  ["const buckets = sanitize(g.name.replace(", "const buckets = gname(g.name.replace("],
+  ["const bucketsCap = sanitize(g.name.replace(", "const bucketsCap = gname(g.name.replace("],
+  ["text.push(`extern ${CT[globalTypes[x]]} ${sanitize(x)};\\n`);", "text.push(`extern ${CT[globalTypes[x]]} ${gname(x)};\\n`);"],
+];
+
+/** Split (shared-object) output prefixes module globals, so none binds to libc. */
+export async function patchSplitGlobals(root: string): Promise<void> {
+  const file = resolve(root, "compiler/render.js");
+  let src = await readFile(file, "utf8");
+  if (src.includes(SPLIT_GLOBALS_MARKER)) return;
+  for (const [anchor, inject] of SPLIT_GLOBALS_EDITS) {
+    if (src.split(anchor).length !== 2)
+      throw new Error(`could not patch Porffor's split globals: anchor not found in ${file}`);
+    src = src.replace(anchor, inject);
+  }
+  await writeFile(file, src);
+}
+
+const FETCH_CLASSES_MARKER = "sproutboat: Fetch-spec Request and Response";
+/** Replaces Porffor's Request and Response (fetch-classes.ts); covers patchResponseDefaults. */
+export async function patchFetchClasses(root: string): Promise<void> {
+  const file = resolve(root, "runtime/fetch-globals.js");
+  const src = await readFile(file, "utf8");
+  if (src.includes(FETCH_CLASSES_MARKER)) return;
+  const request = src.indexOf("class Request {");
+  const response = src.indexOf("class Response {");
+  if (request < 0 || response < request || src.indexOf("\nclass ", response + 1) >= 0)
+    throw new Error(`could not patch Porffor's Request and Response: anchor not found in ${file}`);
+  await writeFile(file, src.slice(0, request) + REQUEST_CLASS_SOURCE + RESPONSE_CLASS_SOURCE);
+}
+
+/** The native response finalizer sends byte bodies as bytes (fetch-classes.ts). */
+export async function patchResponseBytes(root: string): Promise<void> {
+  const file = resolve(root, "runtime/native-fetch.js");
+  const src = await readFile(file, "utf8");
+  if (src.includes("sproutboat: byte bodies go out as their bytes")) return;
+  if (src.split(RESPONSE_BYTES_ANCHOR).length !== 2)
+    throw new Error(`could not patch Porffor's response finalizer: anchor not found in ${file}`);
+  await writeFile(file, src.replace(RESPONSE_BYTES_ANCHOR, RESPONSE_BYTES_INJECT));
+}
+
+/** Replaces Porffor's Blob with a byte-backed Blob and File (fetch-classes.ts). */
+export async function patchBlobClass(root: string): Promise<void> {
+  const file = resolve(root, "runtime/fetch-globals.js");
+  const src = await readFile(file, "utf8");
+  if (src.includes("sproutboat: byte-backed Blob and File")) return;
+  const start = src.indexOf("class Blob {");
+  const end = start < 0 ? -1 : src.indexOf("\nclass TextEncoder {", start);
+  if (start < 0 || end < 0) throw new Error(`could not patch Porffor's Blob: anchor not found in ${file}`);
+  await writeFile(file, src.slice(0, start) + BLOB_CLASS_SOURCE + src.slice(end));
+}
+
+/** Streamed responses in the uWebSockets shim (streaming.ts). After patchUwebsockets. */
+export async function patchStreamingResponses(root: string): Promise<void> {
+  const renderFile = resolve(root, "compiler/render.js");
+  let render = await readFile(renderFile, "utf8");
+  if (!render.includes("sproutboat B19: streaming fallbacks")) {
+    if (render.split(streaming.STREAM_STUBS_ANCHOR).length !== 2)
+      throw new Error(`could not patch Porffor's streaming fallbacks: anchor not found in ${renderFile}`);
+    render = render.replace(streaming.STREAM_STUBS_ANCHOR, streaming.STREAM_STUBS + streaming.STREAM_STUBS_ANCHOR);
+    await writeFile(renderFile, render);
+  }
+  const file = resolve(root, "compiler/uwebsockets.js");
+  let src = await readFile(file, "utf8");
+  if (src.includes("sproutboat B19: streamed responses")) return;
+  const edits: [string, string][] = [
+    [streaming.STREAM_FORBIDDEN_ANCHOR, streaming.STREAM_FORBIDDEN_INJECT],
+    [streaming.STREAM_FLAG_ANCHOR, streaming.STREAM_FLAG_INJECT],
+    [streaming.STREAM_SCAN_ANCHOR, streaming.STREAM_SCAN_INJECT],
+    [streaming.STREAM_CORK_ANCHOR, streaming.STREAM_CORK_INJECT],
+    [streaming.STREAM_END_ANCHOR, streaming.STREAM_END_INJECT],
+    [streaming.STREAM_REGISTRY_ANCHOR, streaming.STREAM_REGISTRY + streaming.STREAM_REGISTRY_ANCHOR],
+  ];
+  for (const [anchor, inject] of edits) {
+    if (src.split(anchor).length !== 2)
+      throw new Error(`could not patch Porffor's streamed responses: anchor not found in ${file}`);
+    src = src.replace(anchor, inject);
+  }
+  await writeFile(file, src);
+}
+
+/**
+ * True when root is a finished cache entry that this toolchain version and patch
+ * chain patched (ensurePorffor patches before it writes the manifest). The CLI calls
+ * ensurePorfforPatched on every compile: re-running the patch chain there cost
+ * ~1.3 s per build, and its precompile rewrote builtins_precompiled.js in place,
+ * so parallel builds sharing the cache could import a half-written table.
+ */
+async function patchedByThisVersion(root: string): Promise<boolean> {
+  try {
+    // SAFETY: private manifest written by ensurePorffor; only three fields are read.
+    const manifest = JSON.parse(await readFile(resolve(root, ".sproutboat-complete"), "utf8")) as {
+      commit?: string;
+      toolchainVersion?: string;
+      patchFingerprint?: string;
+    };
+    return (
+      manifest.commit === PORFFOR_COMMIT_FULL &&
+      manifest.toolchainVersion === TOOLCHAIN_VERSION &&
+      manifest.patchFingerprint === PATCH_FINGERPRINT
+    );
+  } catch {
+    return false;
+  }
+}
+
 export async function ensurePorfforPatched(root: string): Promise<void> {
   if (done.has(root)) return;
+  if (await patchedByThisVersion(root)) {
+    done.add(root);
+    return;
+  }
   await patchCompilerArgs(root);
   await patchClassSelfName(root);
   await patchUwebsockets(root);
   await patchRenderJs(root);
+  await patchStreamingResponses(root);
+  await patchQuietCollection(root);
+  await patchDeferredDiscard(root);
   await patchDateParser(root);
   await patchPromiseResolveNull(root);
   await patchReplaceAll(root);
-  await patchTypedArrayStore(root);
   await patchLocalFunctionTypes(root);
   await patchUint8ArrayBase64(root);
+  await patchResponseDefaults(root);
+  await patchHeadersArrayInit(root);
+  await patchHeadersClass(root);
+  await patchFetchClasses(root);
+  await patchBlobClass(root);
+  await patchResponseBytes(root);
+  await patchURLClass(root);
+  await patchTextDecoder(root);
+  await patchMapGroupBy(root);
+  await patchPrivateFieldsHidden(root);
+  await patchRepeatDoubling(root);
+  await patchJsonCycles(root);
+  await patchTypedArrayTag(root);
+  await patchConsoleColors(root);
+  await patchCaseMapping(root);
+  await patchZeroDelayTimers(root);
+  await patchSplitGlobals(root);
   // Last of the builtin edits: its precompile picks up the date, promise and
   // replaceAll patches above too.
   await precompileBuiltins(root);