@sproutboat/toolchain 0.7.0 → 0.8.1

package/src/patch.test.ts

@@ -3,7 +3,31 @@ import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { EMPTY_BINDINGS, wrapNativeFetchHandler } from "../../runtime/src/wrap";
-import { patchLocalFunctionTypes, patchUint8ArrayBase64, patchRenderJs, patchUwebsockets } from "./patch";
+import {
+  patchHeadersArrayInit,
+  patchLocalFunctionTypes,
+  patchDeferredDiscard,
+  patchMapGroupBy,
+  patchPrivateFieldsHidden,
+  patchRepeatDoubling,
+  patchJsonCycles,
+  patchTypedArrayTag,
+  patchConsoleColors,
+  patchCaseMapping,
+  patchZeroDelayTimers,
+  patchStreamingResponses,
+  patchSplitGlobals,
+  patchBlobClass,
+  patchFetchClasses,
+  patchResponseBytes,
+  patchHeadersClass,
+  patchTextDecoder,
+  patchResponseDefaults,
+  patchURLClass,
+  patchUint8ArrayBase64,
+  patchRenderJs,
+  patchUwebsockets,
+} from "./patch";
 
 // The parts of Porffor's compiler/render.js the patch anchors to.
 const RENDER = `void porf_native_fetch_runtime_init(void) {
@@ -159,9 +183,13 @@ test("#156: status-line fallback synthesizes a line for unlisted codes, idempote
     const once = await readFile(join(root, "compiler/uwebsockets.js"), "utf8");
 
     // Return type widened, empty fallback replaced, known cases untouched.
-    expect(once).toContain("static std::string lookup_status_line(i32 status) {");
+    expect(once).toContain(
+      "static std::string lookup_status_line(i32 status) {",
+    );
     expect(once).not.toContain("std::string_view lookup_status_line");
-    expect(once).toContain('default: return std::to_string(status) + " Status";');
+    expect(once).toContain(
+      'default: return std::to_string(status) + " Status";',
+    );
     expect(once).not.toContain("default: return {};");
     expect(once).toContain('case 302: return "302 Found";');
     // 303 gets its real phrase; the switch stays well-formed (302 still present once).
@@ -184,10 +212,14 @@ test("#156: status-line fallback synthesizes a line for unlisted codes, idempote
     expect(once).toContain(
       "static i32 collect_headers(uWS::HttpRequest* req, uWS::HttpResponse<false>* res) {",
     );
-    expect(once).toContain("const i32 headers_ptr = collect_headers(req, res);");
+    expect(once).toContain(
+      "const i32 headers_ptr = collect_headers(req, res);",
+    );
     expect(once).toContain('if (key == "x-sb-remote-addr") continue;');
     expect(once).toContain("res->getRemoteAddressAsText()");
-    expect(once).toContain('porf_native_fetch_alloc_bytestring("x-sb-remote-addr", 16)');
+    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
@@ -204,10 +236,12 @@ test("#156: status-line fallback synthesizes a line for unlisted codes, idempote
       '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);",
+      "if (raw_body && porf_native_fetch_read_raw_bytes(body_value, &body_buf, &body_len) != 0 && body_value.type == 67) {",
     );
+    // A UTF-16 body (type 67) is narrowed unit by unit, never UTF-8 encoded.
+    expect(once).toContain("body_owned[i] = (char)(units[i] & 0xff);");
     expect(once).toContain(
-      "else porf_native_fetch_read_value(body_value, &body_buf, &body_len, &body_owned);",
+      "} else if (!raw_body || !body_buf) 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(
@@ -218,7 +252,9 @@ test("#156: status-line fallback synthesizes a line for unlisted codes, idempote
     );
 
     await patchUwebsockets(root);
-    expect(await readFile(join(root, "compiler/uwebsockets.js"), "utf8")).toBe(once);
+    expect(await readFile(join(root, "compiler/uwebsockets.js"), "utf8")).toBe(
+      once,
+    );
   } finally {
     await rm(root, { recursive: true, force: true });
   }
@@ -228,7 +264,10 @@ test("a drifted shim fails loudly instead of silently no-op'ing", async () => {
   const root = await mkdtemp(join(tmpdir(), "sb-patch-uws-drift-"));
   try {
     await mkdir(join(root, "compiler"), { recursive: true });
-    await writeFile(join(root, "compiler/uwebsockets.js"), "// nothing the patch recognizes\n");
+    await writeFile(
+      join(root, "compiler/uwebsockets.js"),
+      "// nothing the patch recognizes\n",
+    );
     await expect(patchUwebsockets(root)).rejects.toThrow(/anchor not found/);
   } finally {
     await rm(root, { recursive: true, force: true });
@@ -241,8 +280,11 @@ test("broker transport defines every direct R2 transfer symbol the patched shim
     await patchUwebsockets(root);
     const shim = await readFile(join(root, "compiler/uwebsockets.js"), "utf8");
     const abi = shim.match(/extern "C" \{([\s\S]*?)\n\}/)?.[1];
-    if (abi === undefined) throw new Error("patched shim did not contain the R2 transfer ABI");
-    const required = [...abi.matchAll(/\b(sb_r2_transfer_[a-z_]+)\s*\(/g)].map((match) => match[1]);
+    if (abi === undefined)
+      throw new Error("patched shim did not contain the R2 transfer ABI");
+    const required = [...abi.matchAll(/\b(sb_r2_transfer_[a-z_]+)\s*\(/g)].map(
+      (match) => match[1],
+    );
     const wrapped = wrapNativeFetchHandler(
       "export default { fetch() { return new Response('ok'); } }",
       "",
@@ -274,7 +316,9 @@ test("#165: render.js routes console output to stderr, unbuffered, idempotently"
     expect(once).toContain("dup2(2, 1);");
     expect(once).toContain("setvbuf(stdout, NULL, _IONBF, 0);");
     // Injected inside runtime_init, right after the SIGPIPE line.
-    expect(once).toMatch(/signal\(SIGPIPE, SIG_IGN\);\n {2}\/\* sproutboat #165/);
+    expect(once).toMatch(
+      /signal\(SIGPIPE, SIG_IGN\);\n {2}\/\* sproutboat #165/,
+    );
     // The $PORT edit still lands too.
     expect(once).toContain('getenv("PORT")');
 
@@ -300,13 +344,15 @@ test("#165: render.js routes console output to stderr, unbuffered, idempotently"
   }
 });
 
-
 test("local function type patch registers lexical bindings and is idempotent", async () => {
   const root = await mkdtemp(join(tmpdir(), "sb-local-functions-"));
   try {
     await mkdir(join(root, "compiler"));
     const file = join(root, "compiler/codegen.js");
-    await writeFile(file, "if (!hoistRead && directCallOnlyFunctionBinding(scope, kind, name, pattern, func)) {\n        return valUndefined();\n}\nconst func = resolveNamedFunction(scope, name) ?? funcByName(name);");
+    await writeFile(
+      file,
+      "if (!hoistRead && directCallOnlyFunctionBinding(scope, kind, name, pattern, func)) {\n        return valUndefined();\n}\nconst func = resolveNamedFunction(scope, name) ?? funcByName(name);",
+    );
     await patchLocalFunctionTypes(root);
     const patched = await readFile(file, "utf8");
     expect(patched).toContain("bindNamedFunction(scope, name, func);");
@@ -318,13 +364,15 @@ test("local function type patch registers lexical bindings and is idempotent", a
   }
 });
 
-
 test("base64 patch preserves option tags and truncates full chunks, idempotently", async () => {
   const root = await mkdtemp(join(tmpdir(), "sb-base64-patch-"));
   try {
     await mkdir(join(root, "compiler/builtins"), { recursive: true });
     const file = join(root, "compiler/builtins/uint8array_base64.ts");
-    await writeFile(file, "let alphabet: string = 'base64';\nlet lastChunkHandling: string = 'loose';\nconst fullChunks: i32 = (len / 3) * 3;");
+    await writeFile(
+      file,
+      "let alphabet: string = 'base64';\nlet lastChunkHandling: string = 'loose';\nconst fullChunks: i32 = (len / 3) * 3;",
+    );
     await patchUint8ArrayBase64(root);
     const patched = await readFile(file, "utf8");
     expect(patched).toContain("let alphabet: any =");
@@ -336,3 +384,426 @@ test("base64 patch preserves option tags and truncates full chunks, idempotently
     await rm(root, { recursive: true, force: true });
   }
 });
+
+test("Response defaults patch types string bodies only, idempotently", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-response-defaults-"));
+  try {
+    await mkdir(join(root, "runtime"));
+    const file = join(root, "runtime/fetch-globals.js");
+    await writeFile(
+      file,
+      "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  }\n}\n",
+    );
+    await patchResponseDefaults(root);
+    const patched = await readFile(file, "utf8");
+    expect(patched).toContain(
+      "if (typeof body === 'string' && !this.headers.has('content-type')) this.headers.set('content-type', 'text/plain;charset=UTF-8');",
+    );
+    await patchResponseDefaults(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+    await writeFile(file, "class Response {}\n");
+    await expect(patchResponseDefaults(root)).rejects.toThrow(
+      "anchor not found",
+    );
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("Headers array-init patch sends arrays to the sequence branch, idempotently", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-headers-array-"));
+  try {
+    await mkdir(join(root, "runtime"));
+    const file = join(root, "runtime/fetch-globals.js");
+    await writeFile(
+      file,
+      "    if (Porffor.type(init.entries) == Porffor.TYPES.function) {\n      this._entries = Porffor.array.new(8);\n      for (const entry of init.entries()) {\n",
+    );
+    await patchHeadersArrayInit(root);
+    const patched = await readFile(file, "utf8");
+    expect(patched).toContain(
+      "if (!Array.isArray(init) && Porffor.type(init.entries) == Porffor.TYPES.function) {",
+    );
+    await patchHeadersArrayInit(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("URL patch replaces Porffor's URL class, idempotently", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-url-class-"));
+  try {
+    await mkdir(join(root, "runtime"));
+    const file = join(root, "runtime/fetch-globals.js");
+    await writeFile(
+      file,
+      "class TextDecoder {}\n\nclass URL {\n  constructor(input) {\n    this.href = '';\n  }\n}\n\nclass Request {\n  constructor() {}\n}\n",
+    );
+    await patchURLClass(root);
+    const patched = await readFile(file, "utf8");
+    expect(patched).toContain("sproutboat: WHATWG-style URL");
+    expect(patched).not.toContain("this.href = '';");
+    expect(patched.startsWith("class TextDecoder {}\n\nclass URL {")).toBe(true);
+    expect(patched.endsWith("}\n\nclass Request {\n  constructor() {}\n}\n")).toBe(true);
+    await patchURLClass(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+    await writeFile(file, "class URL {}\n");
+    await expect(patchURLClass(root)).rejects.toThrow("anchor not found");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+
+test("Map.groupBy patch appends the builtin once and refuses an upstream one", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-map-groupby-"));
+  try {
+    await mkdir(join(root, "compiler/builtins"), { recursive: true });
+    const file = join(root, "compiler/builtins/map.ts");
+    await writeFile(file, "export const Map = function (iterable: any): Map {\n};\n");
+    await patchMapGroupBy(root);
+    const patched = await readFile(file, "utf8");
+    expect(patched).toContain("export const __Map_groupBy = (items: any, callbackFn: any): Map => {");
+    await patchMapGroupBy(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+    await writeFile(file, "export const Map = function (iterable: any): Map {\n};\nexport const __Map_groupBy = 1;\n");
+    await expect(patchMapGroupBy(root)).rejects.toThrow("drop patchMapGroupBy");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("private field patch installs instance and static private fields as methods, idempotently", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-private-fields-"));
+  try {
+    await mkdir(join(root, "compiler"));
+    const file = join(root, "compiler/codegen.js");
+    await writeFile(
+      file,
+      "        builtinCall(func, '__Porffor_object_class_value', [\n" +
+        "      if (kind === 'get' || kind === 'set') initKind = kind;\n",
+    );
+    await patchPrivateFieldsHidden(root);
+    const patched = await readFile(file, "utf8");
+    expect(patched).toContain("x.key?.type === 'PrivateIdentifier' ? '__Porffor_object_class_method' : '__Porffor_object_class_value'");
+    expect(patched).toContain("if (initKind === 'value' && x.key?.type === 'PrivateIdentifier') initKind = 'method';");
+    await patchPrivateFieldsHidden(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+    await writeFile(file, "export const x = 1;\n");
+    await expect(patchPrivateFieldsHidden(root)).rejects.toThrow("anchor not found");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("deferred discard patch moves page discard to the idle collection, idempotently", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-deferred-discard-"));
+  try {
+    await mkdir(join(root, "compiler"));
+    const file = join(root, "compiler/render.js");
+    await writeFile(
+      file,
+      "static i32 porf_gc_mark_queue_cap = 0;\n" +
+        "    porf_gc_discard_free_runs();\n" +
+        "porf_gc_mark_queue_cap > 65536);' : '  return 0;'\n" +
+        "  porf_c_stack_top = stack_top;\n  porf_gc_collect(0);\n  // The mark queue is empty\n",
+    );
+    await patchDeferredDiscard(root);
+    const patched = await readFile(file, "utf8");
+    expect(patched).toContain("if (porf_gc_discard_now) porf_gc_discard_free_runs(); else porf_gc_discard_pending = 1;");
+    expect(patched).toContain("porf_gc_discard_pending || porf_gc_claimed_since_full > 0 || porf_gc_promoted_since_full > 0);");
+    expect(patched).toContain("  porf_gc_discard_now = 1;\n  porf_gc_collect(0);\n  porf_gc_discard_now = 0;\n  porf_gc_discard_pending = 0;");
+    await patchDeferredDiscard(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+    await writeFile(file, "export const x = 1;\n");
+    await expect(patchDeferredDiscard(root)).rejects.toThrow("anchor not found");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("repeat patch replaces both per-repetition loops once", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-repeat-patch-"));
+  try {
+    await mkdir(join(root, "compiler/builtins"), { recursive: true });
+    const file = join(root, "compiler/builtins/string.ts");
+    const 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";
+    await writeFile(file, "a\n" + loop + "b\n" + loop);
+    await patchRepeatDoubling(root);
+    const patched = await readFile(file, "utf8");
+    expect(patched.split("sproutboat B16: doubling repeat").length).toBe(3);
+    expect(patched).not.toContain("i * thisLen");
+    await patchRepeatDoubling(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+    await writeFile(file, "a\n" + loop);
+    await expect(patchRepeatDoubling(root)).rejects.toThrow("anchor not found twice");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("ensurePorfforPatched trusts a cache entry this toolchain version and patch chain patched, and nothing else", async () => {
+  const { ensurePorfforPatched } = await import("./patch");
+  const { PORFFOR_COMMIT_FULL } = await import("./pin");
+  const { PATCH_FINGERPRINT } = await import("./fingerprint");
+  const { version } = await import("../package.json");
+  const root = await mkdtemp(join(tmpdir(), "sb-patched-stamp-"));
+  try {
+    // An empty tree: running the chain would throw on the first missing file.
+    await writeFile(join(root, ".sproutboat-complete"), JSON.stringify({ commit: PORFFOR_COMMIT_FULL, toolchainVersion: version, patchFingerprint: PATCH_FINGERPRINT }));
+    await ensurePorfforPatched(root);
+    const stale = await mkdtemp(join(tmpdir(), "sb-patched-stale-"));
+    try {
+      await writeFile(join(stale, ".sproutboat-complete"), JSON.stringify({ commit: PORFFOR_COMMIT_FULL, toolchainVersion: "0.0.0" }));
+      await expect(ensurePorfforPatched(stale)).rejects.toThrow();
+      // Same release, older patch chain (B19): the chain runs again.
+      await writeFile(join(stale, ".sproutboat-complete"), JSON.stringify({ commit: PORFFOR_COMMIT_FULL, toolchainVersion: version, patchFingerprint: "000000000000" }));
+      await expect(ensurePorfforPatched(stale)).rejects.toThrow();
+    } finally {
+      await rm(stale, { recursive: true, force: true });
+    }
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("JSON cycle patch adds an ancestor stack around arrays and objects, idempotently", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-json-cycles-"));
+  try {
+    await mkdir(join(root, "compiler/builtins"), { recursive: true });
+    const file = join(root, "compiler/builtins/json.ts");
+    await writeFile(
+      file,
+      "let __Porffor_json_bufLimit: i32 = 0;\n    depth += 1;\n    depth -= 1;\n    depth += 1;\n    depth -= 1;\n" +
+        "  let out: i32 = __Porffor_json_serialize(buffer, value, 0, space);\n",
+    );
+    await patchJsonCycles(root);
+    const patched = await readFile(file, "utf8");
+    expect(patched.split("__Porffor_json_enter(value);").length).toBe(3);
+    expect(patched.split("__Porffor_json_leave();").length).toBe(3);
+    expect(patched).toContain("throw new TypeError('Converting circular structure to JSON');");
+    await patchJsonCycles(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+    await writeFile(file, "let __Porffor_json_bufLimit: i32 = 0;\n");
+    await expect(patchJsonCycles(root)).rejects.toThrow("anchor not found");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("typed array tag patch names every typed array before toString returns, idempotently", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-ta-tag-"));
+  try {
+    await mkdir(join(root, "compiler/builtins"), { recursive: true });
+    const file = join(root, "compiler/builtins/object.ts");
+    await writeFile(file, "  return '[object ' + builtinTag + ']';\n};\n");
+    await patchTypedArrayTag(root);
+    const patched = await readFile(file, "utf8");
+    for (const name of ["Uint8Array", "Uint8ClampedArray", "BigInt64Array", "Float64Array"]) expect(patched).toContain(`builtinTag = '${name}';`);
+    await patchTypedArrayTag(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+    await writeFile(file, "export const x = 1;\n");
+    await expect(patchTypedArrayTag(root)).rejects.toThrow("anchor not found");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("console colour patch colours only on a terminal, idempotently", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-console-colors-"));
+  try {
+    await mkdir(join(root, "compiler/builtins"), { recursive: true });
+    const file = join(root, "compiler/builtins/console.ts");
+    await writeFile(file, "export const __Porffor_consolePrint = (arg: any): void => {\n  if (x) return;\n  __Porffor_print(arg);\n};\n");
+    await patchConsoleColors(root);
+    const patched = await readFile(file, "utf8");
+    expect(patched).toContain("Porffor.c`tty = isatty(1) ? 1 : 0;`;");
+    expect(patched).toContain("  __Porffor_print(arg, __Porffor_consoleColors());\n};");
+    await patchConsoleColors(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+    await writeFile(file, "export const x = 1;\n");
+    await expect(patchConsoleColors(root)).rejects.toThrow("anchor not found");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("TextDecoder and Headers patches replace Porffor's classes once", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-web-classes-"));
+  try {
+    await mkdir(join(root, "runtime"));
+    const file = join(root, "runtime/fetch-globals.js");
+    await writeFile(file, "class Headers {\n  old() {}\n}\nfunction setTimeout() {}\nclass TextDecoder {\n  old() {}\n}\nclass URL {\n}\n");
+    await patchHeadersClass(root);
+    await patchTextDecoder(root);
+    const patched = await readFile(file, "utf8");
+    expect(patched).toContain("sproutboat: Fetch-spec Headers");
+    expect(patched).toContain("sproutboat: WHATWG UTF-8 decoder");
+    expect(patched).not.toContain("old() {}");
+    expect(patched).toContain("\nfunction setTimeout() {}\nclass TextDecoder {");
+    await patchHeadersClass(root);
+    await patchTextDecoder(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+    await writeFile(file, "export const x = 1;\n");
+    await expect(patchHeadersClass(root)).rejects.toThrow("anchor not found");
+    await expect(patchTextDecoder(root)).rejects.toThrow("anchor not found");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("case mapping patch adds the lookup and routes non-ASCII units through it, idempotently", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-case-map-"));
+  try {
+    await mkdir(join(root, "compiler/builtins"), { recursive: true });
+    const file = join(root, "compiler/builtins/string.ts");
+    await writeFile(
+      file,
+      "export const __String_prototype_toUpperCase = function (this: string) {\n" +
+        "    if (chr >= 97) if (chr <= 122) chr -= 32;\n\n    Porffor.IR.storeU16(j, 4, chr);\n" +
+        "    if (chr >= 97) if (chr <= 122) chr -= 32;\n\n    Porffor.IR.storeU8(j++, 4, chr);\n" +
+        "    if (chr >= 65) if (chr <= 90) chr += 32;\n\n    Porffor.IR.storeU16(j, 4, chr);\n" +
+        "    if (chr >= 65) if (chr <= 90) chr += 32;\n\n    Porffor.IR.storeU8(j++, 4, chr);\n",
+    );
+    await patchCaseMapping(root);
+    const patched = await readFile(file, "utf8");
+    expect(patched).toContain("export const __Porffor_caseFind = (chr: i32, runs: string): i32 => {");
+    expect(patched).toContain("else chr = __Porffor_caseUpper(chr);");
+    expect(patched).toContain("else chr = __Porffor_caseLower(chr);");
+    expect(patched).toContain("if (chr != 247) chr -= 32;");
+    await patchCaseMapping(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+    await writeFile(file, "export const x = 1;\n");
+    await expect(patchCaseMapping(root)).rejects.toThrow("anchor not found");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("zero-delay timer patch arms timers at 1 ms, idempotently", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-zero-timers-"));
+  try {
+    await mkdir(join(root, "compiler"));
+    const file = join(root, "compiler/render.js");
+    await writeFile(file, "x\n  porf_native_fetch_timer_start(id, (i32)delay_ms, timer->repeat ? (i32)delay_ms : 0);\n");
+    await patchZeroDelayTimers(root);
+    const patched = await readFile(file, "utf8");
+    expect(patched).toContain("delay_ms < 1 ? 1 : (i32)delay_ms");
+    await patchZeroDelayTimers(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+    await writeFile(file, "export const x = 1;\n");
+    await expect(patchZeroDelayTimers(root)).rejects.toThrow("anchor not found");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("Request/Response, Blob and finalizer patches replace their targets once", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-fetch-classes-"));
+  try {
+    await mkdir(join(root, "runtime"));
+    const globals = join(root, "runtime/fetch-globals.js"), entry = join(root, "runtime/native-fetch.js");
+    await writeFile(globals, "class Blob {\n  old() {}\n}\nclass TextEncoder {\n}\nclass Request {\n  old() {}\n}\nclass Response {\n  old() {}\n}\n");
+    await writeFile(entry, "x\n  const body = response.body == null ? '' : String(response.body);\n  const headersEntries = response.headers._entries;\n");
+    await patchFetchClasses(root);
+    await patchBlobClass(root);
+    await patchResponseBytes(root);
+    const g = await readFile(globals, "utf8"), e = await readFile(entry, "utf8");
+    expect(g).toContain("sproutboat: Fetch-spec Request and Response");
+    expect(g).toContain("sproutboat: byte-backed Blob and File");
+    expect(g).toContain("class File extends Blob {");
+    expect(g).not.toContain("old() {}");
+    expect(e).toContain("headersEntries.push('x-sb-raw-body', '1');");
+    await patchFetchClasses(root);
+    await patchBlobClass(root);
+    await patchResponseBytes(root);
+    expect(await readFile(globals, "utf8")).toBe(g);
+    expect(await readFile(entry, "utf8")).toBe(e);
+    await writeFile(globals, "export const x = 1;\n");
+    await writeFile(entry, "export const x = 1;\n");
+    await expect(patchFetchClasses(root)).rejects.toThrow("anchor not found");
+    await expect(patchBlobClass(root)).rejects.toThrow("anchor not found");
+    await expect(patchResponseBytes(root)).rejects.toThrow("anchor not found");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("streaming patch adds the stream registry and attaches marked responses, idempotently", async () => {
+  const streaming = await import("./streaming");
+  const root = await mkdtemp(join(tmpdir(), "sb-streaming-"));
+  try {
+    await mkdir(join(root, "compiler"));
+    const file = join(root, "compiler/uwebsockets.js");
+    const render = join(root, "compiler/render.js");
+    await writeFile(render, "f64 x;\n" + streaming.STREAM_STUBS_ANCHOR + " for a bytestring\n");
+    await writeFile(
+      file,
+      streaming.STREAM_FORBIDDEN_ANCHOR +
+        streaming.STREAM_REGISTRY_ANCHOR +
+        streaming.STREAM_FLAG_ANCHOR +
+        streaming.STREAM_SCAN_ANCHOR +
+        streaming.STREAM_CORK_ANCHOR +
+        streaming.STREAM_END_ANCHOR,
+    );
+    await patchStreamingResponses(root);
+    const patched = await readFile(file, "utf8");
+    expect(patched).toContain('extern "C" u32 sb_stream_open(void) {');
+    expect(patched).toContain("if (stream_id) sb_stream_attach(stream_id, res);");
+    expect(patched).toContain('key == "x-sb-stream"; // sproutboat B19');
+    expect(patched.indexOf("sproutboat B19: streamed responses")).toBeLessThan(patched.indexOf("static void write_response_value"));
+    const stubs = await readFile(render, "utf8");
+    expect(stubs).toContain("__attribute__((weak)) int sb_stream_supported(void) { return 0; }");
+    expect(stubs.indexOf("streaming fallbacks")).toBeLessThan(stubs.indexOf(streaming.STREAM_STUBS_ANCHOR));
+    await patchStreamingResponses(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+    expect(await readFile(render, "utf8")).toBe(stubs);
+    await writeFile(file, "export const x = 1;\n");
+    await expect(patchStreamingResponses(root)).rejects.toThrow("anchor not found");
+    await writeFile(render, "export const x = 1;\n");
+    await expect(patchStreamingResponses(root)).rejects.toThrow("streaming fallbacks: anchor not found");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("split globals patch prefixes module globals so none binds to libc, idempotently", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-split-globals-"));
+  try {
+    await mkdir(join(root, "compiler"));
+    const file = join(root, "compiler/render.js");
+    await writeFile(
+      file,
+      [
+        "  const st = split ? '' : 'static ';",
+        "      case K.Global:\n        cur.globals[node[N_A]] = true;\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`);",
+        "            ? `${sanitize(update[N_A][N_A])} = ${rx(update[N_B], P_COMMA)}`",
+        "    const t = sanitize(target[N_A]);",
+        "  for (const g of globals) link.push(`${st}${CT[g.type]} ${sanitize(g.name)};`);",
+        "      const name = sanitize(g.name);",
+        "          const buckets = sanitize(g.name.replace(/underlyingStore$/, 'underlyingBuckets'));",
+        "          const bucketsCap = sanitize(g.name.replace(/underlyingStore$/, 'underlyingBucketsCap'));",
+        "      for (const x of Object.keys(parts.globals).sort()) text.push(`extern ${CT[globalTypes[x]]} ${sanitize(x)};\\n`);",
+        "",
+      ].join("\n"),
+    );
+    await patchSplitGlobals(root);
+    const patched = await readFile(file, "utf8");
+    expect(patched).toContain("const gname = n => sanitize(split && !n.startsWith('__') ? 'pg_' + n : n);");
+    expect(patched).toContain("return [gname(node[N_A]), P_PRIM];\n      case K.Local:\n        return [sanitize(node[N_A]), P_PRIM];");
+    expect(patched).toContain("${st}${CT[g.type]} ${gname(g.name)}");
+    expect(patched).toContain("text.push(`extern ${CT[globalTypes[x]]} ${gname(x)};\\n`);");
+    expect(patched.match(/gname\(/g)?.length).toBe(9);
+    await patchSplitGlobals(root);
+    expect(await readFile(file, "utf8")).toBe(patched);
+    await writeFile(file, "export const x = 1;\n");
+    await expect(patchSplitGlobals(root)).rejects.toThrow("anchor not found");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});