@sproutboat/toolchain 0.4.13 → 0.4.15

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @sproutboat/toolchain
 
+## 0.4.15
+
+### Patch Changes
+
+- c9f84ac: Raise Porffor's per-coroutine fiber stack from 256 KiB to 8 MiB. A large async handler compiled at -O0 (`sproutboat dev`) overflowed it within a few nested awaits and died with SIGBUS on its first request (baronunread/sproutboat#178). Only touched pages cost memory.
+
+## 0.4.14
+
+### Patch Changes
+
+- 6c1f605: Pin and vendor Porffor alpha-10 (`08ac7ee`). Update the compiler patches for UTF-16 JSON strings, surrogate-pair UTF-8 encoding, and `TextEncoder.encodeInto` character boundaries. Verify native Unicode and date behavior against the new source.
+
 ## 0.4.13
 
 ### Patch Changes

package/PORFFOR_ALPHA10.md

@@ -0,0 +1,9 @@
+# Porffor alpha-10 upgrade audit
+
+The source pin moves from alpha-9 (`de4eb58`) to the [alpha-10 release](https://github.com/CanadaHonk/porffor/releases/tag/alpha-10), commit `08ac7ee1077c05da2bec18dcca15197051e87b62`, published September 27, 2026. The vendored codeload archive has SHA-256 `d49ce6724efde555b4cdeea0d2610baddd4310153956c79b352d86ba9cf0f60f`.
+
+Alpha-10 changes coroutine and `finally` handling, fixes object handling for `null`, replaces array storage with C reuse, and removes threads. Its `compiler/uwebsockets.js` still pins `360c276d609d59af56ae6932adb95154ace9f15f`, so the CLI's vendored uWebSockets archive does not change. The existing Sproutboat patch set applies without changing its anchors or markers.
+
+The native package suite passed 152 tests. The CLI passed 103 tests, 28 broker checks, 30 standalone checks, all 17 default examples, and the five focused Worker/handler fixtures when linked to the local runtime and toolchain. The platform's 32-handler comparison compiled all 32 and matched Bun on 30, unchanged from alpha-9. The remaining two failures are non-ISO date parsing in `15-date-iso.js` and `16-date-parts.js`. See [the scorecard](PORFFOR_SCORECARD.md) for the exact results and patch inventory.
+
+The source upgrade is ready for a toolchain package release. Existing CLI and platform lockfiles still resolve the published alpha-9 toolchain until that package is released and dependencies are refreshed.

package/PORFFOR_SCORECARD.md

@@ -1,18 +1,18 @@
 # Porffor pin scorecard
 
-Pin: alpha-9 (de4eb588264885b3a1596f75010e371a2052033f). Compatibility report: 2026-09-26T00:32:42.739Z.
+Pin: alpha-10 (08ac7ee1077c05da2bec18dcca15197051e87b62). Compatibility report: 2026-09-28T07:08:44.821Z.
 
 | Measure | Result |
 | --- | ---: |
 | Fixtures compiled | 32/32 |
 | Behavior matches | 30/32 |
-| Median / p95 compile, ms | 3139 / 3472 |
+| Median / p95 compile, ms | 4468 / 7436 |
 | Median / p95 binary, bytes | 983392 / 1016464 |
 | Patch markers | 27 |
 | Upstream files written | 6 |
 | Fresh patch application | pass |
 
-This is the first recorded pin. Compare the next pin against this snapshot.
+Previous snapshot: alpha-9-de4eb58.json. Matches 30/32 to 30/32; patch markers 27 to 27.
 
 ## Patch inventory
 
@@ -23,7 +23,7 @@ This is the first recorded pin. Compare the next pin against this snapshot.
 - `compiler/uwebsockets.js`: BODY_MARKER, STATUS_SIG_MARKER, STATUS_303_MARKER, STATUS_DEFAULT_MARKER, HDR_SIG_MARKER, HDR_CALL_MARKER, HDR_CAP_MARKER, HDR_SKIP_MARKER, HDR_APPEND_MARKER, READ_RAW_DECL_MARKER, FORBIDDEN_HDR_MARKER, WRITE_RESPONSE_MARKER, R2_TRANSFER_MARKER, R2_TRANSFER_CALL_MARKER, R2_DOWNLOAD_CACHE_MARKER, R2_RANGE_CACHE_MARKER, R2_CONDITIONAL_CACHE_MARKER, R2_STREAMING_CACHE_MARKER, R2_RANGE_HEADER_CACHE_MARKER
 - `compiler/builtins_precompiled.js`: regenerated builtin table
 
-Patch source SHA-256: `69cf5d0bcf3f4d4c05b81df0ff04b83479af622539fa19566155531bf3ee469c`.
+Patch source SHA-256: `edf60b7104e2d0b8efb64e38459fd2d5616ccdf24995ad1d4ca07fa232db4eaf`.
 
 ## Known behavior gaps
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/toolchain",
-  "version": "0.4.13",
+  "version": "0.4.15",
   "license": "MIT",
   "type": "module",
   "repository": {

package/scorecards/alpha-10-08ac7ee.json

@@ -0,0 +1,58 @@
+{
+  "pin": "alpha-10 (08ac7ee1077c05da2bec18dcca15197051e87b62)",
+  "reportGeneratedAt": "2026-09-28T07:08:44.821Z",
+  "fixtures": 32,
+  "compiled": 32,
+  "matched": 30,
+  "medianCompileMs": 4468,
+  "p95CompileMs": 7436,
+  "medianBinaryBytes": 983392,
+  "p95BinaryBytes": 1016464,
+  "patchSourceSha256": "edf60b7104e2d0b8efb64e38459fd2d5616ccdf24995ad1d4ca07fa232db4eaf",
+  "patchMarkerCount": 27,
+  "patchTargets": {
+    "compiler/render.js": [
+      "PORT_MARKER",
+      "CONSOLE_MARKER",
+      "BYTESTRING_MARKER",
+      "READ_RAW_MARKER"
+    ],
+    "compiler/index.js": [
+      "LINK_MARKER",
+      "CFLAGS_MARKER"
+    ],
+    "compiler/builtins/typedarray.js": [
+      "TYPED_ARRAY_FROM_MARKER"
+    ],
+    "compiler/builtins/date.ts": [
+      "DATE_PARSER_MARKER"
+    ],
+    "compiler/uwebsockets.js": [
+      "BODY_MARKER",
+      "STATUS_SIG_MARKER",
+      "STATUS_303_MARKER",
+      "STATUS_DEFAULT_MARKER",
+      "HDR_SIG_MARKER",
+      "HDR_CALL_MARKER",
+      "HDR_CAP_MARKER",
+      "HDR_SKIP_MARKER",
+      "HDR_APPEND_MARKER",
+      "READ_RAW_DECL_MARKER",
+      "FORBIDDEN_HDR_MARKER",
+      "WRITE_RESPONSE_MARKER",
+      "R2_TRANSFER_MARKER",
+      "R2_TRANSFER_CALL_MARKER",
+      "R2_DOWNLOAD_CACHE_MARKER",
+      "R2_RANGE_CACHE_MARKER",
+      "R2_CONDITIONAL_CACHE_MARKER",
+      "R2_STREAMING_CACHE_MARKER",
+      "R2_RANGE_HEADER_CACHE_MARKER"
+    ],
+    "compiler/builtins_precompiled.js": []
+  },
+  "patchApplication": "pass",
+  "mismatches": [
+    "15-date-iso.js: request 3 mismatch: expected {\"status\":200,\"body\":\"2008-03-04T23:00:00.000Z\",\"content-type\":null}, got {\"status\":200,\"body\":\"0003-05-08T00:00:00.000Z\",\"content-type\":null}",
+    "16-date-parts.js: request 3 mismatch: expected {\"status\":200,\"body\":\"{\\\"year\\\":2008,\\\"month\\\":3,\\\"day\\\":4}\",\"content-type\":\"application/json;charset=utf-8\"}, got {\"status\":200,\"body\":\"{\\\"year\\\":3,\\\"month\\\":5,\\\"day\\\":8}\",\"content-type\":\"application/json;charset=utf-8\"}"
+  ]
+}

package/src/acquire.test.ts

@@ -16,7 +16,7 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
   const source = join(root, `porffor-${PORFFOR_COMMIT_FULL}`);
   const files = {
     "runtime/index.js": "fixture:runtime/index.js\n",
-    "compiler/render.js":
+    "compiler/render.js": "// sb_native_utf8_scalar_v1\n" +
       "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" +
       "int porf_native_fetch_read_value(jsval value, const char** out_buf, size_t* out_len, char** out_owned) {\n" +
@@ -27,7 +27,8 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
       "    return 0;\n" +
       "  }\n" +
       "  return -1;\n" +
-      "}\n",
+      "}\n" +
+      "#define PORF_CORO_STACK_SIZE (256u * 1024u)\n",
     "compiler/index.js": "      ...darwinReleaseCompileArgs,\n        uSocketsArchive,\n        '-lm'\n",
     "compiler/precompile.js":
       "const fs = require('node:fs');\n" +
@@ -113,6 +114,8 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
       "\n" +
       "  if (body_owned) free(body_owned);\n" +
       "}\n",
+    "compiler/builtins/json.ts": "// sb_json_utf16_v1\n",
+    "runtime/fetch-globals.js": "// sb_text_encoder_scalar_v1\n",
     "compiler/builtins/promise.ts":
       "export const __Porffor_promise_resolve = (value: any, promise: any): void => {\n" +
       "  if (Porffor.type(value) == Porffor.TYPES.object) {\n" +

package/src/acquire.ts

@@ -5,7 +5,7 @@ import { homedir } from "node:os";
 import { resolve } from "node:path";
 // @ts-expect-error Bun's file loader supplies a path; see the pinned-commit
 // check below for why this is safe to trust unconditionally.
-import vendoredPorfforArchive from "../vendor/porffor-de4eb58.tar.gz" with { type: "file" };
+import vendoredPorfforArchive from "../vendor/porffor-08ac7ee.tar.gz" with { type: "file" };
 import { ensurePorfforPatched } from "./patch";
 import { PORFFOR_ARCHIVE_SHA256, PORFFOR_ARCHIVE_URL, PORFFOR_COMMIT_FULL } from "./pin";
 // Folded into the cache manifest below so a toolchain release that changes

package/src/patch.test.ts

@@ -35,6 +35,9 @@ int porf_native_fetch_read_value(jsval value, const char** out_buf, size_t* out_
 
   return -1;
 }
+
+#define PORF_CORO_STACK_SIZE (256u * 1024u)
+#define PORF_CORO_MAX 16384
 `;
 
 // Porffor's compiler/uwebsockets.js, trimmed to the parts the patch touches:
@@ -289,6 +292,10 @@ test("#165: render.js routes console output to stderr, unbuffered, idempotently"
       "int porf_native_fetch_read_value(jsval value, const char** out_buf, size_t* out_len, char** out_owned) {",
     );
 
+    // #178: fiber stacks big enough for -O0 frames in a few nested awaits.
+    expect(once).toContain("#define PORF_CORO_STACK_SIZE (8u * 1024u * 1024u)");
+    expect(once).not.toContain("(256u * 1024u)");
+
     await patchRenderJs(root);
     expect(await readFile(join(root, "compiler/render.js"), "utf8")).toBe(once);
   } finally {

package/src/patch.ts

@@ -14,6 +14,7 @@
  */
 import { readFile, realpath, writeFile } from "node:fs/promises";
 import { resolve } from "node:path";
+import { patchUnicode } from "./unicode";
 
 // --- compiler/render.js: the native-fetch server, rendered as C text ---
 
@@ -130,6 +131,24 @@ const READ_RAW_INJECT =
   READ_RAW_ANCHOR;
 const READ_RAW_MARKER = "porf_native_fetch_read_raw_bytes(jsval value";
 
+/**
+ * baronunread/sproutboat#178: every async function runs on its own fiber
+ * stack, and alpha-10 fixes those at 256 KiB. A large handler compiled at -O0
+ * (what `sproutboat dev` builds) spends ~40 KiB of stack per call into the
+ * biggest generated functions, so a few nested awaits run off the end into
+ * the guard page and the sprout dies with SIGBUS on its first request, no log.
+ * -O3 frames are smaller, which only raises the threshold: a deep enough
+ * async chain hits it in a release build too.
+ *
+ * Match a thread's usual 8 MiB. The reservation is MAP_NORESERVE with a guard
+ * page, so only touched pages cost memory and a shallow handler pays nothing.
+ */
+const CORO_STACK_ANCHOR = "#define PORF_CORO_STACK_SIZE (256u * 1024u)";
+const CORO_STACK_INJECT =
+  "// sproutboat #178: 256 KiB overflows -O0 frames in a few nested awaits.\n" +
+  "#define PORF_CORO_STACK_SIZE (8u * 1024u * 1024u)";
+const CORO_STACK_MARKER = "sproutboat #178";
+
 /**
  * render.js full-block replacements: `[marker, anchor, inject, what]`, each a
  * complete swap of the matched region (unlike `RENDER_EDITS`, which only ever
@@ -138,6 +157,7 @@ const READ_RAW_MARKER = "porf_native_fetch_read_raw_bytes(jsval value";
 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)"],
+  [CORO_STACK_MARKER, CORO_STACK_ANCHOR, CORO_STACK_INJECT, "coroutine stack size (#178)"],
 ] as const;
 
 // #15 — no `--port` flag: Porffor's native-fetch entry point calls
@@ -1032,5 +1052,6 @@ export async function ensurePorfforPatched(root: string): Promise<void> {
   await patchRenderJs(root);
   await patchDateParser(root);
   await patchTypedArrayFrom(root);
+  await patchUnicode(root);
   done.add(root);
 }

package/src/pin.ts

@@ -11,14 +11,14 @@
  * uWebSockets archive in `sproutboat-cli/vendor/` — then run both repos'
  * test + conformance suites. See sproutboat-cli/MIGRATION.md.
  */
-export const PORFFOR_CHANNEL = "alpha-9";
-export const PORFFOR_COMMIT_FULL = "de4eb588264885b3a1596f75010e371a2052033f";
+export const PORFFOR_CHANNEL = "alpha-10";
+export const PORFFOR_COMMIT_FULL = "08ac7ee1077c05da2bec18dcca15197051e87b62";
 export const PORFFOR_COMMIT = PORFFOR_COMMIT_FULL.slice(0, 7);
 export const PORFFOR_ARCHIVE_SHA256 =
-  "1a62187a93356b36cb6ac703ce9770c8917e4fa65545fd7c33ee8a180ae5a4c9";
+  "d49ce6724efde555b4cdeea0d2610baddd4310153956c79b352d86ba9cf0f60f";
 export const PORFFOR_ARCHIVE_URL = `https://codeload.github.com/CanadaHonk/porffor/tar.gz/${PORFFOR_COMMIT_FULL}`;
 
-/** A compact identity string for a manifest / report (`alpha-9 (de4eb58)`). */
+/** A compact identity string for a manifest / report (`alpha-10 (08ac7ee)`). */
 export function porfforVersion(): string {
   return process.env.PORFFOR_VERSION || `${PORFFOR_CHANNEL} (${PORFFOR_COMMIT})`;
 }

package/src/unicode-native.test.ts

@@ -0,0 +1,113 @@
+import { expect, test } from "bun:test";
+import { cp, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ensurePorffor } from "./acquire";
+import { ensurePorfforPatched } from "./patch";
+import {
+  preludePath,
+  TRANSPORT_MARKER,
+  transportPath,
+  wrapNativeFetchHandler,
+} from "../../runtime/src/wrap";
+
+// Bun tests alone cannot expose Porffor's string representations or native
+// wire encoding. Compile a real HTTP handler and compare it with Bun vectors.
+test("native Unicode JSON and UTF-8 encoding preserve code points and buffer boundaries", async () => {
+  const work = await mkdtemp(join(tmpdir(), "sb-unicode-native-"));
+  let child: ReturnType<typeof Bun.spawn> | undefined;
+  try {
+    // Start from the verified pinned checkout, then patch only a private copy.
+    // SPROUTBOAT_PORFFOR_DIR can point at an already-isolated dev compiler.
+    const compiler = await ensurePorffor();
+    const isolated = join(work, "porffor");
+    await cp(compiler, isolated, { recursive: true });
+    await ensurePorfforPatched(isolated);
+    const inputs = ["ASCII", "caffè", "東京", "🚤", "x🚤y", "\ud800", "\udc00", "\ud800x"];
+    const source = join(work, "unicode.js");
+    const binary = join(work, "unicode-native");
+    const code = `export default { fetch() {
+      const values = ${JSON.stringify(inputs)};
+      const encoded = [];
+      const into = [];
+      for (const value of values) {
+        encoded.push(Array.from(new TextEncoder().encode(value)));
+        const rows = [];
+        for (let size = 0; size <= 6; size++) {
+          const dest = new Uint8Array(size);
+          const counts = new TextEncoder().encodeInto(value, dest);
+          rows.push({ counts, bytes: Array.from(dest) });
+        }
+        into.push(rows);
+      }
+      const nested = JSON.parse('{"東京":{"id":"🚤","plain":"caffè"}}');
+      const escaped = JSON.parse('"\\\\ud83d\\\\udea4"');
+      const long = "🚤".repeat(4096);
+      const growth = JSON.parse(JSON.stringify({ value: long })).value;
+      const negatives = [];
+      for (const invalid of ['{', '{} trailing', '"\\\\uZZZZ"', '[1,]']) {
+        let rejected = false;
+        try { JSON.parse(invalid); } catch { rejected = true; }
+        negatives.push(rejected);
+      }
+      const lone = JSON.parse(JSON.stringify({ value: String.fromCharCode(0xd800) }));
+      const quotedKey = JSON.parse(JSON.stringify({ ['quote"key']: "🚤" }));
+      return Response.json({ encoded, into, nested, escaped, growth, negatives, lone, quotedKey });
+    } };`;
+    const [prelude, transport] = await Promise.all([
+      readFile(preludePath, "utf8"),
+      readFile(transportPath("broker"), "utf8"),
+    ]);
+    await writeFile(
+      source,
+      wrapNativeFetchHandler(code, prelude.replace(TRANSPORT_MARKER, transport)),
+    );
+    const compile = Bun.spawnSync(
+      ["bun", join(isolated, "runtime/index.js"), "native", source, "-o", binary, "-s"],
+      { cwd: work, stdout: "pipe", stderr: "pipe" },
+    );
+    expect(compile.exitCode, compile.stderr.toString()).toBe(0);
+    const listener = Bun.listen({ hostname: "127.0.0.1", port: 0, socket: { data() {} } });
+    const port = listener.port;
+    listener.stop(true);
+    child = Bun.spawn([binary], {
+      env: { ...process.env, PORT: String(port) },
+      stdout: "ignore",
+      stderr: "pipe",
+    });
+    let response: Response | undefined;
+    for (let attempt = 0; attempt < 100; attempt++) {
+      try {
+        response = await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(500) });
+        break;
+      } catch {}
+      if (child.exitCode !== null) break;
+      await Bun.sleep(50);
+    }
+    expect(response).toBeDefined();
+    const actual = await response!.json();
+    expect(actual.encoded).toEqual(
+      inputs.map((input) => Array.from(new TextEncoder().encode(input))),
+    );
+    expect(actual.into).toEqual(
+      inputs.map((input) =>
+        Array.from({ length: 7 }, (_, size) => {
+          const bytes = new Uint8Array(size);
+          return { counts: new TextEncoder().encodeInto(input, bytes), bytes: Array.from(bytes) };
+        }),
+      ),
+    );
+    expect(actual.nested).toEqual({ 東京: { id: "🚤", plain: "caffè" } });
+    expect(actual.escaped).toBe("🚤");
+    expect(actual.growth).toBe("🚤".repeat(4096));
+    expect(actual.lone).toEqual({ value: "\ud800" });
+    expect(actual.quotedKey).toEqual({ 'quote"key': "🚤" });
+    expect(actual.negatives).toEqual([true, true, true, true]);
+  } finally {
+    if (child) {
+      child.kill(9);
+      await child.exited;
+    }
+    await rm(work, { recursive: true, force: true });
+  }
+}, 60_000);

package/src/unicode.test.ts

@@ -0,0 +1,42 @@
+import { expect, test } from "bun:test";
+import { unicodeEncoderSource } from "./unicode";
+const source = unicodeEncoderSource("class TextEncoder { }\nclass TextDecoder { }");
+// oxlint-disable-next-line no-function-constructor -- Test the replacement source inserted into Porffor's fetch globals.
+const Encoder = new Function(`${source}\nreturn TextEncoder;`)();
+
+test("UTF-8 encoding matches WebCrypto inputs for BMP, astral and lone surrogates", () => {
+  for (const input of [
+    "",
+    "ASCII",
+    "caffè",
+    "東京",
+    "🚤",
+    "x🚤y",
+    "\ud800",
+    "\udc00",
+    "\ud800x",
+    "🚤".repeat(1000),
+  ]) {
+    expect(Array.from(new Encoder().encode(input))).toEqual(
+      Array.from(new TextEncoder().encode(input)),
+    );
+  }
+});
+
+test("encodeInto stops before a split UTF-8 character and counts UTF-16 units", () => {
+  for (const input of ["🚤", "x🚤y", "éx", "\ud800x"]) {
+    for (let size = 0; size <= 10; size++) {
+      const actual = new Uint8Array(size);
+      const expected = new Uint8Array(size);
+      expect(new Encoder().encodeInto(input, actual)).toEqual(
+        new TextEncoder().encodeInto(input, expected),
+      );
+      expect(actual).toEqual(expected);
+    }
+  }
+});
+
+test("encoder patch is idempotent and refuses a changed upstream layout", () => {
+  expect(unicodeEncoderSource(source)).toBe(source);
+  expect(() => unicodeEncoderSource("unexpected upstream")).toThrow();
+});

package/src/unicode.ts

@@ -0,0 +1,233 @@
+import { createHash } from "node:crypto";
+import { readFile, realpath, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+const JSON_MARKER = "sb_json_utf16_v1";
+const ENCODER_MARKER = "sb_text_encoder_scalar_v1";
+function replace(source: string, anchor: string, replacement: string): string {
+  if (!source.includes(anchor)) throw new Error(`Porffor Unicode patch anchor missing: ${anchor}`);
+  return source.replaceAll(anchor, replacement);
+}
+
+// Keep Porffor's parser/serializer, but store UTF-16 code units instead of
+// truncating them into byte buffers. Dynamic inputs may be either string form.
+export function unicodeJsonSource(source: string): string {
+  if (source.includes(JSON_MARKER)) return source;
+  const start = source.indexOf("export const __Porffor_bytestring_bufferStr");
+  const end = source.indexOf("export const __Porffor_json_canSerialize");
+  if (start < 0 || end < start) throw new Error("Porffor JSON buffer helpers not found");
+  source =
+    source.slice(0, start) +
+    `
+// ${JSON_MARKER}
+export const __Porffor_bytestring_bufferStr = (buffer: i32, str: any): i32 => {
+  const len: i32 = str.length;
+  if (buffer + 4 + len * 2 > __Porffor_json_bufLimit) return buffer + len * 2;
+  for (let i: i32 = 0; i < len; i++) Porffor.IR.storeU16(buffer + i * 2, 4, str.charCodeAt(i));
+  return buffer + len * 2;
+};
+export const __Porffor_bytestring_bufferChar = (buffer: i32, char: i32): i32 => {
+  if (buffer + 6 > __Porffor_json_bufLimit) return buffer + 2;
+  Porffor.IR.storeU16(buffer, 4, char);
+  return buffer + 2;
+};
+export const __Porffor_bytestring_buffer2Char = (buffer: i32, a: i32, b: i32): i32 => {
+  buffer = __Porffor_bytestring_bufferChar(buffer, a);
+  return __Porffor_bytestring_bufferChar(buffer, b);
+};
+export const __Porffor_json_appendChar = (out: string, char: i32): void => {
+  const len: i32 = out.length;
+  Porffor.IR.storeU16(Porffor.IR.ptr(out) + len * 2, 4, char);
+  out.length = len + 1;
+};
+` +
+    source.slice(end);
+  source = replace(source, "text: bytestring", "text: any");
+  source = replace(source, "(_: bytestring)", "(_: any)");
+  source = replace(
+    source,
+    "const out: bytestring = Porffor.malloc(6 + (strEnd - pos));",
+    "const out: string = Porffor.malloc(4 + (strEnd - pos) * 2);",
+  );
+  source = replace(source, "Porffor.bytestring.appendChar(out,", "__Porffor_json_appendChar(out,");
+  source = replace(
+    source,
+    "Porffor.callThis(__ByteString_prototype_slice, text, start, pos)",
+    "text.slice(start, pos)",
+  );
+  source = replace(
+    source,
+    "let buffer: bytestring = Porffor.malloc(6 + cap);",
+    "let buffer: string = Porffor.malloc(4 + cap);",
+  );
+  source = replace(
+    source,
+    "buffer = Porffor.malloc(6 + cap);",
+    "buffer = Porffor.malloc(4 + cap);",
+  );
+  source = replace(
+    source,
+    "buffer.length = out - (buffer as i32);",
+    "buffer.length = (out - (buffer as i32)) / 2;",
+  );
+  source = replace(source, "(buffer - _buffer) > 1", "(buffer - _buffer) > 2");
+  source = replace(source, "Porffor.IR.storeU8(buffer, 3,", "Porffor.IR.storeU16(buffer, 2,");
+  source = replace(source, "for (const key: bytestring in", "for (const key: any in");
+  // Serialize object keys through the string escaping path too.
+  source = replace(
+    source,
+    `      buffer = __Porffor_bytestring_bufferChar(buffer, 34); // "
+      buffer = __Porffor_bytestring_bufferStr(buffer, key);
+      buffer = __Porffor_bytestring_bufferChar(buffer, 34); // "`,
+    "      buffer = __Porffor_json_serialize(buffer, key, depth, undefined);",
+  );
+  source = replace(
+    source,
+    `      // todo: support non-bytestrings
+      buffer = __Porffor_bytestring_bufferChar(buffer, c);`,
+    `      // Well-formed JSON.stringify escapes lone surrogate code units.
+      if ((c >= 0xd800 && c <= 0xdbff && (i + 1 >= len || value.charCodeAt(i + 1) < 0xdc00 || value.charCodeAt(i + 1) > 0xdfff)) ||
+          (c >= 0xdc00 && c <= 0xdfff && (i == 0 || value.charCodeAt(i - 1) < 0xd800 || value.charCodeAt(i - 1) > 0xdbff))) {
+        buffer = __Porffor_bytestring_buffer2Char(buffer, 92, 117);
+        for (let shift: i32 = 12; shift >= 0; shift -= 4) {
+          const digit: i32 = (c >> shift) & 15;
+          buffer = __Porffor_bytestring_bufferChar(buffer, digit < 10 ? digit + 48 : digit + 87);
+        }
+        continue;
+      }
+      buffer = __Porffor_bytestring_bufferChar(buffer, c);`,
+  );
+  // JSON.parse must reject trailing non-whitespace, not just parse a prefix.
+  source = replace(
+    source,
+    "return __Porffor_json_parseValue(_, posPtr, _.length);",
+    `const result: any = __Porffor_json_parseValue(_, posPtr, _.length);
+  if (__Porffor_json_skipWhitespace(_, Porffor.IR.loadI32(posPtr, 0), _.length) != _.length) throw new SyntaxError('Unexpected trailing JSON input');
+  return result;`,
+  );
+  return source;
+}
+
+const ENCODER = `class TextEncoder {
+  // ${ENCODER_MARKER}
+  get encoding() { return 'utf-8'; }
+  encode(input = '') {
+    const text = String(input);
+    let length = 0;
+    for (let i = 0; i < text.length; i++) {
+      const c = text.charCodeAt(i);
+      if (c >= 0xd800 && c <= 0xdbff && i + 1 < text.length && text.charCodeAt(i + 1) >= 0xdc00 && text.charCodeAt(i + 1) <= 0xdfff) { length += 4; i++; }
+      else length += c < 0x80 ? 1 : c < 0x800 ? 2 : 3;
+    }
+    const out = new Uint8Array(length);
+    this.encodeInto(text, out);
+    return out;
+  }
+  encodeInto(source, destination) {
+    const text = String(source);
+    let read = 0;
+    let written = 0;
+    while (read < text.length) {
+      let cp = text.charCodeAt(read);
+      let units = 1;
+      if (cp >= 0xd800 && cp <= 0xdbff && read + 1 < text.length && text.charCodeAt(read + 1) >= 0xdc00 && text.charCodeAt(read + 1) <= 0xdfff) {
+        cp = 0x10000 + ((cp - 0xd800) << 10) + text.charCodeAt(read + 1) - 0xdc00;
+        units = 2;
+      } else if (cp >= 0xd800 && cp <= 0xdfff) cp = 0xfffd;
+      const count = cp < 0x80 ? 1 : cp < 0x800 ? 2 : cp < 0x10000 ? 3 : 4;
+      if (written + count > destination.length) break;
+      if (count === 1) destination[written++] = cp;
+      else if (count === 2) {
+        destination[written++] = 0xc0 | (cp >> 6);
+        destination[written++] = 0x80 | (cp & 0x3f);
+      } else if (count === 3) {
+        destination[written++] = 0xe0 | (cp >> 12);
+        destination[written++] = 0x80 | ((cp >> 6) & 0x3f);
+        destination[written++] = 0x80 | (cp & 0x3f);
+      } else {
+        destination[written++] = 0xf0 | (cp >> 18);
+        destination[written++] = 0x80 | ((cp >> 12) & 0x3f);
+        destination[written++] = 0x80 | ((cp >> 6) & 0x3f);
+        destination[written++] = 0x80 | (cp & 0x3f);
+      }
+      read += units;
+    }
+    return { read, written };
+  }
+}
+
+`;
+export function unicodeEncoderSource(source: string): string {
+  if (source.includes(ENCODER_MARKER)) return source;
+  const start = source.indexOf("class TextEncoder {");
+  const end = source.indexOf("class TextDecoder {", start);
+  if (start < 0 || end < start) throw new Error("Porffor TextEncoder block not found");
+  return source.slice(0, start) + ENCODER + source.slice(end);
+}
+
+export function unicodeWireSource(source: string): string {
+  const marker = "sb_native_utf8_scalar_v1";
+  if (source.includes(marker)) return source;
+  const start = source.indexOf("  if (value.type == ${TYPES.string}) {");
+  const end = source.indexOf("    utf8[out_len_local]", start);
+  if (start < 0 || end < start) throw new Error("Porffor UTF-16 wire encoder not found");
+  let block = source.slice(start, end);
+  block = replace(
+    block,
+    "      u16 c = chars[i];",
+    `      // ${marker}
+      u32 c = chars[i];
+      if (c >= 0xd800 && c <= 0xdbff && i + 1 < len && chars[i + 1] >= 0xdc00 && chars[i + 1] <= 0xdfff) {
+        c = 0x10000 + ((c - 0xd800) << 10) + chars[++i] - 0xdc00;
+      } else if (c >= 0xd800 && c <= 0xdfff) c = 0xfffd;`,
+  );
+  block = replace(
+    block,
+    `      } else {
+        utf8[out_len_local++] = (char)(0xe0 | (c >> 12));
+        utf8[out_len_local++] = (char)(0x80 | ((c >> 6) & 0x3f));
+        utf8[out_len_local++] = (char)(0x80 | (c & 0x3f));
+      }`,
+    `      } else if (c < 0x10000) {
+        utf8[out_len_local++] = (char)(0xe0 | (c >> 12));
+        utf8[out_len_local++] = (char)(0x80 | ((c >> 6) & 0x3f));
+        utf8[out_len_local++] = (char)(0x80 | (c & 0x3f));
+      } else {
+        utf8[out_len_local++] = (char)(0xf0 | (c >> 18));
+        utf8[out_len_local++] = (char)(0x80 | ((c >> 12) & 0x3f));
+        utf8[out_len_local++] = (char)(0x80 | ((c >> 6) & 0x3f));
+        utf8[out_len_local++] = (char)(0x80 | (c & 0x3f));
+      }`,
+  );
+  return source.slice(0, start) + block + source.slice(end);
+}
+
+export async function patchUnicode(root: string): Promise<void> {
+  const renderPath = resolve(root, "compiler/render.js");
+  await writeFile(renderPath, unicodeWireSource(await readFile(renderPath, "utf8")));
+  const jsonPath = resolve(root, "compiler/builtins/json.ts");
+  const globalsPath = resolve(root, "runtime/fetch-globals.js");
+  const json = unicodeJsonSource(await readFile(jsonPath, "utf8"));
+  const globals = unicodeEncoderSource(await readFile(globalsPath, "utf8"));
+  await writeFile(jsonPath, json);
+  await writeFile(globalsPath, globals);
+  // Source edits alone do not change the builtin table used by native builds.
+  const digest = createHash("sha256").update(json).digest("hex");
+  const stamp = resolve(root, "compiler/.sb-unicode-json");
+  let previous = "";
+  try {
+    previous = await readFile(stamp, "utf8");
+  } catch {
+    /* first build */
+  }
+  if (previous === digest) return;
+  const precompile = await realpath(resolve(root, "compiler/precompile.js"));
+  const child = Bun.spawn(["bun", precompile], { cwd: root, stdout: "pipe", stderr: "pipe" });
+  const [code, stdout, stderr] = await Promise.all([
+    child.exited,
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+  ]);
+  if (code !== 0) throw new Error(`could not precompile Unicode JSON: ${stderr || stdout}`);
+  await writeFile(stamp, digest);
+}