@sproutboat/runtime 0.22.0 → 0.23.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @sproutboat/runtime
 
+## 0.23.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.22.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/native-fetch-prelude.js

@@ -3315,6 +3315,15 @@ for (const E of [Error, TypeError, RangeError, ReferenceError, SyntaxError, Eval
 // Object.fromEntries(headers) work. Porffor's Headers has entries() but no iterator.
 if (Headers.prototype[Symbol.iterator] == null) Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
 
+// workerd's immutable headers, from compatibility date 2026-10-23: an incoming request's,
+// a fetched or service-binding response's, and Response.redirect()'s refuse append, set
+// and delete with a TypeError. A copy (new Headers(h), new Response(body, res)) is
+// mutable. The runtime's own writes after the handler lift the guard first.
+function __sbFreezeHeaders(message) {
+  if (globalThis.__sbCompat >= "2026-10-23") message.headers._immutable = true;
+  return message;
+}
+
 // Porffor alpha-10 has no static Response.redirect().
 if (Response.redirect == null) {
   Response.redirect = function (url, status = 302) {
@@ -3322,7 +3331,7 @@ if (Response.redirect == null) {
       throw new RangeError("invalid redirect status");
     }
     // Serialized like the URL parser does (a bare origin gains its "/"); invalid URLs throw.
-    return new Response(null, { status, headers: { location: new URL(String(url)).href } });
+    return __sbFreezeHeaders(new Response(null, { status, headers: { location: new URL(String(url)).href } }));
   };
 }
 
@@ -3739,7 +3748,9 @@ if (typeof globalThis.EventTarget !== "function") {
     __sbAbort(reason) {
       if (this.aborted) return;
       this.aborted = true;
-      this.reason = reason === undefined ? namedError("AbortError", "This operation was aborted") : reason;
+      // workerd's default reason reads "The operation was aborted" (from 2026-10-23 here).
+      const message = globalThis.__sbCompat >= "2026-10-23" ? "The operation was aborted" : "This operation was aborted";
+      this.reason = reason === undefined ? namedError("AbortError", message) : reason;
       const event = new Event("abort");
       if (typeof this.onabort === "function") this.onabort.call(this, event);
       this.dispatchEvent(event);
@@ -5229,7 +5240,7 @@ globalThis.__sbInstallBindings = function (target, bindings) {
       fetch(input, init) {
         if (globalThis.__sbCompat >= "2026-10-22") return __sbServiceFetch(binding, input, init);
         const parts = __sbFetchParts(input, init);
-        const msg = { binding, url: parts.url, method: parts.method, headers: parts.headers, ...__sbRequestBody(parts.body) };
+        const msg = { binding, url: parts.url, method: parts.method, headers: parts.headers, ...__sbPartsBody(parts) };
         return __sbUpstreamResponse(globalThis.__sbFetchUpstream("service.fetch", msg));
       },
     };
@@ -5251,9 +5262,9 @@ async function __sbServiceFetch(binding, input, init) {
   const parts = __sbFetchParts(input, init);
   if (parts.signal) parts.signal.throwIfAborted();
   // A stream body is read to the end first: the wire carries a whole body.
-  let body = __sbUnwrapBody(parts.body);
-  if (body instanceof ReadableStream) body = await __sbCollectBody(body);
-  const msg = { binding, url: parts.url, method: parts.method, headers: parts.headers, ...__sbRequestBody(body) };
+  const body = __sbUnwrapBody(parts.body);
+  const wire = body instanceof ReadableStream ? __sbRequestBody(await __sbCollectBody(body)) : __sbPartsBody({ ...parts, body });
+  const msg = { binding, url: parts.url, method: parts.method, headers: parts.headers, ...wire };
   const response = await __sbFetchFollowing("service.fetch", msg, "sproutboat service " + binding, parts.redirect, parts.signal);
   // The callee threw: as in workerd, its error is thrown here.
   const uncaught = response.headers.get("x-sb-uncaught");
@@ -5436,7 +5447,29 @@ async function __sbRpcDispatch(handlers, receiver, method, request) {
 
 // fetch(input, init) as Fetch reads it: a Request's method, headers, body, redirect mode
 // and signal apply unless init overrides them; a URL object stands for its href.
+// From compatibility date 2026-10-23 it is Fetch's own first step, `new Request(input,
+// init)`, as in workerd: the input Request's body is used up (a second fetch of it
+// throws), a Request given as init brings its body, GET and HEAD refuse a body, and the
+// method and redirect mode are checked. Before it, the parts are read off the input.
 function __sbFetchParts(input, init) {
+  if (globalThis.__sbCompat >= "2026-10-23") {
+    const request = new Request(input, init);
+    const headers = [];
+    request.headers.forEach((v, k) => headers.push([k, v]));
+    const body = request._bodyStream != null ? request._bodyStream : request._bodyInit;
+    // A stream the runtime made over a value is sent as that value, unread: it is used
+    // all the same, so a Request that gave it (as input or as init) reads as used.
+    if (body instanceof ReadableStream && body._sbBody !== undefined) body._disturbed = true;
+    return {
+      url: request.url,
+      method: request.method,
+      headers,
+      body: body === undefined ? null : body,
+      latin1: request._bodyLatin1 === true,
+      redirect: request.redirect,
+      signal: request._signal || null,
+    };
+  }
   const req = input != null && !__sbIsStr(input) && input.url != null ? input : null;
   const url = req ? String(req.url) : input != null && input.href != null ? String(input.href) : String(input);
   const opts = init || {};
@@ -5449,8 +5482,17 @@ function __sbFetchParts(input, init) {
   const body = opts.body !== undefined && !(opts instanceof Request) ? opts.body : req && __sbRawBody(req) !== "" ? __sbRawBody(req) : null;
   const method = opts.method || (req && req.method) || "GET";
   const redirect = opts.redirect || (req && req.redirect) || "follow";
-  const signal = opts.signal || (req && req.signal) || null;
-  return { url, method, headers, body, redirect, signal };
+  const signal = opts.signal || (req && req._signal) || null;
+  // An incoming request's body is its raw bytes, one character each: sent as bytes.
+  const latin1 = body != null && opts.body === undefined && req !== null && req._bodyLatin1 === true;
+  return { url, method, headers, body, latin1, redirect, signal };
+}
+
+// The wire fields of a fetch body (see __sbRequestBody). Raw ingress bytes go as bytes,
+// not as text encoded again.
+function __sbPartsBody(parts) {
+  if (parts.latin1 === true && __sbIsStr(parts.body)) return { body: parts.body, bodyBinary: true };
+  return __sbRequestBody(parts.body);
 }
 
 // An upstream reply (fetch or service.fetch) -> a Response. Headers are appended,
@@ -5469,7 +5511,7 @@ function __sbUpstreamResponse(r) {
   if (r.body != null) respHeaders.set("x-sb-raw-body", "1");
   const response = __sbRawBodyResponse(r.body, { status: r.status || 502, headers: respHeaders });
   if (!typed) response.headers.delete("content-type");
-  return response;
+  return __sbFreezeHeaders(response);
 }
 
 // A streamed upstream response (from compatibility date 2026-10-22, with the other
@@ -5520,7 +5562,7 @@ function __sbUpstreamStreamed(op, msg, label, signal) {
             __sbCancelAsync(id);
           },
         });
-        resolve(new Response(body, { status: reply.status || 502, headers }));
+        resolve(__sbFreezeHeaders(new Response(body, { status: reply.status || 502, headers })));
         return;
       }
       const frame = JSON.parse(raw);
@@ -5645,9 +5687,23 @@ function __sbUpstream(op, msg, label, signal, always) {
 // prelude must not replace fetch just by being evaluated.
 globalThis.__sbInstallFetch = function () {
   globalThis.fetch = function (input, init) {
-    const parts = __sbFetchParts(input, init);
-    const msg = { url: parts.url, method: parts.method, headers: parts.headers, ...__sbRequestBody(parts.body) };
-    return __sbFetchFollowing("fetch", msg, "sproutboat fetch", parts.redirect, parts.signal);
+    let parts;
+    try {
+      parts = __sbFetchParts(input, init);
+    } catch (error) {
+      // From 2026-10-23 an invalid request rejects, as in workerd; before it, it threw.
+      if (globalThis.__sbCompat >= "2026-10-23") return Promise.reject(error);
+      throw error;
+    }
+    const send = (body) => {
+      const msg = { url: parts.url, method: parts.method, headers: parts.headers, ...body };
+      return __sbFetchFollowing("fetch", msg, "sproutboat fetch", parts.redirect, parts.signal);
+    };
+    // A stream body is read to the end first, as for a service binding: the wire carries a
+    // whole body. It was sent as the text "[object ReadableStream]".
+    const stream = __sbUnwrapBody(parts.body);
+    if (stream instanceof ReadableStream) return __sbCollectBody(stream).then((bytes) => send(__sbRequestBody(bytes)));
+    return send(__sbPartsBody(parts));
   };
 };
 
@@ -5691,7 +5747,11 @@ function __sbMakeDONamespace(binding, className) {
       return {
         fetch(input, init) {
           let req;
-          if (__sbIsObj(input) && __sbIsStr(input.url) && !init) {
+          // From 2026-10-23 the object gets the Request Fetch makes of input and init, as in
+          // workerd: method, headers and body survive, and the input's body is used up.
+          if (globalThis.__sbCompat >= "2026-10-23") {
+            req = new Request(input, init);
+          } else if (__sbIsObj(input) && __sbIsStr(input.url) && !init) {
             req = input;
           } else {
             const url = __sbIsStr(input) ? input : String((input && input.url) || "https://do/");
@@ -6101,6 +6161,8 @@ function __sbStreamingSupported() {
 function __sbStreamResponse(response) {
   const stream = __sbRawBody(response);
   const id = __sbStreamOp("o", "0", "");
+  // A fetched response returned as it is has immutable headers; this mark is ours.
+  response.headers._immutable = false;
   response.headers.set("x-sb-stream", id);
   response.body = "";
   (async () => {
@@ -6227,6 +6289,12 @@ async function __sbQueueWithDrain(result, tasks) {
 function __sbDecodeIngress(request) {
   const raw = __sbRawBody(request);
   if (raw == null) return;
+  // A GET or HEAD has no body, as in workerd (from 2026-10-23): request.body is null, and
+  // new Request(request) copies none. Before it, the body is the empty string.
+  if (raw === "" && (request.method === "GET" || request.method === "HEAD") && globalThis.__sbCompat >= "2026-10-23") {
+    request.body = null;
+    return;
+  }
   // Raw bytes, one character each: arrayBuffer(), blob() and body read them as bytes.
   request._bodyLatin1 = true;
   let decoded = null;
@@ -6258,6 +6326,8 @@ globalThis.__sbEntry = function (handlers, request) {
     const __tlsCipher = __sbTrustedProxyHeader(request, "x-sb-tls-cipher");
     if (__tlsCipher) __cf.tlsCipher = __tlsCipher;
     request.cf = __cf;
+    // The edge's headers are gone: from 2026-10-23 the handler cannot change the rest.
+    __sbFreezeHeaders(request);
     // #28 — per-invocation CPU time. One fetch turn per process (serial), so the
     // process CPU delta across the handler is this invocation's CPU.
     // ponytail: serial-turn assumption; revisit if the profile ever allows

package/test/native-fetch-request.ts

@@ -0,0 +1,305 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { ensurePorffor } from "../../toolchain/src/acquire";
+import { createBroker, listen } from "../../wire/src/broker";
+import { EMPTY_BINDINGS, preludePath, TRANSPORT_MARKER, transportPath, wrapNativeFetchHandler } from "../src/wrap";
+
+// fetch(Request), fetch(Request, init) and new Request(request, init) on a compiled sprout,
+// through the broker transport, against what workerd does (the platform's
+// tests/service-bindings suite holds workerd's answers). The same handler is compiled at
+// compatibility date 2026-10-23, where Request follows Fetch as workerd does, and at
+// 2026-10-22, where an app keeps the older behaviour: a copied Request shares its body,
+// headers stay mutable and any method name passes.
+const handler = `
+const textStream = (...parts) =>
+  new ReadableStream({
+    start(c) {
+      for (const p of parts) c.enqueue(new TextEncoder().encode(p));
+      c.close();
+    },
+  });
+const attempt = async (step) => {
+  try {
+    return await step();
+  } catch (e) {
+    return e.name + ": " + e.message;
+  }
+};
+
+export default {
+  async fetch(request, env) {
+    const url = new URL(request.url);
+    const up = url.searchParams.get("up");
+    const echo = async (res) => res.json();
+    if (url.pathname === "/ping") return new Response("pong");
+    if (url.pathname === "/fetch") {
+      const viaRequest = await echo(await fetch(new Request(up + "/echo", { method: "PUT", headers: { "x-from": "request" }, body: "req body" })));
+      const plusInit = await echo(
+        await fetch(new Request(up + "/echo", { method: "PUT", headers: { "x-from": "request" }, body: "req body" }), { method: "PATCH", headers: { "x-from": "init" } }),
+      );
+      const initBody = await echo(await fetch(new Request(up + "/echo", { method: "PUT", body: "req body" }), { body: "init body" }));
+      const stream = await echo(await fetch(new Request(up + "/echo", { method: "POST", body: textStream("in ", "a request"), duplex: "half" })));
+      const initStream = await echo(await fetch(up + "/echo", { method: "POST", body: textStream("in ", "init"), duplex: "half" }));
+      const initRequest = new Request("https://other/", { method: "POST", headers: { "x-from": "init-request" }, body: "init req" });
+      const asInit = { ...(await echo(await fetch(up + "/echo", initRequest))), initUsed: initRequest.bodyUsed };
+      const manual = (await fetch(new Request(up + "/redirect", { redirect: "manual" }))).status;
+      const aborted = await attempt(() => fetch(new Request(up + "/echo", { signal: AbortSignal.abort() })).then((r) => r.status));
+      const once = new Request(up + "/echo", { method: "POST", body: "once" });
+      const first = (await echo(await fetch(once))).body;
+      const usedUp = once.bodyUsed;
+      const again = await attempt(() => fetch(once).then(echo).then((e) => e.body));
+      const getBody = await attempt(() => fetch(up + "/echo", { body: "x" }).then((r) => r.status));
+      return Response.json({ viaRequest, plusInit, initBody, stream, initStream, asInit, manual, aborted, first, usedUp, again, getBody });
+    }
+    if (url.pathname === "/forward") {
+      // The incoming request's raw bytes reach the upstream intact.
+      const copied = await echo(await fetch(new Request(up + "/echo", request)));
+      return Response.json({ copied, incomingUsed: request.bodyUsed });
+    }
+    if (url.pathname === "/request") {
+      const a = new Request("https://peer/a", { method: "POST", headers: { "x-a": "1" }, body: "abc" });
+      const b = new Request(a, { headers: { "x-b": "2" } });
+      const copy = { aUsed: a.bodyUsed, aRead: await attempt(() => a.text()), b: await b.text(), headers: [...b.headers] };
+      const s = new Request("https://peer/s", { method: "POST", body: textStream("tee ", "me"), duplex: "half" });
+      const t = s.clone();
+      const tee = [await t.text(), await s.text()];
+      const controller = new AbortController();
+      const signalled = new Request(new Request("https://peer/", { signal: controller.signal }));
+      controller.abort();
+      const res = await fetch(url.searchParams.get("up") + "/echo");
+      await res.text();
+      return Response.json({
+        copy,
+        tee,
+        signal: [signalled.signal.aborted, new Request("https://peer/").signal.aborted],
+        getBody: await attempt(() => new Request("https://peer/", { body: "" }).method),
+        method: await attempt(() => new Request("https://peer/", { method: "custom" }).method),
+        redirect: await attempt(() => new Request("https://peer/", { redirect: "error" }).redirect),
+        incoming: await attempt(() => (request.headers.set("x-t", "1"), "mutable")),
+        fetched: await attempt(() => (res.headers.set("x-t", "1"), "mutable")),
+        copiedResponse: await attempt(() => (new Response(null, res).headers.set("x-t", "1"), "mutable")),
+        incomingBody: request.body === null ? "none" : typeof request.body,
+      });
+    }
+    return new Response("no route", { status: 404 });
+  },
+};
+`;
+
+function freePort(): number {
+  const listener = Bun.listen({ hostname: "127.0.0.1", port: 0, socket: { data() {} } });
+  const port = listener.port;
+  listener.stop(true);
+  return port;
+}
+
+const upstream = Bun.serve({
+  hostname: "127.0.0.1",
+  port: 0,
+  async fetch(request) {
+    const url = new URL(request.url);
+    if (url.pathname === "/redirect") return new Response(null, { status: 302, headers: { location: "/echo?hop=1" } });
+    const bytes = new Uint8Array(await request.arrayBuffer());
+    let binaryIntact = bytes.length === 256;
+    for (let i = 0; binaryIntact && i < 256; i++) binaryIntact = bytes[i] === i;
+    return Response.json({
+      method: request.method,
+      from: request.headers.get("x-from"),
+      type: request.headers.get("content-type"),
+      body: binaryIntact ? "bytes 0-255" : new TextDecoder().decode(bytes),
+    });
+  },
+});
+const up = `http://127.0.0.1:${upstream.port}`;
+const workdir = await mkdtemp(join(tmpdir(), "sb-native-fetch-request-"));
+const broker = createBroker({
+  db: ":memory:",
+  token: "native-fetch-request",
+  bindings: { ...EMPTY_BINDINGS, resources: {} },
+  egressAllow: ["127.0.0.1"],
+});
+const brokerServer = listen(broker, "127.0.0.1", 0);
+const servers: ReturnType<typeof Bun.spawn>[] = [];
+
+// Compiles the handler at `date` and starts it; resolves to a GET helper for it.
+async function start(porffor: string, node: string, source: string, date: string) {
+  const port = freePort();
+  const generated = join(workdir, `fetch-request-${date}.generated.js`);
+  const binary = join(workdir, `fetch-request-${date}`);
+  await writeFile(generated, wrapNativeFetchHandler(handler, source, {}, EMPTY_BINDINGS, undefined, date));
+  const compile = Bun.spawn(
+    [node, resolve(porffor, "runtime/index.js"), "native", generated, "-o", binary, "-s", "-O0"],
+    {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe",
+    },
+  );
+  const [exitCode, stderr] = await Promise.all([compile.exited, new Response(compile.stderr).text()]);
+  assert.equal(exitCode, 0, `Porffor native compile at ${date} failed:\n${stderr}`);
+  const server = Bun.spawn([binary], {
+    cwd: workdir,
+    env: {
+      ...process.env,
+      PORT: String(port),
+      SB_BROKER_PORT: String(brokerServer.port),
+      SB_BROKER_TOKEN: "native-fetch-request",
+    },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  servers.push(server);
+  const call = async (path: string, init?: RequestInit) => {
+    const sep = path.includes("?") ? "&" : "?";
+    const res = await fetch(`http://127.0.0.1:${port}${path}${sep}up=${encodeURIComponent(up)}`, {
+      ...init,
+      signal: AbortSignal.timeout(20_000),
+    });
+    const text = await res.text();
+    assert.equal(res.status, 200, `${date} ${path}: ${text}`);
+    return JSON.parse(text);
+  };
+  for (let i = 0; i < 50; i++) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/ping`);
+      if ((await res.text()) === "pong") return call;
+    } catch {
+      if (server.exitCode !== null) break;
+      await Bun.sleep(100);
+    }
+  }
+  throw new Error(`compiled handler at ${date} did not start`);
+}
+
+try {
+  const porffor = await ensurePorffor({ cacheRoot: workdir });
+  const node = Bun.which("node");
+  if (!node) throw new Error("native fetch-request test needs node on PATH");
+  const [core, transport] = await Promise.all([
+    readFile(preludePath, "utf8"),
+    readFile(transportPath("broker"), "utf8"),
+  ]);
+  assert(core.includes(TRANSPORT_MARKER), "runtime prelude is missing its transport marker");
+  const source = core.replace(TRANSPORT_MARKER, transport);
+  const [strict, legacy] = await Promise.all([
+    start(porffor, node, source, "2026-10-23"),
+    start(porffor, node, source, "2026-10-22"),
+  ]);
+
+  const echo = (method: string, from: string | null, type: string | null, body: string) => ({
+    method,
+    from,
+    type,
+    body,
+  });
+  const plain = "text/plain;charset=UTF-8";
+  const bytes = new Uint8Array(256).map((_, i) => i);
+
+  // From 2026-10-23: fetch() is fetch(new Request(input, init)), as in workerd.
+  assert.deepEqual(await strict("/fetch"), {
+    viaRequest: echo("PUT", "request", plain, "req body"),
+    plusInit: echo("PATCH", "init", null, "req body"),
+    initBody: echo("PUT", null, plain, "init body"),
+    stream: echo("POST", null, null, "in a request"),
+    initStream: echo("POST", null, null, "in init"),
+    asInit: { ...echo("POST", "init-request", plain, "init req"), initUsed: true },
+    manual: 302,
+    aborted: "AbortError: The operation was aborted",
+    first: "once",
+    usedUp: true,
+    again: "TypeError: Cannot reconstruct a Request with a used body.",
+    getBody: "TypeError: Request with a GET or HEAD method cannot have a body.",
+  });
+  assert.deepEqual(await strict("/forward", { method: "POST", body: bytes, headers: { "x-from": "client" } }), {
+    copied: echo("POST", "client", null, "bytes 0-255"),
+    incomingUsed: true,
+  });
+  assert.deepEqual(await strict("/request"), {
+    copy: {
+      aUsed: true,
+      aRead:
+        "TypeError: Body has already been used. It can only be used once. Use tee() first if you need to read it twice.",
+      b: "abc",
+      headers: [["x-b", "2"]],
+    },
+    tee: ["tee me", "tee me"],
+    signal: [true, false],
+    getBody: "TypeError: Request with a GET or HEAD method cannot have a body.",
+    method: "TypeError: Invalid HTTP method string: custom",
+    redirect:
+      '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).',
+    incoming: "TypeError: Can't modify immutable headers.",
+    fetched: "TypeError: Can't modify immutable headers.",
+    copiedResponse: "mutable",
+    incomingBody: "none",
+  });
+
+  // Before it: the Request's method, headers and body still reach the upstream (fixed at
+  // every date, as are stream bodies and raw bytes), but a Request can be sent twice, a
+  // copy leaves the source readable, and headers, methods and redirect modes are not checked.
+  const old = await legacy("/fetch");
+  assert.deepEqual(
+    {
+      viaRequest: old.viaRequest,
+      plusInit: old.plusInit,
+      stream: old.stream,
+      initStream: old.initStream,
+      manual: old.manual,
+      again: old.again,
+    },
+    {
+      viaRequest: echo("PUT", "request", plain, "req body"),
+      plusInit: echo("PATCH", "init", null, "req body"),
+      stream: echo("POST", null, null, "in a request"),
+      initStream: echo("POST", null, null, "in init"),
+      manual: 302,
+      again: "once",
+    },
+  );
+  assert.deepEqual(await legacy("/forward", { method: "POST", body: bytes, headers: { "x-from": "client" } }), {
+    copied: echo("POST", "client", null, "bytes 0-255"),
+    incomingUsed: false,
+  });
+  const oldRequest = await legacy("/request");
+  assert.deepEqual(
+    {
+      aUsed: oldRequest.copy.aUsed,
+      aRead: oldRequest.copy.aRead,
+      tee: oldRequest.tee,
+      signal: oldRequest.signal,
+      method: oldRequest.method,
+      redirect: oldRequest.redirect,
+      incoming: oldRequest.incoming,
+      fetched: oldRequest.fetched,
+      incomingBody: oldRequest.incomingBody,
+    },
+    {
+      aUsed: false,
+      aRead: "abc",
+      tee: ["tee me", "tee me"],
+      signal: [true, false],
+      method: "CUSTOM",
+      redirect: "error",
+      incoming: "mutable",
+      fetched: "mutable",
+      incomingBody: "object",
+    },
+  );
+
+  console.log(
+    "fetch(Request) and new Request(request, init) follow workerd from 2026-10-23 (body used up, init merging, " +
+      "GET/HEAD bodies, methods, redirect modes, signals, immutable headers); stream bodies, clone() tees and raw bytes at every date; " +
+      "2026-10-22 keeps the older Request semantics",
+  );
+} finally {
+  for (const server of servers) {
+    server.kill(9);
+    await server.exited;
+  }
+  brokerServer.stop();
+  broker.close();
+  upstream.stop(true);
+  await rm(workdir, { recursive: true, force: true });
+}