@sproutboat/toolchain 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # @sproutboat/toolchain
 
+## 0.13.0
+
+### Minor Changes
+
+- df612fc: `fetch(Request)`, `fetch(Request, init)` and `new Request(request, init)` behave as in workerd from compatibility date `2026-10-23`. This covers outgoing `fetch()`, service-binding `fetch()` and Durable Object stubs, on the broker and embedded transports alike. Every behaviour was checked against workerd 2026-09-27 by the platform's service-binding suite.
+  
+  From `2026-10-23`:
+  
+  - `fetch(input, init)` is `fetch(new Request(input, init))`, as the Fetch spec says. The Request's method, headers, body, redirect mode and signal apply unless `init` replaces them, and `init.headers` replaces all of the Request's headers.
+  - A Request given as `init` brings its method, headers and body.
+  - A body can be used once. `fetch(request)`, `new Request(request)` and reading it through `request.body` all use it, after which `bodyUsed` is true. Sending or copying a used Request throws `TypeError: Cannot reconstruct a Request with a used body.`, and reading it again throws workerd's "Body has already been used..." message. With a body in `init`, the source Request is left alone.
+  - A GET or HEAD Request with any body throws, even `""` or one inherited from another Request. An incoming GET or HEAD has `request.body === null`.
+  - Methods are workerd's: known names in any case are uppercased, and anything else throws `Invalid HTTP method string`. That includes `CONNECT` and custom names.
+  - `redirect` must be `"follow"` or `"manual"`. As in workerd, `"error"` throws when the Request is made.
+  - The headers of an incoming request, a fetched or service-binding response, and `Response.redirect()` are immutable: `set`, `append` and `delete` throw `TypeError: Can't modify immutable headers.` Copies are mutable, so `new Request(request)`, `new Response(body, response)` and `new Headers(h)` can still be changed.
+  - `AbortSignal.abort()`'s default reason reads "The operation was aborted", as in workerd.
+  
+  With an earlier `compatibility_date` these keep their old behaviour: a copy shares the body, any method name and redirect mode passes, and headers stay mutable. To get the new behaviour, move `compatibility_date` to `2026-10-23` and rebuild.
+  
+  These are fixed at every date, since no app can depend on the old behaviour:
+  
+  - `Request.signal` exists. A Request made with `signal` passes it on to copies and to `fetch()`, which aborts with it.
+  - A `ReadableStream` body in an outgoing `fetch()` is sent as its bytes. Before, it went out as the text `[object ReadableStream]`.
+  - `request.clone()` and `response.clone()` tee a stream body, so both copies can read it. Before, the second reader failed.
+  - A copy of an incoming request keeps its raw bytes. Its `text()` decodes UTF-8, and `fetch()` sends the bytes unchanged.
+
+## 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/toolchain",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "license": "MIT",
   "repository": {
     "type": "git",

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" +

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/fetch-classes.ts

@@ -61,9 +61,43 @@ export const REQUEST_CLASS_SOURCE = String.raw`class Request {
     return new TextEncoder().encode(text);
   }
 
+  // Fetch as workerd implements it, from compatibility date 2026-10-23: a Request made from
+  // another takes its body (the source becomes used, and a used one cannot be copied),
+  // GET and HEAD refuse any body, methods and redirect modes are workerd's, and errors
+  // carry workerd's messages. Before it, a copy shared the body, as it always did here.
+  static _strict() { return globalThis.__sbCompat >= '2026-10-23'; }
+  static _usedError() {
+    return new TypeError(Request._strict() ? 'Body has already been used. It can only be used once. Use tee() first if you need to read it twice.' : 'Body has already been used');
+  }
+  // workerd's methods (kj's list): known names in any case, uppercased; anything else throws.
+  static _method(method) {
+    const upper = method.toUpperCase();
+    const known = ' GET HEAD POST PUT DELETE PATCH PURGE OPTIONS TRACE COPY LOCK MKCOL MOVE PROPFIND PROPPATCH SEARCH UNLOCK ACL REPORT MKACTIVITY CHECKOUT MERGE MSEARCH NOTIFY SUBSCRIBE UNSUBSCRIBE QUERY ';
+    if (method.indexOf(' ') < 0 && known.indexOf(' ' + upper + ' ') >= 0) return upper;
+    throw new TypeError('Invalid HTTP method string: ' + method);
+  }
+  // Whether the body was used: read through this message, or (from 2026-10-23, as in
+  // workerd) through its stream by anyone, such as a Request given it as init.
+  static _used(message) {
+    if (message._bodyUsed === true) return true;
+    if (!Request._strict()) return false;
+    const stream = message._bodyStream != null ? message._bodyStream : message._bodyInit;
+    return Request._isStream(stream) && stream._disturbed === true;
+  }
+  // A body for two readers: a stream is teed, the first branch staying with the source.
+  // Values are read by copying, so both share them.
+  static _split(message) {
+    const init = message._bodyStream != null ? message._bodyStream : message._bodyInit;
+    if (!Request._isStream(init)) return init;
+    const pair = init.tee();
+    message._bodyInit = pair[0];
+    message._bodyStream = null;
+    return pair[1];
+  }
+
   // 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');
+    if (Request._used(message)) throw Request._usedError();
     message._bodyUsed = true;
     // A stream the body getter handed out is what the reader reads: a locked one throws.
     return message._bodyStream != null ? message._bodyStream : message._bodyInit;
@@ -89,6 +123,12 @@ export const REQUEST_CLASS_SOURCE = String.raw`class Request {
     return message._bodyStream;
   }
 
+  // Raw ingress bytes (a copy of an incoming request) decode as UTF-8, like any byte body.
+  static _messageText(message, body) {
+    if (message._bodyLatin1 === true && typeof body == 'string') return new TextDecoder().decode(Request._messageBytes(message, body));
+    return Request._bodyText(body);
+  }
+
   static _bodyText(body) {
     if (body == null) return '';
     if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return new TextDecoder().decode(body);
@@ -140,11 +180,15 @@ export const REQUEST_CLASS_SOURCE = String.raw`class Request {
   }
 
   constructor(input, init = undefined) {
+    const strict = Request._strict();
     let url = input;
     let method = 'GET';
     let headers = undefined;
     let body = null;
     let redirect = undefined;
+    let signal = null;
+    // The Request whose body this one takes, when init gives none.
+    let source = null;
 
     if (input instanceof Request) {
       url = input.url;
@@ -152,13 +196,19 @@ export const REQUEST_CLASS_SOURCE = String.raw`class Request {
       headers = input.headers;
       body = input._bodyStream != null ? input._bodyStream : input._bodyInit;
       redirect = input.redirect;
+      if (input._signal != null) signal = input._signal;
+      if (body != null) source = input;
     } 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.body !== undefined) {
+        body = init.body;
+        source = null;
+      }
       if (init.redirect != null) redirect = init.redirect;
+      if (init.signal !== undefined) signal = init.signal;
     }
 
     const raw = (Porffor.type(url) | 0b10000000) == Porffor.TYPES.bytestring ? url : String(url);
@@ -169,34 +219,58 @@ export const REQUEST_CLASS_SOURCE = String.raw`class Request {
       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'))
+    const methodText = (Porffor.type(method) | 0b10000000) == Porffor.TYPES.bytestring ? method : String(method);
+    this.method = strict ? Request._method(methodText) : methodText.toUpperCase();
+    if (strict) {
+      if (redirect != null && redirect != 'follow' && redirect != 'manual')
+        throw new TypeError('Invalid redirect value, must be one of "follow" or "manual" ("error" won\'t be implemented since it does not make sense at the edge; use "manual" and check the response status code).');
+      if (body != null && (this.method == 'GET' || this.method == 'HEAD'))
+        throw new TypeError('Request with a GET or HEAD method cannot have a body.');
+      if (source != null && Request._used(source)) throw new TypeError('Cannot reconstruct a Request with a used body.');
+    } else 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._bodyInit = Request._extractBody(body, this.headers);
+    if (source != null) {
+      // The body as the source holds it, already extracted: no content type is added, and
+      // raw ingress bytes stay bytes. From 2026-10-23 the source gives it up.
+      this._bodyInit = body;
+      if (source._bodyLatin1 === true) this._bodyLatin1 = true;
+      if (strict) source._bodyUsed = true;
+    } else this._bodyInit = Request._extractBody(body, this.headers);
     if (redirect != null) this._redirect = String(redirect);
+    if (signal != null) this._signal = signal;
   }
 
   get redirect() { return this._redirect ?? 'follow'; }
+  // A signal that never aborts unless one was given, made when first asked for.
+  get signal() {
+    if (this._signal == null) this._signal = new globalThis.AbortController().signal;
+    return this._signal;
+  }
   get body() { return Request._bodyAsStream(this); }
   set body(value) { this._bodyInit = value; this._bodyStream = null; }
-  get bodyUsed() { return this._bodyUsed === true; }
+  get bodyUsed() { return Request._used(this); }
 
   arrayBuffer() { return Request._read(this, (bytes) => bytes.buffer); }
   blob() { return Request._read(this, (bytes) => new Blob([bytes])); }
+  // A copy with its own branch of the body. workerd says the used body's stream is locked.
   clone() {
-    if (this._bodyUsed === true) throw new TypeError('Body has already been used');
-    return new Request(this);
+    if (Request._used(this))
+      throw new TypeError(Request._strict() ? 'This ReadableStream is currently locked to a reader,' : 'Body has already been used');
+    const copy = new Request(this.url, { method: this.method, headers: this.headers, redirect: this._redirect, signal: this._signal });
+    copy._bodyInit = Request._split(this);
+    if (this._bodyLatin1 === true) copy._bodyLatin1 = true;
+    return copy;
   }
   json() {
     const body = Request._consume(this);
     if (Request._isStream(body)) return Request._streamBytes(body).then((bytes) => JSON.parse(new TextDecoder().decode(bytes)));
-    return JSON.parse(Request._bodyText(body));
+    return JSON.parse(Request._messageText(this, body));
   }
   text() {
     const body = Request._consume(this);
     if (Request._isStream(body)) return Request._streamBytes(body).then((bytes) => new TextDecoder().decode(bytes));
-    return Request._bodyText(body);
+    return Request._messageText(this, body);
   }
 }
 
@@ -227,14 +301,14 @@ export const RESPONSE_CLASS_SOURCE = String.raw`class Response {
   get ok() { return this.status >= 200 && this.status < 300; }
   get body() { return Request._bodyAsStream(this); }
   set body(value) { this._bodyInit = value; this._bodyStream = null; }
-  get bodyUsed() { return this._bodyUsed === true; }
+  get bodyUsed() { return Request._used(this); }
 
   arrayBuffer() { return Request._read(this, (bytes) => bytes.buffer); }
   blob() { return Request._read(this, (bytes) => new Blob([bytes])); }
   clone() {
-    if (this._bodyUsed === true) throw new TypeError('Body has already been used');
+    if (Request._used(this)) 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._bodyInit = this._bodyInit;
+    copy._bodyInit = Request._split(this);
     copy.status = this.status;
     if (this._type != null) copy._type = this._type;
     return copy;
@@ -242,12 +316,12 @@ export const RESPONSE_CLASS_SOURCE = String.raw`class Response {
   json() {
     const body = Request._consume(this);
     if (Request._isStream(body)) return Request._streamBytes(body).then((bytes) => JSON.parse(new TextDecoder().decode(bytes)));
-    return JSON.parse(Request._bodyText(body));
+    return JSON.parse(Request._messageText(this, body));
   }
   text() {
     const body = Request._consume(this);
     if (Request._isStream(body)) return Request._streamBytes(body).then((bytes) => new TextDecoder().decode(bytes));
-    return Request._bodyText(body);
+    return Request._messageText(this, body);
   }
 }
 `;

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 = "7e12e7bba967";
+export const RELEASED_FINGERPRINT = "147f6e5e6655";
 
 /** The fingerprint of the sources in dir, or null where they are not on disk. */
 export function sourceFingerprint(dir: string): string | null {

package/src/headers-class.ts

@@ -7,6 +7,10 @@
  * 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.
+ *
+ * `_immutable`, when the runtime sets it, makes append, set and delete throw as workerd's
+ * immutable guard does (an incoming request's headers, a fetched response's). The runtime
+ * sets it from compatibility date 2026-10-23; a copy (`new Headers(h)`) is always mutable.
  */
 export const HEADERS_CLASS_SOURCE = String.raw`class Headers {
   // sproutboat: Fetch-spec Headers
@@ -52,11 +56,17 @@ export const HEADERS_CLASS_SOURCE = String.raw`class Headers {
     Porffor.array.fastPush(this._entries, value);
   }
 
+  _writable() {
+    if (this._immutable === true) throw new TypeError("Can't modify immutable headers.");
+  }
+
   append(name, value) {
+    this._writable();
     this._push(Headers._name(name), Headers._value(value));
   }
 
   delete(name) {
+    this._writable();
     const normalized = Headers._name(name);
     const next = Porffor.array.new(this._entries.length);
     for (let i = 0; i < this._entries.length; i += 2) {
@@ -90,6 +100,7 @@ export const HEADERS_CLASS_SOURCE = String.raw`class Headers {
   }
 
   set(name, value) {
+    this._writable();
     const normalized = Headers._name(name), v = Headers._value(value);
     this.delete(normalized);
     this._push(normalized, v);

package/src/patch.ts

@@ -1925,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> {
@@ -2023,6 +2053,7 @@ 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);

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");