@sproutboat/toolchain 0.11.0 → 0.12.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @sproutboat/toolchain
 
+## 0.12.1
+
+### Patch Changes
+
+- 1ff15e6: Keep heap-backed BigInts alive during conservative garbage collection. The native scanner now recognizes the encoded floating-point pointer used by BigInt arithmetic, preventing crashes and incorrect checksums in workloads such as CRC64 and LTX encoding.
+
+## 0.12.0
+
+### Minor Changes
+
+- feba29b: Upgrade the verified vendored Porffor pin to Alpha 19 (`0c135ce`). Alpha 19 brings `Map.groupBy`, private names that stay out of `Object.keys`, `for-in` and `JSON.stringify`, `JSON.stringify` throwing on cycles, a spec `JSON.parse` reviver (with source text), spec ISO date parsing, spec base64 and hex on `Uint8Array`, typed-array `toString` tags, the `Error.prototype.stack` accessor, spec `instanceof`, `+` and template literals converting objects with ToPrimitive, sloppy functions boxing a primitive `this`, unresolvable names read from the global object, `with`, and many String, Date, Function and Object spec fixes. These move compiled handlers closer to V8 (Workers), so they are not gated on a compatibility date, as with earlier Porffor upgrades.
+  
+  Seven downstream workarounds are dropped because upstream now does the same thing, each proven by its native test without the patch: the ISO date offset parser, the base64 option tags, `Map.groupBy` and non-enumerable private fields (sproutboat#286), the `JSON.stringify` cycle check, the `JSON.parse` reviver, and the typed-array `toString` tag. The Unicode JSON patch is re-anchored on the new `JSON.parse`: upstream now rejects trailing input itself, and the reviver's source-text records keep UTF-16 text. The #256 class self-name rewrite is kept (Alpha 19 still has the bug) and now places its synthesized read after the class, so Alpha 19's new TDZ check does not reject it. #287 (GC page discard), B16 (`repeat`), #237 (`replaceAll`), #168 (promise resolving to `null`) and the local function types patch are still needed.
+  
+  One patch is new: Alpha 19 added a `new Function` source specialization that walked the whole program twice per top-level function, so compiling the runtime prelude took 3.7 s instead of 0.6 s before any C was generated. The patch checks the function body first; the generated code is byte-identical.
+
 ## 0.11.0
 
 ### Minor Changes

package/PORFFOR_ALPHA19.md

@@ -0,0 +1,72 @@
+# Porffor Alpha 19 evaluation
+
+Verified on 2026-10-21. Released 2026-10-21:
+https://github.com/CanadaHonk/porffor/releases/tag/alpha-19
+
+Pinned commit: `0c135ce2f36fdd3467d5a58daa92283810705a51`.
+Vendored archive SHA256:
+`b54da2297ad9e03c5bbac0e0d156f1179ac3a09a2a6fd702475cef605bab97b9`.
+`compiler/uwebsockets.js` is unchanged, so uWebSockets stays on `360c276d` and the
+vendored uWebSockets archive is unchanged.
+
+## Changes since Alpha 18
+
+91 commits. The ones that matter to handlers:
+
+- `Map.groupBy`; private names are brands, so `#x` stays out of `Object.keys`,
+  `for-in`, `Object.entries` and `JSON.stringify` (baronunread/sproutboat#286).
+- JSON: `stringify` throws on cycles and unwraps boxed primitives; `parse` applies a
+  reviver with source text (`context.source`) and rejects trailing input;
+  `JSON.rawJSON`.
+- Spec ISO date string parsing, `Date.prototype[Symbol.toPrimitive]`, Date setters.
+- Spec base64 and hex on `Uint8Array`; `%TypedArray%.prototype[Symbol.toStringTag]`.
+- `Error.prototype.stack` accessor (`Name: message`, settable). The runtime prelude's
+  own getter only installs when `stack` is missing, so it now stands down.
+- Language: spec `instanceof` and `Symbol.hasInstance`, `+` and template literals use
+  ToPrimitive / ToString, sloppy functions box a primitive `this`, unresolvable names
+  are global object properties, lexical bindings are in the TDZ before their
+  declaration, `with`, `new Function` from literal sources, eval completion values.
+- Many String, Function, Object, Number and Promise spec fixes; string index reads
+  are bounds checked.
+
+## Downstream patches
+
+Each workaround was removed from the chain and its native test run without it.
+
+Dropped, now upstream:
+
+- ISO date timezone offsets (`patchDateParser`): its anchor is gone; `date-native`
+  passes on upstream's parser.
+- Base64 option tags and complete chunks (`patchUint8ArrayBase64`): rewritten upstream;
+  `test:native-base64` passes.
+- `Map.groupBy` and non-enumerable private fields (#286): `groupby-private-native`
+  passes.
+- `JSON.stringify` cycle check and the typed-array `toString` tag: `json-cycles-native`
+  passes. The tag patch still applied, but upstream's own tag gives the same result.
+- `JSON.parse` reviver: `test:native-json` passes on upstream's reviver.
+
+Re-anchored:
+
+- Unicode JSON (`unicode.ts`): upstream's `JSON.parse` takes `(_: any, reviver)` and
+  rejects trailing input itself, so those two edits go. The bytestring slice is widened
+  everywhere `text` is sliced, which now includes the reviver's source-text records;
+  without it `context.source` is garbled for non-ASCII input (`unicode-native` covers it).
+- #256 class self name: Alpha 19 still has the bug (unpatched, the test case throws a
+  TypeError), but its new TDZ check rejected the rewrite's synthesized `return l`,
+  which carried the class's start offset. The returned name is now positioned after
+  the class, as it would be in source.
+
+New:
+
+- `patchFunctionSourcesScan`: Alpha 19's `specializeFunctionSources` (b2b9bf6) walks the
+  whole program twice for every top-level function declaration before checking whether
+  its body calls `Function`. On the runtime prelude IR generation took 3.7 s instead of
+  0.6 s (sproutd admission went from 1.1 to 4.2 s per app). The patch checks the body
+  first; the generated C is byte-identical (compared on a sproutd admission compile).
+
+Retained, still needed on Alpha 19:
+
+- Local function types: `alpha18-native` throws a TypeError without it.
+- #287 GC page discard, B16 `repeat`, #237 `replaceAll`: upstream's code is unchanged.
+- #168 promise resolving to `null`: the `then` probe still lacks the null guard.
+- The native-fetch server patches are Sproutboat features, not Porffor bugs.

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@sproutboat/toolchain",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "license": "MIT",
-  "type": "module",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/baronunread/sproutboat-packages.git",
     "directory": "packages/toolchain"
   },
+  "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "exports": {

package/src/acquire.test.ts

@@ -18,6 +18,11 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
   const files = {
     "runtime/index.js": "fixture:runtime/index.js\n",
     "compiler/render.js": "// sb_native_utf8_scalar_v1\n" +
+      "static void porf_gc_cons_candidate(u32 c);\n" +
+      // Both conservative scanners consume raw f64 values.
+      ("    if (d > 0.0 && d < 4294967296.0) {\n" +
+        "      const i64 iv = (i64)d;\n" +
+        "      if ((f64)iv == d) porf_gc_cons_candidate((u32)(u64)iv);\n    }\n").repeat(2) +
       "static i32 porf_gc_mark_queue_cap = 0;\n    porf_gc_discard_free_runs();\n" +
       "  porf_native_fetch_timer_start(id, (i32)delay_ms, timer->repeat ? (i32)delay_ms : 0);\n" +
       "void porf_native_fetch_collect_normal_from(void* stack_top) {\n" +
@@ -63,7 +68,7 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
       "const path = require('node:path');\n" +
       "fs.writeFileSync(path.join(__dirname, 'builtins_precompiled.js'), fs.readFileSync(path.join(__dirname, 'builtins/typedarray.js')));\n",
     "compiler/builtins_precompiled.js": "fixture:precompiled\n",
-    "compiler/builtins/date.ts": "export const __ecma262_ParseDTSF = (string: string) => {\n  let n: number = 0;\n  let nInd: number = 0;\n\n  const len: i32 = string.length;\n  const endPtr: i32 = Porffor.IR.ptr(string) + len;\n  let ptr: i32 = Porffor.IR.ptr(string);\n\n  while (ptr <= endPtr) { // <= to include extra null byte to set last n\n    const chr: i32 = Porffor.IR.loadU8(ptr++, 4);\n    if (Porffor.fastAnd(chr >= 48, chr <= 57)) { // 0-9\n      n *= 10;\n      n += chr - 48;\n      continue;\n    }\n\n    if (chr == 45) { // -\n      if (Porffor.fastOr(ptr == Porffor.IR.ptr(string), nInd == 7)) n = -n;\n    }\n\n    if (n > 0) {\n      if (nInd == 0) y = n;\n        else if (nInd == 1) m = n - 1;\n        else if (nInd == 2) dt = n;\n        else if (nInd == 3) h = n;\n        else if (nInd == 4) min = n;\n        else if (nInd == 5) s = n;\n        else if (nInd == 6) milli = n;\n        else if (nInd == 7) tzHour = n;\n        else if (nInd == 8) tzMin = n;\n\n      n = 0;\n      nInd++;\n    }\n  }\n\n  h += tzHour;\n  min += tzMin;\n};\n// RFC 7231 or Date.prototype.toString() parser\n",
+    "compiler/builtins/date.ts": "export const __ecma262_ParseDTSF = (string: string) => {\n};\n",
     "compiler/builtins/typedarray.js":
       "${typedArrayFuncs.reduce((acc, x) => acc + x.replace('// @porf-typed-array\\n', '').replaceAll('Array', name).replaceAll('any[]', name) + '\\n\\n', '')}`;\n" +
       "  offset = Math.trunc(offset);\n  if (Porffor.fastOr(offset < 0, offset > len)) throw new RangeError('Offset out of bounds');\n" +
@@ -150,10 +155,7 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
       "}\n" +
       "int main(void) {\n  porf_native_fetch_runtime_init();\n  porf_native_fetch_static_init();\n\n  return 0;\n}\n",
     "compiler/builtins/json.ts":
-      "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" +
       "// sb_json_utf16_v1\n" +
-      // patchJsonReviver's anchor.
-      "export const __JSON_parse = (_: bytestring) => {\n};\n" +
       "export const __Porffor_json_serialize = (_buffer: i32, value: any): i32 => {\n" +
       "    for (const x of (value as any[])) {\n    }\n" +
       "      const val: any = value[key];\n" +
@@ -168,14 +170,10 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
       "}\nfunction setTimeout() {}\nclass TextDecoder {\n}\n" +
       "class URL {\n  constructor(input) {\n    this.href = '';\n  }\n}\n\nclass Request {\n}\n" +
       "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",
-    "compiler/builtins/uint8array_base64.ts": "let alphabet: string = 'base64';\nlet lastChunkHandling: string = 'loose';\nconst fullChunks: i32 = (len / 3) * 3;\n",
-    "compiler/builtins/object.ts": "  return '[object ' + builtinTag + ']';\n};\n",
     "compiler/builtins/console.ts": "export const __Porffor_consolePrint = (arg: any): void => {\n  __Porffor_print(arg);\n};\n",
-    "compiler/builtins/map.ts": "export const Map = function (iterable: any): Map {\n};\n",
     "compiler/codegen.js":
       "if (!hoistRead && directCallOnlyFunctionBinding(scope, kind, name, pattern, func)) {\n        return valUndefined();\n}\nconst func = resolveNamedFunction(scope, name) ?? funcByName(name);\n" +
-      "        builtinCall(func, '__Porffor_object_class_value', [\n" +
-      "      if (kind === 'get' || kind === 'set') initKind = kind;\n" +
+      "    // only names that are nothing but this declaration and its direct calls\n    if (find(program, n => n.name === x.id.name).length !== 1) continue;\n" +
       "      stmt(scope, Store(ctype, addr, 4, ctype === 'f64' || ctype === 'f32' ? f : toUint32(scope, f)));\n" +
       "  const taGet = (ctype, size, signed = true) => () => {\n" +
       "    const loaded = Load(ctype, taAddr(size), 4);\n" +
@@ -298,16 +296,15 @@ test("the default call (no url/expectedSha256 override) never touches the networ
   expect(await readFile(join(dir, "compiler/uwebsockets.js"), "utf8")).toContain("sproutboat B19: streamed responses");
   // console colours only on a terminal.
   expect(await readFile(join(dir, "compiler/builtins/console.ts"), "utf8")).toContain("__Porffor_consoleColors");
-  // JSON.stringify throws on cycles; typed arrays have their own toString tag.
-  expect(await readFile(join(dir, "compiler/builtins/json.ts"), "utf8")).toContain("sproutboat: JSON cycle check");
-  expect(await readFile(join(dir, "compiler/builtins/object.ts"), "utf8")).toContain("sproutboat: typed array toStringTag");
+  // JSON cycles, the JSON.parse reviver, typed-array toString tags, ISO date offsets,
+  // base64 options, Map.groupBy and non-enumerable private fields (#286) are upstream's
+  // own since alpha-19; json-cycles, groupby-private, date and base64 native tests cover them.
+  // Alpha 19 new Function specialization checks a function body before walking the program.
+  expect(await readFile(join(dir, "compiler/codegen.js"), "utf8")).toContain("sproutboat: body check before the whole-program walks");
   // B16: String.prototype.repeat doubles its copies.
   expect(await readFile(join(dir, "compiler/builtins/string.ts"), "utf8")).toContain("sproutboat B16: doubling repeat");
   // #287: full collections under load keep their free pages; the idle collection returns them.
   expect(await readFile(join(dir, "compiler/render.js"), "utf8")).toContain("if (porf_gc_discard_now) porf_gc_discard_free_runs(); else porf_gc_discard_pending = 1;");
-  // #286: Map.groupBy, and private fields installed as non-enumerable.
-  expect(await readFile(join(dir, "compiler/builtins/map.ts"), "utf8")).toContain("export const __Map_groupBy");
-  expect(await readFile(join(dir, "compiler/codegen.js"), "utf8")).toContain("sproutboat #286: private fields");
   // #256: named class expressions inside functions are rewritten at parse time.
   expect(await readFile(join(dir, "compiler/parse.js"), "utf8")).toContain("sbClassSelf(ast); // sproutboat #256");
   expect(await readFile(join(dir, "compiler/sb-class-self.js"), "utf8")).toContain("sproutboat #256");
@@ -421,3 +418,12 @@ test("download failures are classified without publishing partial state", async
   expect(attempts).toBe(2);
   expect(await readdir(cacheRoot)).toEqual([]);
 });
+
+test("the vendored archive is the one PORFFOR_ARCHIVE_URL serves: its root is porffor-<full commit>", () => {
+  // codeload names the root after the ref in the URL, so an archive fetched by the short
+  // commit has another root and digest than the pinned URL's, though the same files.
+  const archive = join(import.meta.dir, `../vendor/porffor-${PORFFOR_COMMIT_FULL.slice(0, 7)}.tar.gz`);
+  const list = Bun.spawnSync(["tar", "-tzf", archive], { stdout: "pipe" });
+  expect(list.exitCode).toBe(0);
+  expect(list.stdout.toString().split("\n")[0]).toBe(`porffor-${PORFFOR_COMMIT_FULL}/`);
+});

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-deda494.tar.gz" with { type: "file" };
+import vendoredPorfforArchive from "../vendor/porffor-0c135ce.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/bigint-gc-native.test.ts

@@ -0,0 +1,30 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { ensurePorffor } from "./acquire";
+
+test("conservative roots retain encoded heap BigInts on the stack and in untyped blocks", async () => {
+  const workdir = await mkdtemp(resolve(tmpdir(), "sb-bigint-gc-"));
+  try {
+    const porffor = await ensurePorffor();
+    const source = resolve(import.meta.dir, "../test/gc-bigint.js.txt");
+    const binary = resolve(workdir, "bigint-gc");
+    const compile = Bun.spawn(
+      ["bun", resolve(porffor, "runtime/index.js"), "native", source, "-o", binary, "-O0", "-s"],
+      { stdout: "pipe", stderr: "pipe" },
+    );
+    const [code, stdout, stderr] = await Promise.all([
+      compile.exited,
+      new Response(compile.stdout).text(),
+      new Response(compile.stderr).text(),
+    ]);
+    expect(code, stderr + stdout).toBe(0);
+    const run = Bun.spawnSync([binary], { stdout: "pipe", stderr: "pipe", timeout: 10_000 });
+    expect(run.exitCode, Buffer.from(run.stderr).toString()).toBe(0);
+    const ansi = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+    expect(Buffer.from(run.stdout).toString().replace(ansi, "").trim()).toBe("3");
+  } finally {
+    await rm(workdir, { recursive: true, force: true });
+  }
+}, 120_000);

package/src/fingerprint.ts

@@ -21,7 +21,7 @@ export const PATCH_SOURCES = [
  * patch.ts as the module patch.ts is everywhere else. Kept current by fingerprint.test.ts
  * (UPDATE_FINGERPRINT=1 bun test packages/toolchain/src/fingerprint.test.ts).
  */
-export const RELEASED_FINGERPRINT = "66de5cdac773";
+export const RELEASED_FINGERPRINT = "ee724d4de68f";
 
 /** The fingerprint of the sources in dir, or null where they are not on disk. */
 export function sourceFingerprint(dir: string): string | null {

package/src/idle-gc.test.ts

@@ -10,7 +10,7 @@ test("idle reclamation preserves unconditional request GC and is idempotent on t
   try {
     execFileSync("tar", [
       "-xzf",
-      resolve(import.meta.dir, "../vendor/porffor-deda494.tar.gz"),
+      resolve(import.meta.dir, "../vendor/porffor-0c135ce.tar.gz"),
       "--strip-components=1",
       "-C",
       root,

package/src/patch.test.ts

@@ -6,12 +6,9 @@ import { EMPTY_BINDINGS, wrapNativeFetchHandler } from "../../runtime/src/wrap";
 import {
   patchHeadersArrayInit,
   patchLocalFunctionTypes,
+  patchFunctionSourcesScan,
   patchDeferredDiscard,
-  patchMapGroupBy,
-  patchPrivateFieldsHidden,
   patchRepeatDoubling,
-  patchJsonCycles,
-  patchTypedArrayTag,
   patchConsoleColors,
   patchCaseMapping,
   patchZeroDelayTimers,
@@ -25,7 +22,6 @@ import {
   patchTextDecoder,
   patchResponseDefaults,
   patchURLClass,
-  patchUint8ArrayBase64,
   patchRenderJs,
   patchUwebsockets,
 } from "./patch";
@@ -365,22 +361,21 @@ 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-"));
+test("function source patch checks the body before walking the program, idempotently", async () => {
+  const root = await mkdtemp(join(tmpdir(), "sb-function-sources-"));
   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 patchUint8ArrayBase64(root);
+    await mkdir(join(root, "compiler"));
+    const file = join(root, "compiler/codegen.js");
+    const anchor =
+      "    // only names that are nothing but this declaration and its direct calls\n    if (find(program, n => n.name === x.id.name).length !== 1) continue;\n";
+    await writeFile(file, anchor);
+    await patchFunctionSourcesScan(root);
     const patched = await readFile(file, "utf8");
-    expect(patched).toContain("let alphabet: any =");
-    expect(patched).toContain("let lastChunkHandling: any =");
-    expect(patched).toContain("((len / 3) | 0) * 3");
-    await patchUint8ArrayBase64(root);
+    expect(patched.indexOf("n.callee.name === 'Function').length === 0) continue;")).toBeLessThan(patched.indexOf("find(program,"));
+    await patchFunctionSourcesScan(root);
     expect(await readFile(file, "utf8")).toBe(patched);
+    await writeFile(file, "const unrelated = 1;\n");
+    await expect(patchFunctionSourcesScan(root)).rejects.toThrow("anchor not found");
   } finally {
     await rm(root, { recursive: true, force: true });
   }
@@ -457,47 +452,6 @@ test("URL patch replaces Porffor's URL class, idempotently", async () => {
 });
 
 
-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 {
@@ -572,48 +526,6 @@ test("ensurePorfforPatched trusts a cache entry this toolchain version and patch
   }
 });
 
-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 {

package/src/patch.ts

@@ -233,6 +233,9 @@ const rewrite = (cls) => {
   const name = cls.id.name;
   const at = { start: cls.start, end: cls.end };
   const id = () => ({ type: 'Identifier', name, ...at });
+  // Porffor's TDZ check (Alpha 19) flags a same-function read that starts before its
+  // declarator ends, so the returned name sits at the end of the class, as in source.
+  const after = { start: cls.end, end: cls.end };
   return {
     type: 'CallExpression', optional: false, arguments: [], ...at,
     callee: {
@@ -243,7 +246,7 @@ const rewrite = (cls) => {
           { type: 'VariableDeclaration', kind: 'const', ...at, declarations: [
             { type: 'VariableDeclarator', id: id(), init: { ...cls, id: null }, ...at },
           ] },
-          { type: 'ReturnStatement', argument: id(), ...at },
+          { type: 'ReturnStatement', argument: { ...id(), ...after }, ...after },
         ],
       },
     },
@@ -389,97 +392,6 @@ const REPLACE_ALL_EDITS = [
 ] as const;
 const REPLACE_ALL_MARKER = "sproutboat #237: pieces joined once";
 
-// 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.
-const DATE_PARSER_MARKER = "sproutboat: ISO timezone offset";
-const DATE_PARSER_ANCHOR = `  let n: number = 0;
-  let nInd: number = 0;
-
-  const len: i32 = string.length;
-  const endPtr: i32 = Porffor.IR.ptr(string) + len;
-  let ptr: i32 = Porffor.IR.ptr(string);
-
-  while (ptr <= endPtr) { // <= to include extra null byte to set last n
-    const chr: i32 = Porffor.IR.loadU8(ptr++, 4);
-    if (Porffor.fastAnd(chr >= 48, chr <= 57)) { // 0-9
-      n *= 10;
-      n += chr - 48;
-      continue;
-    }
-
-    if (chr == 45) { // -
-      if (Porffor.fastOr(ptr == Porffor.IR.ptr(string), nInd == 7)) n = -n;
-    }
-
-    if (n > 0) {
-      if (nInd == 0) y = n;
-        else if (nInd == 1) m = n - 1;
-        else if (nInd == 2) dt = n;
-        else if (nInd == 3) h = n;
-        else if (nInd == 4) min = n;
-        else if (nInd == 5) s = n;
-        else if (nInd == 6) milli = n;
-        else if (nInd == 7) tzHour = n;
-        else if (nInd == 8) tzMin = n;
-
-      n = 0;
-      nInd++;
-    }
-  }
-
-  h += tzHour;
-  min += tzMin;`;
-const DATE_PARSER_INJECT = `  // sproutboat: ISO timezone offset
-  let n: number = 0;
-  let nInd: number = 0;
-  let digits: i32 = 0;
-  let offsetSign: i32 = 0;
-
-  const len: i32 = string.length;
-  const endPtr: i32 = Porffor.IR.ptr(string) + len;
-  let ptr: i32 = Porffor.IR.ptr(string);
-
-  // Loop once past the last character to flush the final number, but read a
-  // 0 there, not the byte after the string: if that byte happened to be '+' or
-  // '-' it flipped the offset's sign.
-  while (ptr <= endPtr) {
-    const chr: i32 = ptr < endPtr ? Porffor.IR.loadU8(ptr, 4) : 0;
-    ptr++;
-    if (Porffor.fastAnd(chr >= 48, chr <= 57)) {
-      n = n * 10 + chr - 48;
-      digits++;
-      continue;
-    }
-
-    if (digits > 0) {
-      if (nInd == 0) y = n;
-        else if (nInd == 1) m = n - 1;
-        else if (nInd == 2) dt = n;
-        else if (nInd == 3) h = n;
-        else if (nInd == 4) min = n;
-        else if (nInd == 5) s = n;
-        else if (nInd == 6) {
-          while (digits < 3) { n *= 10; digits++; }
-          while (digits > 3) { n = Math.trunc(n / 10); digits--; }
-          milli = n;
-        }
-        else if (nInd == 7) tzHour = n;
-        else if (nInd == 8) tzMin = n;
-      n = 0;
-      nInd++;
-      digits = 0;
-    }
-
-    if (Porffor.fastOr(chr == 43, chr == 45) && nInd >= 6) {
-      offsetSign = chr == 43 ? 1 : -1;
-      nInd = 7;
-    }
-  }
-
-  h -= offsetSign * tzHour;
-  min -= offsetSign * tzMin;`;
-
 /**
  * #56 — make the inbound request-body limit configurable.
  *
@@ -1407,30 +1319,6 @@ async function patchCompilerArgs(root: string): Promise<void> {
   if (changed) await writeFile(file, src);
 }
 
-export async function patchDateParser(root: string): Promise<void> {
-  const file = resolve(root, "compiler/builtins/date.ts");
-  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 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),
-  );
-}
-
 /** #168: keep a promise resolving to null out of the `then` probe. */
 export async function patchPromiseResolveNull(root: string): Promise<void> {
   const file = resolve(root, "compiler/builtins/promise.ts");
@@ -1501,28 +1389,32 @@ export async function patchLocalFunctionTypes(root: string): Promise<void> {
   await writeFile(file, src);
 }
 
-/** Keep base64 option tags accurate and truncate the complete-chunk count. */
-export async function patchUint8ArrayBase64(root: string): Promise<void> {
-  const file = resolve(root, "compiler/builtins/uint8array_base64.ts");
-  let src = await readFile(file, "utf8");
-  const marker = "sproutboat: base64 option tags and complete chunks";
-  if (src.includes(marker)) return;
-  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;",
-    ],
-  ] 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}`,
-      );
-    src = src.replaceAll(anchor, replacement);
-  }
-  await writeFile(file, `// ${marker}\n${src}`);
+/**
+ * Alpha 19's specializeFunctionSources (codegen.js) walks the whole program twice for
+ * every top-level function declaration before it checks whether that function's body
+ * calls `Function` at all, so a program with many top-level functions compiled
+ * quadratically: IR generation for the runtime prelude went from 0.6 s on Alpha 18 to
+ * 3.7 s (sproutd admission: 1.1 s to 4.2 s per app). Check the body first; every check
+ * is a pure walk, so the generated code is unchanged.
+ */
+const FUNCTION_SOURCES_MARKER = "sproutboat: body check before the whole-program walks";
+const FUNCTION_SOURCES_ANCHOR =
+  "    // only names that are nothing but this declaration and its direct calls\n    if (find(program, n => n.name === x.id.name)";
+export async function patchFunctionSourcesScan(root: string): Promise<void> {
+  const file = resolve(root, "compiler/codegen.js");
+  const src = await readFile(file, "utf8");
+  if (src.includes(FUNCTION_SOURCES_MARKER)) return;
+  if (src.split(FUNCTION_SOURCES_ANCHOR).length !== 2)
+    throw new Error(`could not patch Porffor's new Function source specialization: anchor not found in ${file}`);
+  await writeFile(
+    file,
+    src.replace(
+      FUNCTION_SOURCES_ANCHOR,
+      `    // ${FUNCTION_SOURCES_MARKER}\n` +
+        "    if (find(x.body, n => (n.type === 'CallExpression' || n.type === 'NewExpression') && n.callee.name === 'Function').length === 0) continue;\n" +
+        FUNCTION_SOURCES_ANCHOR,
+    ),
+  );
 }
 
 export async function precompileBuiltins(root: string): Promise<void> {
@@ -1752,66 +1644,6 @@ export async function patchHeadersArrayInit(root: string): Promise<void> {
   );
 }
 
-// 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
@@ -1920,128 +1752,6 @@ export async function patchRepeatDoubling(root: string): Promise<void> {
   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);
-}
-
-// JSON.parse ignored its reviver (W2 conformance: json/reviver). The parser keeps its body
-// under a new name, and __JSON_parse walks the result as the spec's InternalizeJSONProperty
-// does: children first, a reviver answer of undefined deletes the property.
-const JSON_REVIVER_MARKER = "sproutboat: JSON.parse reviver";
-// Porffor declares (_: bytestring); patchUnicode widens it to any later, on the renamed parser.
-const JSON_PARSE_ANCHOR = /export const __JSON_parse = \(_: (bytestring|any)\) => \{\n/;
-const JSON_REVIVER_SOURCE = `
-// ${JSON_REVIVER_MARKER}
-export const __Porffor_json_revive = (holder: any, key: any, reviver: any): any => {
-  const value: any = holder[key];
-  if (Porffor.type(value) == Porffor.TYPES.array) {
-    const len: i32 = value.length;
-    for (let i: i32 = 0; i < len; i++) {
-      const next: any = __Porffor_json_revive(value, ecma262.ToString(i), reviver);
-      if (next === undefined) delete value[i];
-      else value[i] = next;
-    }
-  } else if (Porffor.type(value) == Porffor.TYPES.object) {
-    for (const k: any in value) {
-      const next: any = __Porffor_json_revive(value, k, reviver);
-      if (next === undefined) delete value[k];
-      else value[k] = next;
-    }
-  }
-  return reviver.call(holder, key, value);
-};
-
-export const __JSON_parse = (text: any, reviver: any) => {
-  const value: any = __Porffor_json_parseText(text);
-  if (Porffor.type(reviver) != Porffor.TYPES.function) return value;
-  const root: object = {};
-  root[''] = value;
-  return __Porffor_json_revive(root, '', reviver);
-};
-`;
-
-/** JSON.parse applies its reviver, as InternalizeJSONProperty does. */
-export async function patchJsonReviver(root: string): Promise<void> {
-  const file = resolve(root, "compiler/builtins/json.ts");
-  const src = await readFile(file, "utf8");
-  if (src.includes(JSON_REVIVER_MARKER)) return;
-  if ((src.match(new RegExp(JSON_PARSE_ANCHOR, "g")) ?? []).length !== 1)
-    throw new Error(`could not patch Porffor's JSON.parse reviver: anchor not found in ${file}`);
-  await writeFile(
-    file,
-    src.replace(JSON_PARSE_ANCHOR, (_line, type) => `export const __Porffor_json_parseText = (_: ${type}) => {\n`).trimEnd() + "\n" + JSON_REVIVER_SOURCE,
-  );
-}
-
-// 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.
@@ -2215,6 +1925,36 @@ export async function patchSplitGlobals(root: string): Promise<void> {
   await writeFile(file, src);
 }
 
+// The conservative scanner must recognize the encoded f64 form used by BigInt builtins.
+const BIGINT_GC_ANCHOR = "static void porf_gc_cons_candidate(u32 c);\n";
+const BIGINT_GC_HELPER = `static void porf_gc_cons_f64(f64 d) {
+  // Heap BigInts encode their offset above 2^51, including in f64 builtin arguments.
+  if (d >= 2251799813685248.0 && d < 2251804108652544.0) d -= 2251799813685248.0;
+  if (d > 0.0 && d < 4294967296.0) {
+    const u32 ptr = (u32)d;
+    if ((f64)ptr == d) porf_gc_cons_candidate(ptr);
+  }
+}
+`;
+const BIGINT_GC_SCAN = `    if (d > 0.0 && d < 4294967296.0) {
+      const i64 iv = (i64)d;
+      if ((f64)iv == d) porf_gc_cons_candidate((u32)(u64)iv);
+    }`;
+
+export async function patchBigIntRoots(root: string): Promise<void> {
+  const file = resolve(root, "compiler/render.js");
+  const src = await readFile(file, "utf8");
+  if (src.includes(BIGINT_GC_HELPER) && src.split("    porf_gc_cons_f64(d);").length === 3) return;
+  if (src.split(BIGINT_GC_ANCHOR).length !== 2 || src.split(BIGINT_GC_SCAN).length !== 3)
+    throw new Error(`could not patch Porffor's BigInt GC roots: anchor not found in ${file}`);
+  await writeFile(
+    file,
+    src
+      .replace(BIGINT_GC_ANCHOR, BIGINT_GC_ANCHOR + BIGINT_GC_HELPER)
+      .replaceAll(BIGINT_GC_SCAN, "    porf_gc_cons_f64(d);"),
+  );
+}
+
 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> {
@@ -2313,15 +2053,15 @@ export async function ensurePorfforPatched(root: string): Promise<void> {
   await patchClassSelfName(root);
   await patchUwebsockets(root);
   await patchRenderJs(root);
+  await patchBigIntRoots(root);
   await patchStreamingResponses(root);
   await patchQuietCollection(root);
   await patchAsyncWaker(root);
   await patchDeferredDiscard(root);
-  await patchDateParser(root);
   await patchPromiseResolveNull(root);
   await patchReplaceAll(root);
   await patchLocalFunctionTypes(root);
-  await patchUint8ArrayBase64(root);
+  await patchFunctionSourcesScan(root);
   await patchResponseDefaults(root);
   await patchHeadersArrayInit(root);
   await patchHeadersClass(root);
@@ -2330,18 +2070,13 @@ export async function ensurePorfforPatched(root: string): Promise<void> {
   await patchResponseBytes(root);
   await patchURLClass(root);
   await patchTextDecoder(root);
-  await patchMapGroupBy(root);
-  await patchPrivateFieldsHidden(root);
   await patchRepeatDoubling(root);
-  await patchJsonCycles(root);
-  await patchJsonReviver(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.
+  // Last of the builtin edits: its precompile picks up the promise, replaceAll,
+  // local function and repeat patches above too.
   await precompileBuiltins(root);
   await patchUnicode(root);
   done.add(root);

package/src/pin.ts

@@ -11,11 +11,11 @@
  * uWebSockets archive in `sproutboat-cli/vendor/` — then run both repos'
  * test + conformance suites. See sproutboat-cli/MIGRATION.md.
  */
-export const PORFFOR_CHANNEL = "alpha-18";
-export const PORFFOR_COMMIT_FULL = "deda4945a526d3974ff79e499e8c1dcef0873f3a";
+export const PORFFOR_CHANNEL = "alpha-19";
+export const PORFFOR_COMMIT_FULL = "0c135ce2f36fdd3467d5a58daa92283810705a51";
 export const PORFFOR_COMMIT = PORFFOR_COMMIT_FULL.slice(0, 7);
 export const PORFFOR_ARCHIVE_SHA256 =
-  "4626ffba0d5bd417ba2c5b96506d40a152dbbeeaa8a698c904054bdef6bc6e64";
+  "b54da2297ad9e03c5bbac0e0d156f1179ac3a09a2a6fd702475cef605bab97b9";
 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-17 (731f1b2)`). */

package/src/unicode-native.test.ts

@@ -52,7 +52,10 @@ test("native Unicode JSON and UTF-8 encoding preserve code points and buffer bou
       }
       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 });
+      // The reviver sees each primitive's source text, sliced from UTF-16 input.
+      const sources = [];
+      JSON.parse('{"東京":{"id":"🚤","n":1.25},"l":[-3e2,"é"]}', (k, v, ctx) => { sources.push([k, ctx.source ?? null]); return v; });
+      return Response.json({ encoded, into, nested, escaped, growth, negatives, lone, quotedKey, sources });
     } };`;
     const [prelude, transport] = await Promise.all([
       readFile(preludePath, "utf8"),
@@ -103,6 +106,7 @@ test("native Unicode JSON and UTF-8 encoding preserve code points and buffer bou
     expect(actual.lone).toEqual({ value: "\ud800" });
     expect(actual.quotedKey).toEqual({ 'quote"key': "🚤" });
     expect(actual.negatives).toEqual([true, true, true, true]);
+    expect(actual.sources).toEqual([["id", '"🚤"'], ["n", "1.25"], ["東京", null], ["0", "-3e2"], ["1", '"é"'], ["l", null], ["", null]]);
   } finally {
     if (child) {
       child.kill(9);

package/src/unicode.ts

@@ -42,19 +42,16 @@ export const __Porffor_json_appendChar = (out: string, char: i32): void => {
 };
 ` +
     source.slice(end);
+  // Every parser helper and JSON.parse's own `const text` (Alpha 19 types the argument any).
   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)",
-  );
+  // Number literals and, since Alpha 19, the reviver's source text records.
+  source = replace(source, "Porffor.callThis(__ByteString_prototype_slice, text, start, ", "text.slice(start, ");
   source = replace(
     source,
     "let buffer: bytestring = Porffor.malloc(6 + cap);",
@@ -97,14 +94,6 @@ export const __Porffor_json_appendChar = (out: string, char: i32): void => {
       }
       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;
 }
 

package/test/gc-bigint.js.txt

@@ -0,0 +1,44 @@
+// Native GC scanner regression: bit 0 is the stack root, bit 1 the untyped block.
+// Bit 2 is set if a value just outside the heap-BigInt encoding marks the allocation.
+function probe() {
+  let stackMarked = 0;
+  let blockMarked = 0;
+  let falseMarked = 0;
+  Porffor.c`
+    u32 bigint = porf_alloc(16, 4);
+    u32 holder = porf_alloc(32, 0);
+    for (i32 ci = 0; ci < PORF_GC_NCLASSES; ci++) porf_gc_publish_window(ci);
+    const u32 gran = porf_gc_gran(bigint);
+    volatile f64 encoded = 2251799813685248.0 + (f64)bigint;
+    volatile f64 outside[4] = {
+      2251799813685248.0 + (f64)bigint + 0.5,
+      2251804108652544.0 + (f64)bigint,
+      -(2251799813685248.0 + (f64)bigint),
+      2251799813685248.0
+    };
+    for (i32 i = 0; i < 4; i++) {
+      porf_gc_bit_clear(PORF_GC_B_MARK, gran);
+      f64 d = outside[i];
+      u64 bits;
+      memcpy(&bits, &d, 8);
+      // Only the f64 decoding is under test: skip values whose 32-bit halves alias the block.
+      if (porf_gc_gran((u32)bits) == gran || porf_gc_gran((u32)(bits >> 32)) == gran) continue;
+      porf_gc_cons_scan_range((const u64*)&outside[i], (const u64*)&outside[i] + 1);
+      if (porf_gc_bit(PORF_GC_B_MARK, gran) != 0u) falseMarked = 1;
+    }
+    porf_gc_bit_clear(PORF_GC_B_MARK, gran);
+    porf_gc_cons_scan_range((const u64*)&encoded, (const u64*)((const char*)&encoded + sizeof(encoded)));
+    stackMarked = porf_gc_bit(PORF_GC_B_MARK, gran) != 0u;
+    porf_gc_bit_clear(PORF_GC_B_MARK, gran);
+    *(u64*)(MEM + holder) = 0xffffffffffffffffull;
+    *(f64*)(MEM + holder + 8) = encoded;
+    porf_gc_bit_clear(PORF_GC_B_MARK, porf_gc_gran(holder));
+    porf_gc_kinds[porf_gc_gran(holder)] = 0;
+    porf_gc_cons_mark_block((i32)holder);
+    blockMarked = porf_gc_bit(PORF_GC_B_MARK, gran) != 0u;
+  `;
+  return stackMarked + blockMarked * 2 + falseMarked * 4;
+}
+const marked = probe();
+console.log(marked);
+if (marked !== 3) throw new Error("heap BigInt was not marked, or a value outside its encoding was");