@sproutboat/toolchain 0.3.0 → 0.3.2

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @sproutboat/toolchain
 
+## 0.3.2
+
+### Patch Changes
+
+- 806c21e: Fix (baronunread/sproutboat#176): #172's bytestring UTF-8 encoding fix broke
+  the assets binding, which reads a file's bytes off disk into a `bytestring`
+  specifically so they pass through the wire untouched — a `bytestring`
+  carrying real text a handler built and one carrying opaque file bytes are the
+  same type with no way to tell them apart, so #172's blanket encoding also
+  re-encoded already-finished bytes, corrupting any binary asset (and any
+  proxied `fetch()`/service-binding response body).
+  
+  Adds a second, dedicated `porf_native_fetch_read_raw_bytes` (zero-copy,
+  bytestring-only, no encoding, ever) alongside the untouched original —
+  `porf_native_fetch_read_value` is called from ~30 places across sproutboat's
+  own inline C, all genuine text, so its signature and behavior stay exactly as
+  #172 left them. `write_response_value` picks between the two based on a new
+  reserved `x-sb-raw-body` response header (same pattern as #163's
+  `x-sb-remote-addr`), which the assets binding, outbound `fetch()`, and
+  service-binding `fetch()` now set — the three places sproutboat's own
+  prelude constructs a Response from wire bytes rather than a string a handler
+  built. Verified end-to-end: a 256-byte all-values fixture now round-trips
+  byte-for-byte through a real standalone build's assets binding, and #172's
+  original UTF-8 fix still holds for genuine text.
+  
+  Not fixed here: `env.<R2>.get()`'s `.body` is exposed directly to handler
+  code, which then constructs its own `new Response(obj.body)` — no
+  sproutboat-owned call site to attach the marker to, so R2 binary objects
+  served this way carry the same corruption. Needs either a real binary body
+  type upstream in Porffor or a different API shape; tracked as a known gap on
+  #176, not resolved by this fix.
+
+## 0.3.1
+
+### Patch Changes
+
+- afd054c: Fix (baronunread/sproutboat#172): a standalone/native-fetch response body,
+  header name, or header value whose code points all fit one byte (any Latin-1-
+  range string — most non-astral JS strings) reached the wire as raw Latin-1
+  bytes instead of UTF-8, corrupting any non-ASCII text regardless of the
+  declared `charset`. `patchRenderJs` now encodes Porffor's `bytestring`
+  representation the same way its `string` (UTF-16) branch already did. Plain
+  ASCII output is unaffected (identical in both encodings).
+
 ## 0.3.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/toolchain",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "license": "MIT",
   "type": "module",
   "main": "./src/index.ts",

package/src/acquire.test.ts

@@ -18,10 +18,20 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
     "runtime/index.js": "fixture:runtime/index.js\n",
     "compiler/render.js":
       "void porf_native_fetch_runtime_init(void) {\n  signal(SIGPIPE, SIG_IGN);\n  porf_init(0, NULL);\n}\n" +
-      "f64 porf_native_fetch_get_port(void) {\nfixture:compiler/render.js\n",
+      "f64 porf_native_fetch_get_port(void) {\nfixture:compiler/render.js\n" +
+      "int porf_native_fetch_read_value(jsval value, const char** out_buf, size_t* out_len, char** out_owned) {\n" +
+      "  if (value.type == ${TYPES.bytestring}) {\n" +
+      "    const u32 ptr = (u32)value.val;\n" +
+      "    *out_buf = (const char*)(MEM + ptr + 4);\n" +
+      "    *out_len = (size_t)*(u32*)(MEM + ptr);\n" +
+      "    return 0;\n" +
+      "  }\n" +
+      "  return -1;\n" +
+      "}\n",
     "compiler/index.js": "          '-xc', '-', '-c',\n          uSocketsArchive,\n          '-lm'\n",
     "compiler/uwebsockets.js":
       "static const size_t REQUEST_BODY_MAX_BYTES = 1024u * 1024u;\n" +
+      "int porf_native_fetch_read_value(struct jsval value, const char** out_buf, size_t* out_len, char** out_owned);\n" +
       "static std::string_view lookup_status_line(i32 status) {\n" +
       '  switch (status) {\n    case 302: return "302 Found";\n    default: return {};\n  }\n}\n' +
       "static i32 collect_headers(uWS::HttpRequest* req) {\n" +
@@ -30,7 +40,60 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
       "  i32 slot = 0;\n  for (auto [key, value] : *req) {\n    slot++;\n  }\n" +
       "  *((i32*)(porf_mem + headers_ptr)) = slot;\n\n  return headers_ptr;\n}\n" +
       "static void on_request(uWS::HttpResponse<false>* res, uWS::HttpRequest* req) {\n" +
-      "  const i32 headers_ptr = collect_headers(req);\n}\n",
+      "  const i32 headers_ptr = collect_headers(req);\n}\n" +
+      "static bool is_forbidden_response_header(std::string_view key) {\n" +
+      '  return key == "connection" ||\n' +
+      '         key == "content-length" ||\n' +
+      '         key == "transfer-encoding";\n' +
+      "}\n" +
+      "static void write_response_value(uWS::HttpResponse<false>* res, struct jsval response, bool* aborted) {\n" +
+      "  struct NativeFetchResponseParts response_parts;\n" +
+      "  porf_native_fetch_finalize_response(response.val, response.type, &response_parts);\n" +
+      "  const i32 status = response_parts.status;\n" +
+      "  const struct jsval body_value = response_parts.body;\n" +
+      "  const i32 headers_entries_ptr = (i32)response_parts.headers.val;\n" +
+      "\n" +
+      "  const char* body_buf = nullptr;\n" +
+      "  size_t body_len = 0;\n" +
+      "  char* body_owned = nullptr;\n" +
+      "  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" +
+      "      if (status != 200) res->writeStatus(lookup_status_line(status));\n" +
+      "\n" +
+      "      const i32 headers_len = *((i32*)(porf_mem + headers_entries_ptr)) / 2;\n" +
+      "      const i32 headers_entries = *((i32*)(porf_mem + headers_entries_ptr + 4));\n" +
+      "      for (i32 i = 0; i < headers_len; i++) {\n" +
+      "        const i32 name_base = headers_entries + i * 16;\n" +
+      "        const i32 value_base = name_base + 8;\n" +
+      "        const struct jsval name_value = unpack_jsval(*((u64*)(porf_mem + name_base)));\n" +
+      "        const struct jsval value_value = unpack_jsval(*((u64*)(porf_mem + value_base)));\n" +
+      "\n" +
+      "        const char* name_buf = nullptr;\n" +
+      "        size_t name_len = 0;\n" +
+      "        char* name_owned = nullptr;\n" +
+      "        const char* value_buf = nullptr;\n" +
+      "        size_t value_len = 0;\n" +
+      "        char* value_owned = nullptr;\n" +
+      "        porf_native_fetch_read_value(name_value, &name_buf, &name_len, &name_owned);\n" +
+      "        porf_native_fetch_read_value(value_value, &value_buf, &value_len, &value_owned);\n" +
+      "\n" +
+      "        const std::string_view key(name_buf, name_len);\n" +
+      "        if (!is_forbidden_response_header(key)) {\n" +
+      "          res->writeHeader(key, std::string_view(value_buf, value_len));\n" +
+      "        }\n" +
+      "\n" +
+      "        if (name_owned) free(name_owned);\n" +
+      "        if (value_owned) free(value_owned);\n" +
+      "      }\n" +
+      "\n" +
+      "      res->end(std::string_view(body_buf, body_len));\n" +
+      "    });\n" +
+      "  }\n" +
+      "\n" +
+      "  if (body_owned) free(body_owned);\n" +
+      "}\n",
   };
   for (const [file, contents] of Object.entries(files)) {
     const path = join(source, file);

package/src/patch.test.ts

@@ -17,12 +17,33 @@ const RENDER = `void porf_native_fetch_runtime_init(void) {
 f64 porf_native_fetch_get_port(void) {
   return __porffor_native_fetch_port.val;
 }
+
+int porf_native_fetch_read_value(jsval value, const char** out_buf, size_t* out_len, char** out_owned) {
+  if (!out_buf || !out_len || !out_owned) return -1;
+
+  *out_buf = NULL;
+  *out_len = 0;
+  *out_owned = NULL;
+
+  if (value.type == \${TYPES.bytestring}) {
+    const u32 ptr = (u32)value.val;
+    *out_buf = (const char*)(MEM + ptr + 4);
+    *out_len = (size_t)*(u32*)(MEM + ptr);
+    return 0;
+  }
+
+  return -1;
+}
 `;
 
 // Porffor's compiler/uwebsockets.js, trimmed to the parts the patch touches:
-// body limit (#56), the #156 status-line switch, and #163's collect_headers.
+// body limit (#56), the #156 status-line switch, #163's collect_headers, and
+// #176's read_value forward decl / is_forbidden_response_header /
+// write_response_value.
 const SHIM = `static const size_t REQUEST_BODY_MAX_BYTES = 1024u * 1024u;
 
+int porf_native_fetch_read_value(struct jsval value, const char** out_buf, size_t* out_len, char** out_owned);
+
 static std::string_view lookup_status_line(i32 status) {
   switch (status) {
     case 200: return "200 OK";
@@ -57,6 +78,61 @@ static i32 collect_headers(uWS::HttpRequest* req) {
 static void on_request(uWS::HttpResponse<false>* res, uWS::HttpRequest* req) {
   const i32 headers_ptr = collect_headers(req);
 }
+
+static bool is_forbidden_response_header(std::string_view key) {
+  return key == "connection" ||
+         key == "content-length" ||
+         key == "transfer-encoding";
+}
+
+static void write_response_value(uWS::HttpResponse<false>* res, struct jsval response, bool* aborted) {
+  struct NativeFetchResponseParts response_parts;
+  porf_native_fetch_finalize_response(response.val, response.type, &response_parts);
+  const i32 status = response_parts.status;
+  const struct jsval body_value = response_parts.body;
+  const i32 headers_entries_ptr = (i32)response_parts.headers.val;
+
+  const char* body_buf = nullptr;
+  size_t body_len = 0;
+  char* body_owned = nullptr;
+  porf_native_fetch_read_value(body_value, &body_buf, &body_len, &body_owned);
+
+  if (!aborted || !*aborted) {
+    res->cork([res, status, headers_entries_ptr, body_buf, body_len]() {
+      if (status != 200) res->writeStatus(lookup_status_line(status));
+
+      const i32 headers_len = *((i32*)(porf_mem + headers_entries_ptr)) / 2;
+      const i32 headers_entries = *((i32*)(porf_mem + headers_entries_ptr + 4));
+      for (i32 i = 0; i < headers_len; i++) {
+        const i32 name_base = headers_entries + i * 16;
+        const i32 value_base = name_base + 8;
+        const struct jsval name_value = unpack_jsval(*((u64*)(porf_mem + name_base)));
+        const struct jsval value_value = unpack_jsval(*((u64*)(porf_mem + value_base)));
+
+        const char* name_buf = nullptr;
+        size_t name_len = 0;
+        char* name_owned = nullptr;
+        const char* value_buf = nullptr;
+        size_t value_len = 0;
+        char* value_owned = nullptr;
+        porf_native_fetch_read_value(name_value, &name_buf, &name_len, &name_owned);
+        porf_native_fetch_read_value(value_value, &value_buf, &value_len, &value_owned);
+
+        const std::string_view key(name_buf, name_len);
+        if (!is_forbidden_response_header(key)) {
+          res->writeHeader(key, std::string_view(value_buf, value_len));
+        }
+
+        if (name_owned) free(name_owned);
+        if (value_owned) free(value_owned);
+      }
+
+      res->end(std::string_view(body_buf, body_len));
+    });
+  }
+
+  if (body_owned) free(body_owned);
+}
 `;
 
 async function shimDir(): Promise<string> {
@@ -93,6 +169,23 @@ test("#156: status-line fallback synthesizes a line for unlisted codes, idempote
     expect(once).toContain('porf_native_fetch_alloc_bytestring("x-sb-remote-addr", 16)');
     expect(once).toContain("header_capacity += 2;");
 
+    // #176: a dedicated porf_native_fetch_read_raw_bytes, declared alongside
+    // the untouched original; write_response_value scans for a reserved
+    // x-sb-raw-body header and calls the new function instead of the old one
+    // only for the body, only when it's present -- header reads are
+    // unchanged, and the marker is dropped from what reaches the client.
+    expect(once).toContain(
+      "int porf_native_fetch_read_raw_bytes(struct jsval value, const char** out_buf, size_t* out_len);",
+    );
+    expect(once).toContain('key == "x-sb-raw-body"');
+    expect(once).toContain("bool raw_body = false;");
+    expect(once).toContain('if (std::string_view(scan_buf, scan_bytes) == "x-sb-raw-body") raw_body = true;');
+    expect(once).toContain("if (raw_body) porf_native_fetch_read_raw_bytes(body_value, &body_buf, &body_len);");
+    expect(once).toContain("else porf_native_fetch_read_value(body_value, &body_buf, &body_len, &body_owned);");
+    // Header reads are the original 4-arg call, unchanged.
+    expect(once).toContain("porf_native_fetch_read_value(name_value, &name_buf, &name_len, &name_owned);");
+    expect(once).toContain("porf_native_fetch_read_value(value_value, &value_buf, &value_len, &value_owned);");
+
     await patchUwebsockets(root);
     expect(await readFile(join(root, "compiler/uwebsockets.js"), "utf8")).toBe(once);
   } finally {
@@ -126,6 +219,21 @@ test("#165: render.js routes console output to stderr, unbuffered, idempotently"
     // The $PORT edit still lands too.
     expect(once).toContain('getenv("PORT")');
 
+    // #172: the bytestring branch encodes instead of copying raw bytes.
+    expect(once).toContain("sproutboat #172");
+    expect(once).toContain("(char)(0xc0 | (c >> 6));");
+    // #176: a separate, dedicated function does the original zero-copy
+    // passthrough for already-finished bytes (an asset) -- porf_native_fetch_
+    // read_value's own signature and behavior are untouched, so its ~30 other
+    // callers across sproutboat's inline C need no changes at all.
+    expect(once).toContain("sproutboat #176");
+    expect(once).toContain(
+      "int porf_native_fetch_read_raw_bytes(jsval value, const char** out_buf, size_t* out_len) {",
+    );
+    expect(once).toContain(
+      "int porf_native_fetch_read_value(jsval value, const char** out_buf, size_t* out_len, char** out_owned) {",
+    );
+
     await patchRenderJs(root);
     expect(await readFile(join(root, "compiler/render.js"), "utf8")).toBe(once);
   } finally {

package/src/patch.ts

@@ -46,6 +46,96 @@ const RENDER_EDITS = [
   [CONSOLE_MARKER, CONSOLE_ANCHOR, CONSOLE_INJECT, "console output sink (#165)"],
 ] as const;
 
+/**
+ * baronunread/sproutboat#172 — `porf_native_fetch_read_value`'s `bytestring`
+ * branch (Porffor's Latin-1-range string representation) copies the raw code
+ * units straight onto the wire, as if they were already UTF-8 bytes. Any unit
+ * >= 0x80 — any non-ASCII Latin-1 character — reaches the client corrupt
+ * instead of UTF-8 encoded. Response bodies and header values both go through
+ * this function, so both are affected; the sibling `string` (UTF-16) branch a
+ * few lines down already encodes correctly, this makes the `bytestring` one
+ * do the same, one byte in instead of two.
+ */
+const BYTESTRING_ANCHOR =
+  "  if (value.type == ${TYPES.bytestring}) {\n" +
+  "    const u32 ptr = (u32)value.val;\n" +
+  "    *out_buf = (const char*)(MEM + ptr + 4);\n" +
+  "    *out_len = (size_t)*(u32*)(MEM + ptr);\n" +
+  "    return 0;\n" +
+  "  }";
+const BYTESTRING_INJECT =
+  "  if (value.type == ${TYPES.bytestring}) {\n" +
+  "    // sproutboat #172: units are Latin-1 code points, not UTF-8 bytes -- encode them\n" +
+  "    const u32 ptr = (u32)value.val;\n" +
+  "    const size_t len = (size_t)*(u32*)(MEM + ptr);\n" +
+  "    const unsigned char* units = (const unsigned char*)(MEM + ptr + 4);\n" +
+  "    char* utf8 = (char*)malloc(len * 2);\n" +
+  "    if (!utf8 && len > 0) return -1;\n" +
+  "    size_t out_len_local = 0;\n" +
+  "    for (size_t i = 0; i < len; i++) {\n" +
+  "      unsigned char c = units[i];\n" +
+  "      if (c < 0x80) utf8[out_len_local++] = (char)c;\n" +
+  "      else {\n" +
+  "        utf8[out_len_local++] = (char)(0xc0 | (c >> 6));\n" +
+  "        utf8[out_len_local++] = (char)(0x80 | (c & 0x3f));\n" +
+  "      }\n" +
+  "    }\n" +
+  "    *out_buf = utf8;\n" +
+  "    *out_len = out_len_local;\n" +
+  "    *out_owned = utf8;\n" +
+  "    return 0;\n" +
+  "  }";
+const BYTESTRING_MARKER = "sproutboat #172";
+
+/**
+ * baronunread/sproutboat#176 — #172 broke the assets binding, which reads a
+ * file's bytes off disk into a `bytestring` specifically so they can pass
+ * through the wire untouched (already-finished bytes: a UTF-8 text file's
+ * bytes are already UTF-8, a binary file's bytes are just bytes, neither
+ * should ever be "encoded" again). A `bytestring` carrying real text a
+ * handler built and one carrying opaque file bytes are the same type with no
+ * way to tell them apart at this point — so the caller has to say which one
+ * this is.
+ *
+ * `porf_native_fetch_read_value` is called from ~30 places across
+ * sproutboat's own inline C (crypto, SQL params, R2/D1 paths, the HTTP
+ * client), every one of them genuine text, every one needing #172's
+ * encoding unchanged — widening its signature would mean touching all of
+ * them for zero behavior change, for one caller that needs something
+ * different. Add a second, dedicated function instead:
+ * `porf_native_fetch_read_raw_bytes`, zero-copy, bytestring-only, no
+ * encoding, ever. Only `write_response_value`'s body read (uwebsockets.js,
+ * below) calls it, gated on the reserved `x-sb-raw-body` response header the
+ * assets binding sets. Every existing call site is untouched.
+ */
+const READ_RAW_ANCHOR = "int porf_native_fetch_read_value(jsval value, const char** out_buf, size_t* out_len, char** out_owned) {";
+const READ_RAW_INJECT =
+  "// sproutboat #176: zero-copy passthrough for a bytestring that is already-\n" +
+  "// finished bytes (an asset read off disk), never a string to UTF-8 encode.\n" +
+  "// Deliberately not folded into porf_native_fetch_read_value above: that one\n" +
+  "// is called from ~30 places across sproutboat's own inline C, all genuine\n" +
+  "// text, all needing its encoding unchanged.\n" +
+  "int porf_native_fetch_read_raw_bytes(jsval value, const char** out_buf, size_t* out_len) {\n" +
+  "  if (value.type != ${TYPES.bytestring}) return -1;\n" +
+  "  const u32 ptr = (u32)value.val;\n" +
+  "  *out_buf = (const char*)(MEM + ptr + 4);\n" +
+  "  *out_len = (size_t)*(u32*)(MEM + ptr);\n" +
+  "  return 0;\n" +
+  "}\n" +
+  "\n" +
+  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)"],
+] as const;
+
 // #15 — no `--port` flag: Porffor's native-fetch entry point calls
 // `porf_init(0, NULL)` (see porf_native_fetch_runtime_init in render.js), so a
 // native-fetch binary never sees argv at all. A standalone binary takes its
@@ -166,6 +256,160 @@ const HDR_APPEND_INJECT =
   "  *((i32*)(porf_mem + headers_ptr)) = slot;\n\n  return headers_ptr;";
 const HDR_APPEND_MARKER = "__sb_peer";
 
+/**
+ * baronunread/sproutboat#176 — the uwebsockets.js half of the raw-bytestring
+ * fix: a forward declaration for render.js's new
+ * `porf_native_fetch_read_raw_bytes`, `write_response_value` scanning for a
+ * reserved `x-sb-raw-body` response header before the body read and calling
+ * that function instead of `porf_native_fetch_read_value` when it's present
+ * (header reads are untouched — a header name or value is always real
+ * text), and `is_forbidden_response_header` dropping that header from what
+ * actually reaches the client — same reserved-header pattern as #163's
+ * `x-sb-remote-addr`, just response-side and sproutboat-to-C instead of
+ * C-to-sproutboat.
+ */
+const READ_RAW_DECL_ANCHOR =
+  "int porf_native_fetch_read_value(struct jsval value, const char** out_buf, size_t* out_len, char** out_owned);";
+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 FORBIDDEN_HDR_ANCHOR =
+  "static bool is_forbidden_response_header(std::string_view key) {\n" +
+  '  return key == "connection" ||\n' +
+  '         key == "content-length" ||\n' +
+  '         key == "transfer-encoding";\n' +
+  "}";
+const FORBIDDEN_HDR_INJECT =
+  "static bool is_forbidden_response_header(std::string_view key) {\n" +
+  '  return key == "connection" ||\n' +
+  '         key == "content-length" ||\n' +
+  '         key == "transfer-encoding" ||\n' +
+  '         key == "x-sb-raw-body"; // sproutboat #176: internal signal, never sent\n' +
+  "}";
+const FORBIDDEN_HDR_MARKER = 'key == "x-sb-raw-body"';
+
+const WRITE_RESPONSE_ANCHOR =
+  "static void write_response_value(uWS::HttpResponse<false>* res, struct jsval response, bool* aborted) {\n" +
+  "  struct NativeFetchResponseParts response_parts;\n" +
+  "  porf_native_fetch_finalize_response(response.val, response.type, &response_parts);\n" +
+  "  const i32 status = response_parts.status;\n" +
+  "  const struct jsval body_value = response_parts.body;\n" +
+  "  const i32 headers_entries_ptr = (i32)response_parts.headers.val;\n" +
+  "\n" +
+  "  const char* body_buf = nullptr;\n" +
+  "  size_t body_len = 0;\n" +
+  "  char* body_owned = nullptr;\n" +
+  "  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" +
+  "      if (status != 200) res->writeStatus(lookup_status_line(status));\n" +
+  "\n" +
+  "      const i32 headers_len = *((i32*)(porf_mem + headers_entries_ptr)) / 2;\n" +
+  "      const i32 headers_entries = *((i32*)(porf_mem + headers_entries_ptr + 4));\n" +
+  "      for (i32 i = 0; i < headers_len; i++) {\n" +
+  "        const i32 name_base = headers_entries + i * 16;\n" +
+  "        const i32 value_base = name_base + 8;\n" +
+  "        const struct jsval name_value = unpack_jsval(*((u64*)(porf_mem + name_base)));\n" +
+  "        const struct jsval value_value = unpack_jsval(*((u64*)(porf_mem + value_base)));\n" +
+  "\n" +
+  "        const char* name_buf = nullptr;\n" +
+  "        size_t name_len = 0;\n" +
+  "        char* name_owned = nullptr;\n" +
+  "        const char* value_buf = nullptr;\n" +
+  "        size_t value_len = 0;\n" +
+  "        char* value_owned = nullptr;\n" +
+  "        porf_native_fetch_read_value(name_value, &name_buf, &name_len, &name_owned);\n" +
+  "        porf_native_fetch_read_value(value_value, &value_buf, &value_len, &value_owned);\n" +
+  "\n" +
+  "        const std::string_view key(name_buf, name_len);\n" +
+  "        if (!is_forbidden_response_header(key)) {\n" +
+  "          res->writeHeader(key, std::string_view(value_buf, value_len));\n" +
+  "        }\n" +
+  "\n" +
+  "        if (name_owned) free(name_owned);\n" +
+  "        if (value_owned) free(value_owned);\n" +
+  "      }\n" +
+  "\n" +
+  "      res->end(std::string_view(body_buf, body_len));\n" +
+  "    });\n" +
+  "  }\n" +
+  "\n" +
+  "  if (body_owned) free(body_owned);\n" +
+  "}";
+const WRITE_RESPONSE_INJECT =
+  "static void write_response_value(uWS::HttpResponse<false>* res, struct jsval response, bool* aborted) {\n" +
+  "  struct NativeFetchResponseParts response_parts;\n" +
+  "  porf_native_fetch_finalize_response(response.val, response.type, &response_parts);\n" +
+  "  const i32 status = response_parts.status;\n" +
+  "  const struct jsval body_value = response_parts.body;\n" +
+  "  const i32 headers_entries_ptr = (i32)response_parts.headers.val;\n" +
+  "\n" +
+  "  // sproutboat #176: a reserved x-sb-raw-body header (set by the prelude's\n" +
+  "  // assets binding) means the body is already-finished bytes, not a string\n" +
+  "  // to UTF-8 encode -- scanned before the body read so it can steer that one\n" +
+  "  // call onto porf_native_fetch_read_raw_bytes instead.\n" +
+  "  bool raw_body = false;\n" +
+  "  {\n" +
+  "    const i32 scan_len = *((i32*)(porf_mem + headers_entries_ptr)) / 2;\n" +
+  "    const i32 scan_entries = *((i32*)(porf_mem + headers_entries_ptr + 4));\n" +
+  "    for (i32 i = 0; i < scan_len && !raw_body; i++) {\n" +
+  "      const struct jsval scan_name = unpack_jsval(*((u64*)(porf_mem + scan_entries + i * 16)));\n" +
+  "      const char* scan_buf = nullptr;\n" +
+  "      size_t scan_bytes = 0;\n" +
+  "      char* scan_owned = nullptr;\n" +
+  "      porf_native_fetch_read_value(scan_name, &scan_buf, &scan_bytes, &scan_owned);\n" +
+  "      if (std::string_view(scan_buf, scan_bytes) == \"x-sb-raw-body\") raw_body = true;\n" +
+  "      if (scan_owned) free(scan_owned);\n" +
+  "    }\n" +
+  "  }\n" +
+  "\n" +
+  "  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" +
+  "\n" +
+  "  if (!aborted || !*aborted) {\n" +
+  "    res->cork([res, status, headers_entries_ptr, body_buf, body_len]() {\n" +
+  "      if (status != 200) res->writeStatus(lookup_status_line(status));\n" +
+  "\n" +
+  "      const i32 headers_len = *((i32*)(porf_mem + headers_entries_ptr)) / 2;\n" +
+  "      const i32 headers_entries = *((i32*)(porf_mem + headers_entries_ptr + 4));\n" +
+  "      for (i32 i = 0; i < headers_len; i++) {\n" +
+  "        const i32 name_base = headers_entries + i * 16;\n" +
+  "        const i32 value_base = name_base + 8;\n" +
+  "        const struct jsval name_value = unpack_jsval(*((u64*)(porf_mem + name_base)));\n" +
+  "        const struct jsval value_value = unpack_jsval(*((u64*)(porf_mem + value_base)));\n" +
+  "\n" +
+  "        const char* name_buf = nullptr;\n" +
+  "        size_t name_len = 0;\n" +
+  "        char* name_owned = nullptr;\n" +
+  "        const char* value_buf = nullptr;\n" +
+  "        size_t value_len = 0;\n" +
+  "        char* value_owned = nullptr;\n" +
+  "        porf_native_fetch_read_value(name_value, &name_buf, &name_len, &name_owned);\n" +
+  "        porf_native_fetch_read_value(value_value, &value_buf, &value_len, &value_owned);\n" +
+  "\n" +
+  "        const std::string_view key(name_buf, name_len);\n" +
+  "        if (!is_forbidden_response_header(key)) {\n" +
+  "          res->writeHeader(key, std::string_view(value_buf, value_len));\n" +
+  "        }\n" +
+  "\n" +
+  "        if (name_owned) free(name_owned);\n" +
+  "        if (value_owned) free(value_owned);\n" +
+  "      }\n" +
+  "\n" +
+  "      res->end(std::string_view(body_buf, body_len));\n" +
+  "    });\n" +
+  "  }\n" +
+  "\n" +
+  "  if (body_owned) free(body_owned);\n" +
+  "}";
+const WRITE_RESPONSE_MARKER = "porf_native_fetch_read_raw_bytes(body_value";
+
 const done = new Set<string>();
 
 /** Edits to Porffor's uWebSockets shim: `[marker, anchor, inject, what]`. */
@@ -179,6 +423,9 @@ const UWS_EDITS = [
   [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, FORBIDDEN_HDR_INJECT, "drop x-sb-raw-body from the wire (#176)"],
+  [WRITE_RESPONSE_MARKER, WRITE_RESPONSE_ANCHOR, WRITE_RESPONSE_INJECT, "detect x-sb-raw-body, steer the body read (#176)"],
 ] as const;
 
 /** The uWebSockets shim source: body limit + the #156 status-line fix. Exported for tests. */
@@ -244,6 +491,21 @@ export async function patchRenderJs(root: string): Promise<void> {
     src = src.slice(0, at + anchor.length) + inject + src.slice(at + anchor.length);
     changed = true;
   }
+
+  // Full-block replacements, not append-after-anchor: each needs the whole
+  // matched region gone, not just something added alongside it.
+  for (const [marker, anchor, inject, what] of RENDER_REPLACEMENTS) {
+    if (src.includes(marker)) continue;
+    if (!src.includes(anchor)) {
+      throw new Error(
+        `could not patch Porffor for ${what}: anchor not found in ${file}. ` +
+          "Porffor's native-fetch renderer changed — check patches/UPSTREAM.md.",
+      );
+    }
+    src = src.replace(anchor, inject);
+    changed = true;
+  }
+
   if (changed) await writeFile(file, src);
 }