@sproutboat/toolchain 0.7.0 → 0.8.0

package/src/fetch-classes.ts

@@ -0,0 +1,242 @@
+/**
+ * Request and Response classes for Porffor's runtime/fetch-globals.js (patchFetchClasses),
+ * and the native response finalizer's byte-body handling (patchResponseBytes). Found by
+ * sproutd's W2 conformance suite against workerd:
+ *  - Response had no statusText or type, no Response.error, accepted any status, and read
+ *    byte bodies as text ("1,2,3"); Request kept relative and unnormalized URLs, allowed
+ *    a body on GET, had no redirect, and set no content type for its body.
+ *  - The finalizer sent String(response.body), so a Uint8Array body reached the client as
+ *    "104,105" and an ArrayBuffer as "[object ArrayBuffer]".
+ * Field names (url, method, headers, body, status) stay Porffor's: the native ingress builds
+ * Requests without the constructor, and the native writer reads those fields, so defaults
+ * for fields it does not set (redirect, statusText, type) are prototype getters.
+ */
+
+export const REQUEST_CLASS_SOURCE = String.raw`class Request {
+  // sproutboat: Fetch-spec Request and Response
+  // Body init as Fetch extracts it: URLSearchParams becomes form text, and a text body gets
+  // its default content type unless one was given. Statics, shared with Response: plain
+  // top-level functions in this file are not visible from class methods.
+  static _extractBody(body, headers) {
+    // A Blob's bytes, with its type as the content type unless one was given.
+    if (body instanceof Blob) {
+      if (body.type != '' && !headers.has('content-type')) headers.set('content-type', body.type);
+      return body._bytes.slice();
+    }
+    // FormData as multipart/form-data. The prelude defines FormData and URLSearchParams on
+    // globalThis after this file is compiled.
+    const Form = globalThis.FormData;
+    if (Form != null && body instanceof Form) {
+      const boundary = '----sproutboat' + Math.random().toString(16).slice(2) + Math.random().toString(16).slice(2);
+      const encoder = new TextEncoder();
+      const parts = [];
+      for (const entry of body._entries) {
+        const name = String(entry[0]).replace(/"/g, '%22');
+        const value = entry[1];
+        if (value instanceof Blob) {
+          const filename = String(value.name ?? 'blob').replace(/"/g, '%22');
+          parts.push(encoder.encode('--' + boundary + '\r\nContent-Disposition: form-data; name="' + name + '"; filename="' + filename + '"\r\nContent-Type: ' + (value.type || 'application/octet-stream') + '\r\n\r\n'));
+          parts.push(value._bytes);
+          parts.push(encoder.encode('\r\n'));
+        } else parts.push(encoder.encode('--' + boundary + '\r\nContent-Disposition: form-data; name="' + name + '"\r\n\r\n' + String(value) + '\r\n'));
+      }
+      parts.push(encoder.encode('--' + boundary + '--\r\n'));
+      if (!headers.has('content-type')) headers.set('content-type', 'multipart/form-data; boundary=' + boundary);
+      return new Blob(parts)._bytes;
+    }
+    const Params = globalThis.URLSearchParams;
+    if (Params != null && body instanceof Params) {
+      if (!headers.has('content-type')) headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+      return body.toString();
+    }
+    if (typeof body === 'string' && !headers.has('content-type')) headers.set('content-type', 'text/plain;charset=UTF-8');
+    return body;
+  }
+
+  static _bodyBytes(body) {
+    if (body == null) return new Uint8Array(0);
+    if (body instanceof ArrayBuffer) return new Uint8Array(body.slice(0));
+    if (ArrayBuffer.isView(body)) return new Uint8Array(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength));
+    const text = (Porffor.type(body) | 0b10000000) == Porffor.TYPES.bytestring ? body : String(body);
+    return new TextEncoder().encode(text);
+  }
+
+  // A body is read once: the first reader marks it used, a second throws, as in Fetch.
+  static _consume(message) {
+    if (message._bodyUsed === true) throw new TypeError('Body has already been used');
+    message._bodyUsed = true;
+    return message.body;
+  }
+
+  static _bodyText(body) {
+    if (body == null) return '';
+    if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return new TextDecoder().decode(body);
+    return (Porffor.type(body) | 0b10000000) == Porffor.TYPES.bytestring ? body : String(body);
+  }
+
+  constructor(input, init = undefined) {
+    let url = input;
+    let method = 'GET';
+    let headers = undefined;
+    let body = null;
+    let redirect = undefined;
+
+    if (input instanceof Request) {
+      url = input.url;
+      method = input.method;
+      headers = input.headers;
+      body = input.body;
+      redirect = input.redirect;
+    } else if (input != null && Porffor.type(input) == Porffor.TYPES.object && input.href != null) url = input.href;
+
+    if (init != null) {
+      if (init.method != null) method = init.method;
+      if (init.headers != null) headers = init.headers;
+      if (init.body !== undefined) body = init.body;
+      if (init.redirect != null) redirect = init.redirect;
+    }
+
+    const raw = (Porffor.type(url) | 0b10000000) == Porffor.TYPES.bytestring ? url : String(url);
+    let href;
+    try {
+      href = new URL(raw).href;
+    } catch (e) {
+      throw new TypeError('Invalid URL: ' + raw);
+    }
+    this.url = href;
+    this.method = ((Porffor.type(method) | 0b10000000) == Porffor.TYPES.bytestring ? method : String(method)).toUpperCase();
+    if (init != null && init.body != null && init.body !== '' && (this.method == 'GET' || this.method == 'HEAD'))
+      throw new TypeError('Request with GET/HEAD method cannot have body.');
+    this.headers = new Headers(headers);
+    this.body = Request._extractBody(body, this.headers);
+    if (redirect != null) this._redirect = String(redirect);
+  }
+
+  get redirect() { return this._redirect ?? 'follow'; }
+  get bodyUsed() { return this._bodyUsed === true; }
+
+  arrayBuffer() { return Request._bodyBytes(Request._consume(this)).buffer; }
+  blob() { return new Blob([Request._bodyBytes(Request._consume(this))]); }
+  clone() {
+    if (this._bodyUsed === true) throw new TypeError('Body has already been used');
+    return new Request(this);
+  }
+  json() { return JSON.parse(Request._bodyText(Request._consume(this))); }
+  text() { return Request._bodyText(Request._consume(this)); }
+}
+
+`;
+
+export const RESPONSE_CLASS_SOURCE = String.raw`class Response {
+  constructor(body = null, init = undefined) {
+    const status = init?.status ?? 200;
+    this.status = Number(status);
+    if (!(this.status >= 200 && this.status <= 599) || this.status != Math.floor(this.status))
+      throw new RangeError('Response status must be between 200 and 599, got ' + status);
+    if (body != null && (this.status == 101 || this.status == 204 || this.status == 205 || this.status == 304))
+      throw new TypeError('Response with null body status cannot have body');
+    if (init?.statusText != null) this._statusText = String(init.statusText);
+    this.headers = new Headers(init?.headers);
+    this.body = Request._extractBody(body, this.headers);
+  }
+
+  static error() {
+    const response = new Response(null, { status: 200 });
+    response.status = 0;
+    response._type = 'error';
+    return response;
+  }
+
+  get statusText() { return this._statusText ?? ''; }
+  get type() { return this._type ?? 'default'; }
+  get ok() { return this.status >= 200 && this.status < 300; }
+  get bodyUsed() { return this._bodyUsed === true; }
+
+  arrayBuffer() { return Request._bodyBytes(Request._consume(this)).buffer; }
+  blob() { return new Blob([Request._bodyBytes(Request._consume(this))]); }
+  clone() {
+    if (this._bodyUsed === true) throw new TypeError('Body has already been used');
+    const copy = new Response(null, { status: this.status == 0 ? 200 : this.status, statusText: this._statusText, headers: this.headers });
+    copy.body = this.body;
+    copy.status = this.status;
+    if (this._type != null) copy._type = this._type;
+    return copy;
+  }
+  json() { return JSON.parse(Request._bodyText(Request._consume(this))); }
+  text() { return Request._bodyText(Request._consume(this)); }
+}
+`;
+
+// The finalizer's body line, and what replaces it: byte bodies go out as their bytes.
+export const RESPONSE_BYTES_ANCHOR =
+  "  const body = response.body == null ? '' : String(response.body);\n  const headersEntries = response.headers._entries;\n";
+export const RESPONSE_BYTES_INJECT =
+  "  // sproutboat: byte bodies go out as their bytes. A Latin-1 string, one character per byte,\n" +
+  "  // built in windows (concatenating one long string is quadratic), sent raw by the writer.\n" +
+  "  let body = response.body;\n" +
+  "  let headersEntries = response.headers._entries;\n" +
+  "  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {\n" +
+  "    const view = body instanceof ArrayBuffer ? new Uint8Array(body) : new Uint8Array(body.buffer, body.byteOffset, body.byteLength);\n" +
+  "    const chunks = [];\n" +
+  "    let chunk = '';\n" +
+  "    for (let i = 0; i < view.length; i++) {\n" +
+  "      chunk += String.fromCharCode(view[i]);\n" +
+  "      if (chunk.length == 512) { chunks.push(chunk); chunk = ''; }\n" +
+  "    }\n" +
+  "    chunks.push(chunk);\n" +
+  "    body = chunks.join('');\n" +
+  "    headersEntries = headersEntries.slice();\n" +
+  "    headersEntries.push('x-sb-raw-body', '1');\n" +
+  "  } else body = body == null ? '' : String(body);\n";
+
+// Porffor's Blob kept one string (binary parts were stringified) and had no size, type or
+// slice; File did not exist. Bytes inside, text() decoded as UTF-8, read methods as promises.
+export const BLOB_CLASS_SOURCE = String.raw`class Blob {
+  // sproutboat: byte-backed Blob and File
+  constructor(parts = [], options = undefined) {
+    const chunks = [];
+    let size = 0;
+    for (const part of parts) {
+      let bytes;
+      if (part instanceof Blob) bytes = part._bytes;
+      else if (part instanceof ArrayBuffer) bytes = new Uint8Array(part);
+      else if (ArrayBuffer.isView(part)) bytes = new Uint8Array(part.buffer, part.byteOffset, part.byteLength);
+      else bytes = new TextEncoder().encode(String(part));
+      chunks.push(bytes);
+      size += bytes.length;
+    }
+    this._bytes = new Uint8Array(size);
+    let at = 0;
+    for (const chunk of chunks) {
+      this._bytes.set(chunk, at);
+      at += chunk.length;
+    }
+    const type = options == null || options.type == null ? '' : String(options.type);
+    this._type = /^[\x20-\x7e]*$/.test(type) ? type.toLowerCase() : '';
+  }
+
+  get size() { return this._bytes.length; }
+  get type() { return this._type; }
+
+  slice(start = 0, end = undefined, contentType = '') {
+    const n = this._bytes.length;
+    const from = start < 0 ? Math.max(n + start, 0) : Math.min(start, n);
+    const to = end === undefined ? n : end < 0 ? Math.max(n + end, 0) : Math.min(end, n);
+    const out = new Blob([], { type: contentType });
+    out._bytes = this._bytes.slice(from, Math.max(to, from));
+    return out;
+  }
+
+  arrayBuffer() { return Promise.resolve(this._bytes.slice().buffer); }
+  bytes() { return Promise.resolve(this._bytes.slice()); }
+  text() { return Promise.resolve(new TextDecoder().decode(this._bytes)); }
+}
+
+class File extends Blob {
+  constructor(bits, name, options = undefined) {
+    super(bits, options);
+    this.name = String(name);
+    this.lastModified = options != null && options.lastModified != null ? Number(options.lastModified) : Date.now();
+  }
+}
+`;

package/src/fingerprint.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from "bun:test";
+import { readdir } from "node:fs/promises";
+import { PATCH_FINGERPRINT, PATCH_SOURCES } from "./fingerprint";
+
+// Not part of the patched compiler: acquisition, the barrel, generators and this module.
+const NOT_PATCH_SOURCES = new Set(["acquire.ts", "index.ts", "fingerprint.ts"]);
+
+test("the patch fingerprint covers every toolchain module that shapes the compiler", async () => {
+  const modules = (await readdir(import.meta.dir)).filter(
+    (name) => name.endsWith(".ts") && !name.endsWith(".test.ts") && !name.startsWith("gen-") && !NOT_PATCH_SOURCES.has(name),
+  );
+  expect(Object.keys(PATCH_SOURCES).sort()).toEqual(modules.sort());
+  const embedded = new Map<string, string>(Object.entries(PATCH_SOURCES));
+  for (const name of modules) expect(embedded.get(name)).toBe(await Bun.file(`${import.meta.dir}/${name}`).text());
+  expect(PATCH_FINGERPRINT).toMatch(/^[0-9a-f]{12}$/);
+});

package/src/fingerprint.ts

@@ -0,0 +1,48 @@
+import { createHash } from "node:crypto";
+// The patch chain's own source text, embedded by Bun's text loader (it survives
+// `bun build --compile`, where these files do not exist on disk). TypeScript sees
+// a module, not a string, hence the expect-errors.
+// @ts-expect-error text import
+import caseMap from "./case-map.ts" with { type: "text" };
+// @ts-expect-error text import
+import fetchClasses from "./fetch-classes.ts" with { type: "text" };
+// @ts-expect-error text import
+import headersClass from "./headers-class.ts" with { type: "text" };
+// @ts-expect-error text import
+import patch from "./patch.ts" with { type: "text" };
+// @ts-expect-error text import
+import pin from "./pin.ts" with { type: "text" };
+// @ts-expect-error text import
+import streaming from "./streaming.ts" with { type: "text" };
+// @ts-expect-error text import
+import textDecoder from "./text-decoder.ts" with { type: "text" };
+// @ts-expect-error text import
+import unicode from "./unicode.ts" with { type: "text" };
+// @ts-expect-error text import
+import urlClass from "./url-class.ts" with { type: "text" };
+
+/** Every module that shapes the patched compiler. fingerprint.test.ts fails when one is missing. */
+export const PATCH_SOURCES = {
+  "case-map.ts": caseMap,
+  "fetch-classes.ts": fetchClasses,
+  "headers-class.ts": headersClass,
+  "patch.ts": patch,
+  "pin.ts": pin,
+  "streaming.ts": streaming,
+  "text-decoder.ts": textDecoder,
+  "unicode.ts": unicode,
+  "url-class.ts": urlClass,
+} satisfies Record<string, string>;
+
+/**
+ * Identifies the patch chain, not just the toolchain release. A cache entry is keyed by it, so
+ * an edited patch gets a fresh, fully patched compiler instead of one a same-version build
+ * already marked complete (B19: the prelude began calling sb_stream_*, which only the new
+ * chain defines, and every build against an older entry failed to link).
+ */
+export const PATCH_FINGERPRINT = (() => {
+  const hash = createHash("sha256");
+  for (const [name, source] of Object.entries(PATCH_SOURCES).sort(([a], [b]) => a.localeCompare(b)))
+    hash.update(`${name}\0${source}\0`);
+  return hash.digest("hex").slice(0, 12);
+})();

package/src/gen-case-map.ts

@@ -0,0 +1,35 @@
+export {};
+// Simple (one code unit to one code unit) BMP case mappings as runs: [start, end, delta, step].
+function runs(map: (c: string) => string) {
+  const pairs: [number, number][] = [];
+  for (let cp = 0x80; cp <= 0xffff; cp++) {
+    if (cp >= 0xd800 && cp <= 0xdfff) continue;
+    const ch = String.fromCharCode(cp), m = map(ch);
+    if (m.length === 1 && m !== ch) pairs.push([cp, m.charCodeAt(0) - cp]);
+  }
+  const out: number[][] = [];
+  for (const [cp, d] of pairs) {
+    const last = out[out.length - 1];
+    if (last && last[2] === d && (last[3] === 0 ? (cp - last[1] === 1 || cp - last[1] === 2) : cp - last[1] === last[3])) {
+      if (last[3] === 0) last[3] = cp - last[1];
+      last[1] = cp;
+    } else out.push([cp, cp, d, 0]);
+  }
+  return out.map((r) => [r[0], r[1], r[2], r[3] || 1]);
+}
+const lower = runs((c) => c.toLowerCase()), upper = runs((c) => c.toUpperCase());
+console.log("lower runs", lower.length, "upper runs", upper.length);
+const all = [...lower, ...upper];
+// usage: bun gen-case-map.ts case-map.ts
+console.log("delta range", Math.min(...all.map((r) => r[2])), Math.max(...all.map((r) => r[2])), "max end", Math.max(...all.map((r) => r[1]).map(Number)).toString(16));
+const enc = (rs: number[][]) => rs.map(([s, e, d, st]) => [s, e, s + d, st].map((x) => "\\u" + x.toString(16).padStart(4, "0")).join("")).join("");
+if (process.argv[2]) await Bun.write(process.argv[2], `/**
+ * Unicode simple case mappings for BMP code units (one unit to one unit), generated by
+ * gen-case-map.ts from ${"Bun " + Bun.version}'s String.prototype.toLowerCase/toUpperCase and checked
+ * in, so patched builds do not depend on the patching engine's Unicode version. Runs of four
+ * UTF-16 code units: start, end, the start's mapping, step (1, or 2 for alternating pairs);
+ * a unit in a run maps to that mapping plus its distance from the start.
+ */
+export const CASE_LOWER_RUNS = "${enc(lower)}";
+export const CASE_UPPER_RUNS = "${enc(upper)}";
+`);

package/src/groupby-private-native.test.ts

@@ -0,0 +1,37 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { ensurePorffor } from "./acquire";
+
+// baronunread/sproutboat#286: Map.groupBy exists, and private fields stay out of
+// Object.keys, for-in, Object.entries and JSON.stringify. Compared against Bun.
+const source = `const m = Map.groupBy([1, 2, 3, 4, NaN, NaN], (x) => (x !== x ? "nan" : x % 2 ? "odd" : "even"));
+const key = {};
+const byObject = Map.groupBy([1, 2, 3], (x) => (x > 1 ? key : 0));
+class A { #s = 1; pub = 2; static #t = 3; static u = 4; get s() { return this.#s; } static get t() { return A.#t; } inc() { this.#s++; return this.#s; } }
+const a = new A();
+const forIn = []; for (const k in a) forIn.push(k);
+console.log(JSON.stringify({
+  groups: [...m], size: m.size, isMap: m instanceof Map, byObject: [byObject.get(key), byObject.get(0)],
+  keys: Object.keys(a), json: JSON.stringify(a), values: [a.s, a.inc(), A.t], staticKeys: Object.keys(A),
+  forIn, entries: Object.entries(a),
+}));`;
+
+test("#286: Map.groupBy and private fields match Bun", async () => {
+  const dir = await mkdtemp(resolve(tmpdir(), "sb-286-"));
+  try {
+    const porffor = await ensurePorffor();
+    const input = resolve(dir, "case.js"), binary = resolve(dir, "case");
+    await writeFile(input, source);
+    const compile = Bun.spawnSync(["bun", resolve(porffor, "runtime/index.js"), "native", input, "-o", binary, "-s", "-O0"], { stdout: "pipe", stderr: "pipe" });
+    expect(compile.exitCode, new TextDecoder().decode(compile.stderr)).toBe(0);
+    const run = Bun.spawnSync([binary], { stdout: "pipe", stderr: "pipe", timeout: 10_000 });
+    expect(run.exitCode, new TextDecoder().decode(run.stderr)).toBe(0);
+    const reference = Bun.spawnSync(["bun", input], { stdout: "pipe" });
+    const strip = (bytes: Uint8Array) => new TextDecoder().decode(bytes).replaceAll("\x1b[33m", "").replaceAll("\x1b[0m", "").trim();
+    expect(JSON.parse(strip(run.stdout))).toEqual(JSON.parse(strip(reference.stdout)));
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}, 60_000);

package/src/headers-class.ts

@@ -0,0 +1,120 @@
+/**
+ * The Headers class patchHeadersClass puts into Porffor's runtime/fetch-globals.js. Porffor's
+ * kept the first value for get() (append("a", "1"), append("a", "2") then get("a") gave
+ * "1"), iterated in insertion order, had no getSetCookie, and accepted any name or value
+ * unvalidated and untrimmed. Found by sproutd's W2 conformance suite against workerd.
+ *
+ * Storage stays Porffor's: `_entries` holds each appended name (lowercased) and value in
+ * order, flat, because the native response writer reads it, and each Set-Cookie must reach
+ * the wire as its own header. The Fetch spec's combined, sorted view is computed on read.
+ */
+export const HEADERS_CLASS_SOURCE = String.raw`class Headers {
+  // sproutboat: Fetch-spec Headers
+  constructor(init = undefined) {
+    this._entries = Porffor.array.new(8);
+    if (init == null) return;
+    if (init instanceof Headers) {
+      for (let i = 0; i < init._entries.length; i += 2) this._push(init._entries[i], init._entries[i + 1]);
+      return;
+    }
+    if (typeof init != 'object') throw new TypeError('Headers: init must be an object, an array of pairs or Headers');
+    if (Array.isArray(init) || typeof init[Symbol.iterator] == 'function') {
+      for (const entry of init) {
+        if (!entry || entry.length != 2) throw new TypeError('Headers: each pair must have exactly two items');
+        this.append(entry[0], entry[1]);
+      }
+      return;
+    }
+    for (const key in init) this.append(key, init[key]);
+  }
+
+  static _name(name) {
+    const s = String(name);
+    if (!/^[!#$%&'*+\-.^_\x60|~0-9A-Za-z]+$/.test(s)) throw new TypeError('Invalid header name: ' + s);
+    return s.toLowerCase();
+  }
+
+  static _value(value) {
+    let s = String(value);
+    let start = 0, end = s.length;
+    while (start < end && (s.charCodeAt(start) == 32 || s.charCodeAt(start) == 9 || s.charCodeAt(start) == 10 || s.charCodeAt(start) == 13)) start++;
+    while (end > start && (s.charCodeAt(end - 1) == 32 || s.charCodeAt(end - 1) == 9 || s.charCodeAt(end - 1) == 10 || s.charCodeAt(end - 1) == 13)) end--;
+    s = s.slice(start, end);
+    for (let i = 0; i < s.length; i++) {
+      const c = s.charCodeAt(i);
+      if (c == 0 || c == 10 || c == 13) throw new TypeError('Invalid header value');
+    }
+    return s;
+  }
+
+  _push(name, value) {
+    Porffor.array.fastPush(this._entries, name);
+    Porffor.array.fastPush(this._entries, value);
+  }
+
+  append(name, value) {
+    this._push(Headers._name(name), Headers._value(value));
+  }
+
+  delete(name) {
+    const normalized = Headers._name(name);
+    const next = Porffor.array.new(this._entries.length);
+    for (let i = 0; i < this._entries.length; i += 2) {
+      if (this._entries[i] == normalized) continue;
+      Porffor.array.fastPush(next, this._entries[i]);
+      Porffor.array.fastPush(next, this._entries[i + 1]);
+    }
+    this._entries = next;
+  }
+
+  get(name) {
+    const normalized = Headers._name(name);
+    let out = null;
+    for (let i = 0; i < this._entries.length; i += 2) {
+      if (this._entries[i] != normalized) continue;
+      out = out == null ? this._entries[i + 1] : out + ', ' + this._entries[i + 1];
+    }
+    return out;
+  }
+
+  getSetCookie() {
+    const out = [];
+    for (let i = 0; i < this._entries.length; i += 2) if (this._entries[i] == 'set-cookie') out.push(this._entries[i + 1]);
+    return out;
+  }
+
+  has(name) {
+    const normalized = Headers._name(name);
+    for (let i = 0; i < this._entries.length; i += 2) if (this._entries[i] == normalized) return true;
+    return false;
+  }
+
+  set(name, value) {
+    const normalized = Headers._name(name), v = Headers._value(value);
+    this.delete(normalized);
+    this._push(normalized, v);
+  }
+
+  // The spec's sort-and-combine: names ascending, values joined with ", ", except
+  // set-cookie, which is listed once per value.
+  _sorted() {
+    const names = [];
+    for (let i = 0; i < this._entries.length; i += 2) if (!names.includes(this._entries[i])) names.push(this._entries[i]);
+    names.sort();
+    const out = [];
+    for (const name of names) {
+      if (name == 'set-cookie') {
+        for (const value of this.getSetCookie()) out.push([name, value]);
+      } else out.push([name, this.get(name)]);
+    }
+    return out;
+  }
+
+  entries() { return this._sorted(); }
+  keys() { return this._sorted().map((pair) => pair[0]); }
+  values() { return this._sorted().map((pair) => pair[1]); }
+  forEach(callback, thisArg = undefined) {
+    for (const pair of this._sorted()) callback.call(thisArg, pair[1], pair[0], this);
+  }
+}
+`;

package/src/idle-gc.test.ts

@@ -0,0 +1,38 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { execFileSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { patchQuietCollection } from "./patch";
+
+test("idle reclamation preserves unconditional request GC and is idempotent on the pinned compiler", async () => {
+  const root = await mkdtemp(resolve(tmpdir(), "sb-quiet-gc-"));
+  try {
+    execFileSync("tar", [
+      "-xzf",
+      resolve(import.meta.dir, "../vendor/porffor-deda494.tar.gz"),
+      "--strip-components=1",
+      "-C",
+      root,
+    ]);
+    await patchQuietCollection(root);
+    const render = await readFile(resolve(root, "compiler/render.js"), "utf8");
+    const shim = await readFile(resolve(root, "compiler/uwebsockets.js"), "utf8");
+    const start = shim.indexOf("static void collect_after_request(void) {");
+    const end = shim.indexOf("\n}\n", start);
+    const body = shim.slice(start, end);
+    const normal = body.indexOf(
+      "porf_native_fetch_collect_normal_from((void*)&porf_stack_anchor);",
+    );
+    const guard = body.indexOf("if (porf_native_fetch_needs_quiet_collect()) {");
+    expect(normal).toBeGreaterThan(-1);
+    expect(guard).toBeGreaterThan(normal);
+    expect(body.slice(0, guard)).not.toContain("return;");
+    expect(render).toContain("porf_gc_mark_queue_len == 0 && porf_gc_mark_queue_cap > 4096");
+    await patchQuietCollection(root);
+    expect(await readFile(resolve(root, "compiler/render.js"), "utf8")).toBe(render);
+    expect(await readFile(resolve(root, "compiler/uwebsockets.js"), "utf8")).toBe(shim);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/src/json-cycles-native.test.ts

@@ -0,0 +1,39 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { ensurePorffor } from "./acquire";
+
+// Found by the sproutd W2 conformance suite: JSON.stringify of a cycle overflowed the
+// native stack (the process died) instead of throwing, and typed arrays had no toString
+// tag. Compared against Bun, except the cycle message, which follows V8.
+const source = `const out = [];
+const a = { n: 1 }; a.self = a;
+try { JSON.stringify(a); out.push("no throw"); } catch (e) { out.push(e.name); }
+const arr = [1]; arr.push(arr);
+try { JSON.stringify(arr); out.push("no throw"); } catch (e) { out.push(e.name); }
+const shared = { x: 1 };
+out.push(JSON.stringify({ a: shared, b: [shared, [shared]] }));
+const bad = { toJSON() { throw new RangeError("t"); } };
+try { JSON.stringify({ x: { y: bad } }); } catch (e) { out.push(e.name); }
+out.push(JSON.stringify({ x: { y: 1 } }));
+out.push([new Uint8Array(1), new Float64Array(1), new BigInt64Array(1), new DataView(new ArrayBuffer(1)), []].map((x) => Object.prototype.toString.call(x)).join(" "));
+console.log(JSON.stringify(out));`;
+
+test("JSON.stringify throws on cycles and typed arrays have toString tags, as in Bun", async () => {
+  const dir = await mkdtemp(resolve(tmpdir(), "sb-json-cycles-"));
+  try {
+    const porffor = await ensurePorffor();
+    const input = resolve(dir, "case.js"), binary = resolve(dir, "case");
+    await writeFile(input, source);
+    const compile = Bun.spawnSync(["bun", resolve(porffor, "runtime/index.js"), "native", input, "-o", binary, "-s", "-O0"], { stdout: "pipe", stderr: "pipe" });
+    expect(compile.exitCode, new TextDecoder().decode(compile.stderr)).toBe(0);
+    const run = Bun.spawnSync([binary], { stdout: "pipe", stderr: "pipe", timeout: 10_000 });
+    expect(run.exitCode, new TextDecoder().decode(run.stderr)).toBe(0);
+    const reference = Bun.spawnSync(["bun", input], { stdout: "pipe" });
+    const strip = (bytes: Uint8Array) => new TextDecoder().decode(bytes).replaceAll("\x1b[33m", "").replaceAll("\x1b[0m", "").trim();
+    expect(JSON.parse(strip(run.stdout))).toEqual(JSON.parse(strip(reference.stdout)));
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}, 60_000);