@sproutboat/runtime 0.22.0 → 0.23.1

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @sproutboat/runtime
 
+## 0.23.1
+
+### Patch Changes
+
+- 7a7fd34: D1 correctness fixes, in the standalone (embedded) transport and the broker:
+  
+  - **Bytes are no longer lost.** Binding a `Uint8Array`, another typed array, a `DataView` or an `ArrayBuffer` stored NULL in a standalone sprout, along with every parameter after it. It now stores a BLOB, at every compatibility date. On earlier dates a BLOB still reads back as before: as one character per byte.
+  - **`batch()` is one transaction** in a standalone sprout, as it already was through the broker and is in D1: if a statement fails, the ones before it are rolled back. This applies at every compatibility date.
+  - **From compatibility date `2026-10-24`**, D1 follows workerd's rules:
+    - a parameter must be `null`, a number, a string, a boolean or bytes, or the call throws `D1_TYPE_ERROR` (before, `undefined` and objects became NULL);
+    - the number of parameters must match the statement (`D1_ERROR: Wrong number of parameter bindings for SQL query.`);
+    - foreign keys are enforced (`PRAGMA foreign_keys = ON`);
+    - errors read `D1_ERROR: <message>: SQLITE_<CODE>`;
+    - a BLOB reads back as an array of byte values.
+  
+    Apps with an earlier `compatibility_date` keep the old behaviour. To opt in, move the date to `2026-10-24` or later and rebuild.
+  - `meta.changes` is 0 for a statement that only reads. It used to repeat the previous write's count.
+
+## 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.1",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/d1-shim.test.js

@@ -0,0 +1,114 @@
+// The D1 shim (`env.DB`) over the broker's D1 store (the production platform's path),
+// at a compatibility date before and after 2026-10-24. The embedded transport's half is
+// test/native-d1.ts.
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { createD1Store } from "../../wire/src/d1";
+
+const source = readFileSync(new URL("./native-fetch-prelude.js", import.meta.url), "utf8");
+let store;
+// oxlint-disable-next-line no-function-constructor -- the prelude is prepended as text in production too
+const { makeD1 } = new Function(
+  "Porffor",
+  "__testCall",
+  `${source}\n__sbCall = __testCall; return { makeD1: __sbMakeD1 };`,
+)({ c: () => "" }, (json) => {
+  const msg = JSON.parse(json);
+  try {
+    return JSON.stringify(store.execute({ owner: "app", key: "app/DB", path: ":memory:", name: "DB", msg }));
+  } catch (error) {
+    return JSON.stringify({ ok: false, error: error.message });
+  }
+});
+const fresh = (date) => {
+  globalThis.__sbCompat = date;
+  store?.close();
+  store = createD1Store();
+  return makeD1("DB");
+};
+const caught = (fn) => {
+  try {
+    fn();
+  } catch (error) {
+    return error.message;
+  }
+  return "did not throw";
+};
+
+for (const date of ["2026-09-28", "2026-10-24"]) {
+  test(`${date}: bytes bind as a BLOB, and the parameters after them are kept`, () => {
+    const DB = fresh(date);
+    DB.exec("CREATE TABLE t (a TEXT, b BLOB, c TEXT)");
+    DB.prepare("INSERT INTO t VALUES (?, ?, ?)")
+      .bind("u8", new Uint8Array([0, 255, 7]), "after")
+      .run();
+    DB.prepare("INSERT INTO t VALUES (?, ?, ?)")
+      .bind("ab", new Uint8Array([1, 2]).buffer, "after")
+      .run();
+    DB.prepare("INSERT INTO t VALUES (?, ?, ?)")
+      .bind("view", new DataView(new Uint8Array([9, 8, 7]).buffer, 1, 2), "after")
+      .run();
+    expect(DB.prepare("SELECT a, hex(b) AS h, typeof(b) AS t, c FROM t ORDER BY rowid").all().results).toEqual([
+      { a: "u8", h: "00FF07", t: "blob", c: "after" },
+      { a: "ab", h: "0102", t: "blob", c: "after" },
+      { a: "view", h: "0807", t: "blob", c: "after" },
+    ]);
+  });
+
+  test(`${date}: batch() is one transaction`, () => {
+    const DB = fresh(date);
+    DB.exec("CREATE TABLE t (id INTEGER PRIMARY KEY)");
+    expect(() => DB.batch([DB.prepare("INSERT INTO t VALUES (1)"), DB.prepare("INSERT INTO t VALUES (1)")])).toThrow(
+      /UNIQUE/,
+    );
+    expect(DB.prepare("SELECT count(*) AS n FROM t").first("n")).toBe(0);
+  });
+}
+
+test("before 2026-10-24: lenient parameters, no foreign keys, BLOBs as one char per byte", () => {
+  const DB = fresh("2026-09-28");
+  // (bun:sqlite has always refused a wrong parameter count here; the embedded transport has not.)
+  expect(DB.prepare("SELECT ?1 AS a").bind(undefined).first()).toEqual({ a: null });
+  DB.exec("CREATE TABLE p (id INTEGER PRIMARY KEY); CREATE TABLE c (p INTEGER REFERENCES p(id))");
+  DB.prepare("INSERT INTO c VALUES (99)").run();
+  expect(DB.prepare("SELECT x'00ff' AS b").first("b")).toBe("\u0000ÿ");
+  expect(caught(() => DB.prepare("SELEC 1").all())).toMatch(/^sproutboat d1\.query: /);
+});
+
+test("from 2026-10-24: D1's parameter rules", () => {
+  const DB = fresh("2026-10-24");
+  expect(caught(() => DB.prepare("SELECT ?1").bind(undefined))).toBe(
+    "D1_TYPE_ERROR: Type 'undefined' not supported for value 'undefined'",
+  );
+  expect(caught(() => DB.prepare("SELECT ?1").bind({ a: 1 }))).toBe(
+    "D1_TYPE_ERROR: Type 'object' not supported for value '[object Object]'",
+  );
+  expect(caught(() => DB.prepare("SELECT ?1").bind(10n))).toBe(
+    "D1_TYPE_ERROR: Type 'bigint' not supported for value '10'",
+  );
+  expect(caught(() => DB.prepare("SELECT ?1, ?2").bind(1).all())).toBe(
+    "D1_ERROR: Wrong number of parameter bindings for SQL query.",
+  );
+  expect(caught(() => DB.prepare("SELECT ?1").bind(1, 2).all())).toBe(
+    "D1_ERROR: Wrong number of parameter bindings for SQL query.",
+  );
+  expect(caught(() => DB.prepare("SELECT ?1").all())).toBe(
+    "D1_ERROR: Wrong number of parameter bindings for SQL query.",
+  );
+  expect(DB.prepare("SELECT ?1 AS a, ?1 AS b, ?2 AS c").bind("x", true).first()).toEqual({ a: "x", b: "x", c: 1 });
+});
+
+test("from 2026-10-24: foreign keys, BLOBs as byte arrays, D1's error text", () => {
+  const DB = fresh("2026-10-24");
+  DB.exec("CREATE TABLE p (id INTEGER PRIMARY KEY); CREATE TABLE c (p INTEGER REFERENCES p(id))");
+  expect(caught(() => DB.prepare("INSERT INTO c VALUES (99)").run())).toBe(
+    "D1_ERROR: FOREIGN KEY constraint failed: SQLITE_CONSTRAINT (extended: SQLITE_CONSTRAINT_FOREIGNKEY)",
+  );
+  DB.prepare("INSERT INTO p VALUES (1)").run();
+  expect(caught(() => DB.prepare("INSERT INTO p VALUES (1)").run())).toBe(
+    "D1_ERROR: UNIQUE constraint failed: p.id: SQLITE_CONSTRAINT (extended: SQLITE_CONSTRAINT_PRIMARYKEY)",
+  );
+  expect(caught(() => DB.prepare("SELECT * FROM nope").all())).toBe("D1_ERROR: no such table: nope: SQLITE_ERROR");
+  expect(DB.prepare("SELECT x'00ff' AS b").first("b")).toEqual([0, 255]);
+  expect(DB.prepare("SELECT count(*) AS n FROM p").run().meta.changes).toBe(0);
+});

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);
@@ -4798,17 +4809,80 @@ function __sbRpc(op, extra) {
 
 // D1: a Cloudflare-shaped `env.<DB>` (prepare / bind / all / run / raw / first,
 // plus batch and exec). Every call is one broker roundtrip.
+//
+// Bytes (an ArrayBuffer or a typed array) bind as a BLOB at every compatibility date:
+// before, they were stored as NULL. From compatibility date 2026-10-24 D1 calls are
+// strict, as in workerd: a parameter must be null, a number, a string, a boolean or
+// bytes (D1_TYPE_ERROR otherwise), the count must match the statement, foreign keys
+// are enforced, errors read "D1_ERROR: ...", and a BLOB comes back as an array of
+// byte values. Earlier dates keep the old behaviour.
+function __sbD1Strict() {
+  return globalThis.__sbCompat >= "2026-10-24";
+}
+function __sbD1Param(value, strict) {
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    let hex = "";
+    for (let i = 0; i < bytes.length; i++) hex += (bytes[i] < 16 ? "0" : "") + bytes[i].toString(16);
+    return { $blob: hex };
+  }
+  if (!strict || value === null || value === true || value === false || Object(value) instanceof Number || __sbIsStr(value)) return value;
+  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- workerd's D1_TYPE_ERROR names the value's typeof
+  throw new Error("D1_TYPE_ERROR: Type '" + typeof value + "' not supported for value '" + String(value) + "'");
+}
+function __sbD1Rpc(op, extra, strict) {
+  if (!strict) return __sbRpc(op, extra);
+  extra.strict = true;
+  try {
+    return __sbRpc(op, extra);
+  } catch (err) {
+    // "sproutboat d1.query: D1_ERROR: ..." -> "D1_ERROR: ...", as workerd words it.
+    const message = String((err && err.message) || err);
+    const at = message.indexOf("D1_");
+    throw new Error(at > 0 ? message.slice(at) : message);
+  }
+}
+// Strict replies carry columns and rows; build workerd's result objects from them.
+function __sbD1Rows(r) {
+  const rows = r.rows || [];
+  for (let i = 0; i < rows.length; i++)
+    for (let c = 0; c < rows[i].length; c++) {
+      const cell = rows[i][c];
+      if (__sbIsObj(cell) && __sbIsStr(cell.$blob)) {
+        const out = [];
+        for (let k = 0; k + 1 < cell.$blob.length; k += 2) out.push(parseInt(cell.$blob.slice(k, k + 2), 16));
+        rows[i][c] = out;
+      }
+    }
+  return rows;
+}
+function __sbD1Objects(columns, rows) {
+  const out = [];
+  for (let i = 0; i < rows.length; i++) {
+    const row = {};
+    for (let c = 0; c < columns.length; c++) row[columns[c]] = rows[i][c];
+    out.push(row);
+  }
+  return out;
+}
+function __sbD1Result(r, strict) {
+  if (!strict) return { results: r.results || [], success: true, meta: r.meta || {} };
+  return { results: __sbD1Objects(r.columns || [], __sbD1Rows(r)), success: true, meta: r.meta || {} };
+}
 function __sbMakeD1(dbName) {
   function stmt(sql, params) {
     const s = {
       __sql: sql,
       __params: params,
       bind() {
-        return stmt(sql, Array.prototype.slice.call(arguments));
+        const strict = __sbD1Strict();
+        const list = [];
+        for (let i = 0; i < arguments.length; i++) list.push(__sbD1Param(arguments[i], strict));
+        return stmt(sql, list);
       },
       all() {
-        const r = __sbRpc("d1.query", { db: dbName, sql, params });
-        return { results: r.results || [], success: true, meta: r.meta || {} };
+        const strict = __sbD1Strict();
+        return __sbD1Result(__sbD1Rpc("d1.query", { db: dbName, sql, params }, strict), strict);
       },
       run() {
         return s.all();
@@ -4836,17 +4910,17 @@ function __sbMakeD1(dbName) {
       return stmt(String(sql), []);
     },
     batch(statements) {
+      const strict = __sbD1Strict();
       const list = [];
       for (let i = 0; i < (statements || []).length; i++)
         list.push({ sql: statements[i].__sql, params: statements[i].__params });
-      const r = __sbRpc("d1.batch", { db: dbName, statements: list });
+      const r = __sbD1Rpc("d1.batch", { db: dbName, statements: list }, strict);
       const out = [];
-      for (let i = 0; i < (r.results || []).length; i++)
-        out.push({ results: r.results[i].results || [], success: true, meta: r.results[i].meta || {} });
+      for (let i = 0; i < (r.results || []).length; i++) out.push(__sbD1Result(r.results[i], strict));
       return out;
     },
     exec(sql) {
-      __sbRpc("d1.exec", { db: dbName, sql: String(sql) });
+      __sbD1Rpc("d1.exec", { db: dbName, sql: String(sql) }, __sbD1Strict());
       return { count: (String(sql).match(/;/g) || []).length, duration: 0 };
     },
     // Sproutboat extension (not in CF Workers D1): an online, integrity-checked
@@ -5229,7 +5303,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 +5325,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 +5510,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 +5545,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 +5574,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 +5625,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 +5750,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 +5810,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 +6224,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 +6352,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 +6389,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