@sproutboat/runtime 0.20.0 → 0.21.1

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # @sproutboat/runtime
 
+## 0.21.1
+
+### Patch Changes
+
+- 98800ca: The asynchronous `fetch()` and service-binding behaviour from 0.20.0 now starts at compatibility date `2026-10-22`. Before, it applied at every date, which broke apps that use the result without `await`, such as the CLI's kitchen-sink: `const r = fetch(url); r.body`.
+  
+  From `2026-10-22`, in a deployed sprout:
+  
+  - `fetch()` and `env.SERVICE.fetch()` return promises and run off the event loop;
+  - responses stream;
+  - redirects are followed;
+  - a callee's error is thrown in the caller;
+  - a callee sees its caller's URL.
+  
+  With an earlier `compatibility_date`, a deployed sprout's `fetch()` and binding calls answer at once with a `Response`, as they did before 0.20.0. To get the new behaviour, move `compatibility_date` to `2026-10-22` and rebuild.
+  
+  These stay ungated:
+  
+  - sproutd answered with promises at every date, and still does;
+  - RPC calls are always asynchronous;
+  - abort signals, `Set-Cookie` and `Content-Type` work at every date.
+
+## 0.21.0
+
+### Minor Changes
+
+- 6f253b9: Service bindings support Workers RPC.
+  
+  **Callee.** A deployment whose default export extends `WorkerEntrypoint`, imported from `cloudflare:workers`, exposes its methods:
+  
+  - `env.SERVICE.add(2, 3)` runs `add(2, 3)` on a fresh instance, with `this.env` and `this.ctx` set, and resolves to its result.
+  - Arguments and results are copied as structured clone does: `undefined`, `NaN`, `-0`, `Date`, `RegExp`, binary data, `Map`, `Set` and errors survive the trip.
+  - An error the method throws rejects the call with the same class and message.
+  - An unknown method rejects with workerd's `TypeError`.
+  - Passing functions or RPC stubs is not supported yet.
+  
+  **Where it works.** RPC travels over the service-binding calls a platform edge vouches for, so no client can invoke a method.
+  
+  **Imports.** `cloudflare:workers` provides `WorkerEntrypoint`, `DurableObject`, `RpcTarget` and `env`. The runtime turns the import into globals, so a handler that imports it runs both bundled and as plain ESM.
+  
+  **Default exports.**
+  - A class default export is instantiated per request, for `fetch`, `scheduled` and `queue`.
+  - A `WorkerEntrypoint` may have no `fetch` at all.
+
+### Patch Changes
+
+- 581c2f4: `atob()` and `btoa()` give the right result for any string. They used Porffor's own implementations, which read how a string is stored, so they went wrong on strings held as UTF-16, such as ones from `JSON.parse` or `TextDecoder`:
+  
+  - `atob(JSON.parse('"AQL/"'))` returned two wrong bytes instead of `01 02 ff`;
+  - `btoa` of a parsed `"héllo"` encoded the UTF-16 storage.
+  
+  Both are now plain JavaScript, with the same validation and errors as before.
+
 ## 0.20.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.20.0",
+  "version": "0.21.1",
   "license": "MIT",
   "type": "module",
   "repository": {

package/src/native-fetch-prelude.js

@@ -3594,18 +3594,53 @@ if (globalThis.crypto.getRandomValues == null) {
       Promise.resolve().then(() => callback());
     };
   }
-  const nativeAtob = globalThis.atob, nativeBtoa = globalThis.btoa;
+  // Base64 in JavaScript rather than Porffor's atob/btoa: those read a string's storage,
+  // so a string held as UTF-16 (one from JSON.parse or TextDecoder, say) decoded to the
+  // wrong bytes, and btoa encoded its UTF-16 units.
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
   globalThis.atob = function (data) {
     let text = String(data).replace(/[\t\n\f\r ]/g, "");
     if (text.length % 4 === 0) text = text.replace(/==?$/, "");
     if (text.length % 4 === 1 || !/^[A-Za-z0-9+/]*$/.test(text)) throw invalidCharacter("atob: the string is not valid base64");
-    while (text.length % 4 !== 0) text += "=";
-    return nativeAtob(text);
+    const parts = [];
+    let chunk = "";
+    let bits = 0;
+    let count = 0;
+    for (let i = 0; i < text.length; i++) {
+      bits = (bits << 6) | alphabet.indexOf(text[i]);
+      count += 6;
+      if (count >= 8) {
+        count -= 8;
+        chunk += String.fromCharCode((bits >> count) & 0xff);
+        if (chunk.length === 512) {
+          parts.push(chunk);
+          chunk = "";
+        }
+      }
+    }
+    parts.push(chunk);
+    return parts.join("");
   };
   globalThis.btoa = function (data) {
     const text = String(data);
-    for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) > 0xff) throw invalidCharacter("btoa: the string has characters outside Latin-1");
-    return nativeBtoa(text);
+    const parts = [];
+    let chunk = "";
+    for (let i = 0; i < text.length; i += 3) {
+      const a = text.charCodeAt(i);
+      const b = i + 1 < text.length ? text.charCodeAt(i + 1) : 0;
+      const c = i + 2 < text.length ? text.charCodeAt(i + 2) : 0;
+      if (a > 0xff || b > 0xff || c > 0xff) throw invalidCharacter("btoa: the string has characters outside Latin-1");
+      const n = (a << 16) | (b << 8) | c;
+      chunk += alphabet[(n >> 18) & 63] + alphabet[(n >> 12) & 63];
+      chunk += i + 1 < text.length ? alphabet[(n >> 6) & 63] : "=";
+      chunk += i + 2 < text.length ? alphabet[n & 63] : "=";
+      if (chunk.length >= 512) {
+        parts.push(chunk);
+        chunk = "";
+      }
+    }
+    parts.push(chunk);
+    return parts.join("");
   };
 }
 
@@ -5183,30 +5218,49 @@ globalThis.__sbInstallBindings = function (target, bindings) {
 
   // #48 — worker-to-worker. Same wire shape as outbound fetch, but the broker
   // resolves the target itself and forwards it internally, so this is not
-  // egress and is not subject to the private-address block. Always a promise, as
-  // in Workers; on an async host the caller keeps serving while the call runs,
-  // which is also what lets a deployment call itself without deadlocking.
+  // egress and is not subject to the private-address block. From compatibility date
+  // 2026-10-22 a promise, as in Workers: on an async host the caller keeps serving
+  // while the call runs, which is also what lets a deployment call itself without
+  // deadlocking. Before it, the Response comes back at once, as it always did, so a
+  // handler that uses it without awaiting keeps working.
   for (let i = 0; i < (bindings.services || []).length; i++) {
     const binding = bindings.services[i].binding;
-    target[binding] = {
-      async fetch(input, init) {
+    const fetcher = {
+      fetch(input, init) {
+        if (globalThis.__sbCompat >= "2026-10-22") return __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 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");
-        if (uncaught != null) throw __sbRemoteError(uncaught);
-        return response;
+        const msg = { binding, url: parts.url, method: parts.method, headers: parts.headers, ...__sbRequestBody(parts.body) };
+        return __sbUpstreamResponse(globalThis.__sbFetchUpstream("service.fetch", msg));
       },
     };
+    // Any other name is an RPC method of the callee's WorkerEntrypoint (see __sbRpcCall).
+    // "then" stays undefined, so awaiting the binding itself is not a call.
+    target[binding] = new Proxy(fetcher, {
+      get(t, prop) {
+        if (prop in t) return t[prop];
+        if (!__sbIsStr(prop) || prop === "then") return undefined;
+        return (...args) => __sbRpcCall(binding, prop, args);
+      },
+    });
   }
-
 };
 
+// A service-binding fetch from compatibility date 2026-10-22: a promise, off the event
+// loop on an async host, following redirects, and throwing the callee's error.
+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 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");
+  if (uncaught != null) throw __sbRemoteError(uncaught);
+  return response;
+}
+
 // The error a service-binding callee threw, from its x-sb-uncaught marker: the same
 // standard class where there is one, else an Error with the original name.
 function __sbRemoteError(marker) {
@@ -5229,6 +5283,157 @@ function __sbRemoteError(marker) {
   return error;
 }
 
+// Workers RPC (cloudflare:workers). A service binding's methods other than fetch() call
+// the callee's WorkerEntrypoint: env.SVC.add(1, 2) runs `add(1, 2)` on an instance of
+// the callee's default export and resolves to what it returns. The call travels as a
+// service-binding request the platform's edge vouched for (x-sb-rpc names the method),
+// so no client can invoke a method. Arguments and results are copied as structured
+// clone does (__sbRpcEncode); functions and RPC stubs are not supported yet. An error
+// the method throws rejects the call with the same class and message, as fetch does.
+if (globalThis.WorkerEntrypoint == null) {
+  class WorkerEntrypoint {
+    constructor(ctx, env) {
+      this.ctx = ctx;
+      this.env = env;
+    }
+  }
+  class DurableObject {
+    constructor(ctx, env) {
+      this.ctx = ctx;
+      this.env = env;
+    }
+  }
+  class RpcTarget {}
+  globalThis.WorkerEntrypoint = WorkerEntrypoint;
+  globalThis.DurableObject = DurableObject;
+  globalThis.RpcTarget = RpcTarget;
+}
+
+// A value -> JSON that keeps what structured clone keeps: undefined, NaN, ±Infinity
+// and -0, Dates, RegExps, binary data, Maps, Sets and Errors are tagged ("$"); a plain
+// object that has its own "$" key is wrapped so it is not read as a tag.
+function __sbRpcEncode(value) {
+  if (value === undefined) return { $: "u" };
+  if (value === null || __sbIsStr(value) || value === true || value === false) return value;
+  // Number.isNaN is true only for NaN itself; strings and booleans returned above.
+  if (Number.isNaN(value)) return { $: "n", v: "NaN" };
+  if (value === Number(value)) {
+    if (value === Infinity) return { $: "n", v: "Infinity" };
+    if (value === -Infinity) return { $: "n", v: "-Infinity" };
+    if (value === 0 && 1 / value < 0) return { $: "n", v: "-0" };
+    return value;
+  }
+  if (__sbIsFn(value)) {
+    throw new TypeError("Could not serialize a function for an RPC call: passing functions is not supported yet.");
+  }
+  if (Array.isArray(value)) return value.map(__sbRpcEncode);
+  if (value instanceof Date) return { $: "d", v: value.getTime() };
+  if (value instanceof RegExp) return { $: "r", s: value.source, f: value.flags };
+  if (value instanceof ArrayBuffer) return { $: "ab", v: btoa(__sbToBytes(new Uint8Array(value))) };
+  if (ArrayBuffer.isView(value)) {
+    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    return { $: "ta", t: value.constructor.name, v: btoa(__sbToBytes(bytes)) };
+  }
+  if (value instanceof Map) {
+    const entries = [];
+    value.forEach((v, k) => entries.push([__sbRpcEncode(k), __sbRpcEncode(v)]));
+    return { $: "m", v: entries };
+  }
+  if (value instanceof Set) {
+    const items = [];
+    value.forEach((v) => items.push(__sbRpcEncode(v)));
+    return { $: "s", v: items };
+  }
+  if (value instanceof Error) return { $: "e", n: value.name, m: String(value.message) };
+  const out = {};
+  for (const key of Object.keys(value)) out[key] = __sbRpcEncode(value[key]);
+  return Object.prototype.hasOwnProperty.call(value, "$") ? { $: "o", v: out } : out;
+}
+
+function __sbRpcDecode(value) {
+  if (value === null || !(value instanceof Object)) return value;
+  if (Array.isArray(value)) return value.map(__sbRpcDecode);
+  const tag = value.$;
+  if (tag === undefined) {
+    const out = {};
+    for (const key of Object.keys(value)) out[key] = __sbRpcDecode(value[key]);
+    return out;
+  }
+  if (tag === "u") return undefined;
+  if (tag === "n") return value.v === "-0" ? -0 : Number(value.v);
+  if (tag === "d") return new Date(value.v);
+  if (tag === "r") return new RegExp(value.s, value.f);
+  if (tag === "ab") return __sbBufFrom(atob(value.v));
+  if (tag === "ta") {
+    const buffer = __sbBufFrom(atob(value.v));
+    const View = globalThis[value.t];
+    if (View === globalThis.DataView) return new DataView(buffer);
+    return View && View.BYTES_PER_ELEMENT ? new View(buffer) : new Uint8Array(buffer);
+  }
+  if (tag === "m") return new Map(value.v.map((pair) => [__sbRpcDecode(pair[0]), __sbRpcDecode(pair[1])]));
+  if (tag === "s") return new Set(value.v.map(__sbRpcDecode));
+  if (tag === "e") return __sbRemoteError(encodeURIComponent(JSON.stringify({ name: value.n, message: value.m })));
+  if (tag === "o") return __sbRpcDecode(value.v);
+  return value;
+}
+
+// Caller: one RPC call through service binding `binding`.
+async function __sbRpcCall(binding, method, args) {
+  const label = "sproutboat service " + binding;
+  const body = JSON.stringify(args.map(__sbRpcEncode));
+  const msg = {
+    binding,
+    url: "https://rpc.sproutboat.internal/" + method,
+    method: "POST",
+    headers: [
+      ["x-sb-rpc", method],
+      ["content-type", "application/json"],
+    ],
+    body,
+  };
+  const response = await __sbUpstream("service.fetch", msg, label, null, true);
+  const uncaught = response.headers.get("x-sb-uncaught");
+  if (uncaught != null) throw __sbRemoteError(uncaught);
+  if (response.headers.get("x-sb-rpc-result") !== "1") {
+    throw new TypeError(
+      label + ": the target answered " + response.status + " instead of an RPC result. RPC needs a platform edge " +
+        "that vouches for service-binding calls and a target whose default export extends WorkerEntrypoint.",
+    );
+  }
+  return __sbRpcDecode(JSON.parse(await response.text()));
+}
+
+// Whether the default export handles `name` (fetch, scheduled, queue): a method of the
+// object, or of the class's instances.
+function __sbHandles(handlers, name) {
+  return __sbIsFn(handlers) ? !!handlers.prototype && __sbIsFn(handlers.prototype[name]) : __sbIsFn(handlers[name]);
+}
+
+// Callee: the receiver of one request. A default export that is a class (a
+// WorkerEntrypoint) is instantiated per request with its ctx and env, as in workerd.
+function __sbReceiver(handlers, ctx) {
+  return __sbIsFn(handlers) ? new handlers(ctx, globalThis.env) : handlers;
+}
+
+// Callee: runs RPC method `method` of `receiver` with the arguments in the request body.
+// Only methods the receiver's class defines can be called, not ones every object has.
+async function __sbRpcDispatch(handlers, receiver, method, request) {
+  if (!__sbIsFn(handlers)) {
+    throw new TypeError(
+      "The receiving Worker does not allow its default export to be invoked over RPC, because it does not extend WorkerEntrypoint.",
+    );
+  }
+  const fn = receiver[method];
+  if (!__sbIsFn(fn) || method === "constructor" || method in Object.prototype) {
+    throw new TypeError('The RPC receiver does not implement the method "' + method + '".');
+  }
+  const args = JSON.parse(await request.text()).map(__sbRpcDecode);
+  const result = await fn.apply(receiver, args);
+  return new Response(JSON.stringify(__sbRpcEncode(result)), {
+    headers: { "content-type": "application/json", "x-sb-rpc-result": "1" },
+  });
+}
+
 // 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.
 function __sbFetchParts(input, init) {
@@ -5267,8 +5472,8 @@ function __sbUpstreamResponse(r) {
   return response;
 }
 
-// A streamed upstream response (from compatibility date 2026-10-21, where body is a
-// stream anyway): the call resolves as soon as the head arrives, and the body is a
+// A streamed upstream response (from compatibility date 2026-10-22, with the other
+// asynchronous fetch() behaviour; body is a stream from 2026-10-21 anyway): the call resolves as soon as the head arrives, and the body is a
 // ReadableStream fed chunk by chunk as the broker passes them on. Each frame fires the
 // same callback, so it is an interval that the last frame clears. A reply that comes
 // whole (a broker from before streaming, or sproutd's embedded transport) is handled
@@ -5392,10 +5597,15 @@ function __sbFollowHop(op, msg, label, mode, signal, hops) {
 // callback alive until then. An aborted `signal` rejects with its reason and cancels
 // the exchange, which closes its broker connection: the broker stops the upstream
 // request, and the edge in turn stops the callee's.
-function __sbUpstream(op, msg, label, signal) {
+// Promises from compatibility date 2026-10-22. Before it, a transport that always
+// answered at once (the broker's) still does, so handlers that use fetch()'s result
+// without awaiting keep working; sproutd's answered with promises at any date
+// (__sbAsyncAtAnyDate). `always` is for RPC, which has no older behaviour to keep.
+function __sbUpstream(op, msg, label, signal, always) {
   if (signal) signal.throwIfAborted();
-  if (!__sbHttpAsyncEnabled()) return __sbUpstreamResponse(globalThis.__sbFetchUpstream(op, msg));
-  if (globalThis.__sbCompat >= "2026-10-21") return __sbUpstreamStreamed(op, msg, label, signal);
+  const promised = always || globalThis.__sbCompat >= "2026-10-22" || __sbAsyncAtAnyDate();
+  if (!__sbHttpAsyncEnabled() || !promised) return __sbUpstreamResponse(globalThis.__sbFetchUpstream(op, msg));
+  if (globalThis.__sbCompat >= "2026-10-22") return __sbUpstreamStreamed(op, msg, label, signal);
   return new Promise((resolve, reject) => {
     let onAbort = null;
     const settled = () => {
@@ -5969,7 +6179,8 @@ function __sbBindingCallIngress(request) {
   const vouched = !!want && headers.get("x-sb-binding-call") === "1" && __sbEqCt(headers.get("x-sb-edge-token") || "", want);
   if (vouched) {
     const url = headers.get("x-sb-url");
-    if (url && URL.canParse(url)) request.url = url;
+    // The callee sees its caller's URL from compatibility date 2026-10-22, as in workerd.
+    if (url && URL.canParse(url) && globalThis.__sbCompat >= "2026-10-22") request.url = url;
     headers.delete("x-sb-remote-addr");
   }
   for (const name of ["x-sb-binding-call", "x-sb-url", "x-sb-edge-token"]) {
@@ -6066,9 +6277,14 @@ globalThis.__sbEntry = function (handlers, request) {
     };
     let __res;
     try {
-      __res = globalThis.__sbCompat >= "2026-09-28"
-        ? handlers.fetch(request, globalThis.env, ctx)
-        : handlers.fetch(request, ctx);
+      const receiver = __sbReceiver(handlers, ctx);
+      // An RPC call (a vouched binding call naming a method) runs that method instead.
+      const rpc = bindingCall ? request.headers.get("x-sb-rpc") : null;
+      __res = rpc != null
+        ? __sbRpcDispatch(handlers, receiver, rpc, request)
+        : globalThis.__sbCompat >= "2026-09-28"
+          ? receiver.fetch(request, globalThis.env, ctx)
+          : receiver.fetch(request, ctx);
     } catch (error) {
       // #179 — a synchronous throw anywhere in the handler must not take the
       // whole process (and every other in-flight request) down with it.
@@ -6082,7 +6298,7 @@ globalThis.__sbEntry = function (handlers, request) {
   if (!__sbTriggerAuthed(request)) return new Response("forbidden", { status: 403 });
 
   if (trigger === "scheduled") {
-    if (!__sbIsFn(handlers.scheduled)) return new Response("no scheduled handler", { status: 404 });
+    if (!__sbHandles(handlers, "scheduled")) return new Response("no scheduled handler", { status: 404 });
     const body = __sbReadJson(request);
     // #171 — ctx.waitUntil, same shape as fetch's. Was also fire-and-forget
     // before this: an async `scheduled()`'s own promise was dropped the
@@ -6096,9 +6312,10 @@ globalThis.__sbEntry = function (handlers, request) {
     let __sres;
     try {
       const event = { cron: body.cron || "", scheduledTime: body.scheduledTime || Date.now(), noRetry() {} };
+      const receiver = __sbReceiver(handlers, ctx);
       __sres = globalThis.__sbCompat >= "2026-09-28"
-        ? handlers.scheduled(event, globalThis.env, ctx)
-        : handlers.scheduled(event, ctx);
+        ? receiver.scheduled(event, globalThis.env, ctx)
+        : receiver.scheduled(event, ctx);
     } catch (error) {
       // #179 — same rule as fetch: don't let a throw here crash the process.
       __sbLogUncaught("scheduled", error);
@@ -6109,7 +6326,7 @@ globalThis.__sbEntry = function (handlers, request) {
   }
 
   if (trigger === "queue") {
-    if (!__sbIsFn(handlers.queue)) return new Response("no queue handler", { status: 404 });
+    if (!__sbHandles(handlers, "queue")) return new Response("no queue handler", { status: 404 });
     // #171 — same ctx.waitUntil shape. `__sbRunQueueBatch` was also
     // fire-and-forget for an async `queue()`: it computed the default
     // ack/retry and answered the broker before the handler's own awaits ran,
@@ -6124,7 +6341,7 @@ globalThis.__sbEntry = function (handlers, request) {
     // Always a promise now (`__sbRunQueueBatch` is async, to await the
     // handler above), so always tail-call the drain wrapper — same
     // promise-identity reasoning as `__sbFetchWithDrain`.
-    return __sbQueueWithDrain(__sbRunQueueBatch(handlers, __sbReadJson(request), ctx), __sbTasks);
+    return __sbQueueWithDrain(__sbRunQueueBatch(__sbReceiver(handlers, ctx), __sbReadJson(request), ctx), __sbTasks);
   }
 
   if (trigger === "alarm") {

package/src/source.ts

@@ -1,4 +1,4 @@
-import { neutraliseExports } from "./wrap";
+import { inlineWorkersImports, neutraliseExports } from "./wrap";
 
 export type SourceValidation = { ok: true } | { ok: false; errors: string[] };
 
@@ -28,7 +28,10 @@ const alwaysForbidden: Array<[RegExp, string]> = [
 
 ];
 
-export function validateHttpSyncSource(source: string): SourceValidation {
+export function validateHttpSyncSource(module: string): SourceValidation {
+  // `cloudflare:workers` is the one import allowed past bundling: the compiler turns it
+  // into globals the same way (see inlineWorkersImports).
+  const source = inlineWorkersImports(module);
   const errors: string[] = [];
   // The default export must be an object literal with a `fetch` method. A module
   // may also declare Durable Object classes / helpers before it, so this is not
@@ -36,8 +39,9 @@ export function validateHttpSyncSource(source: string): SourceValidation {
   // A hand-written file exports inline; a bundled one re-exports at the end.
   // `neutraliseExports` is the same reader the compiler uses, so `check` cannot
   // accept a module the build would then reject.
-  if (neutraliseExports(source) === null || !/\bfetch\s*\(/.test(source)) {
-    errors.push("handler must default-export an object with fetch(request)");
+  // A WorkerEntrypoint may serve only RPC, with no fetch() at all.
+  if (neutraliseExports(source) === null || (!/\bfetch\s*\(/.test(source) && !/\bextends\s+WorkerEntrypoint\b/.test(source))) {
+    errors.push("handler must default-export an object with fetch(request), or a WorkerEntrypoint class");
   }
   for (const [pattern, message] of alwaysForbidden) if (pattern.test(source)) errors.push(message);
   return errors.length ? { ok: false, errors } : { ok: true };

package/src/transport-broker.js

@@ -895,6 +895,11 @@ function __sbCancelAsync(asyncId) {
   `;
 }
 
+// Before compatibility date 2026-10-22, fetch() through the broker answered at once.
+function __sbAsyncAtAnyDate() {
+  return false;
+}
+
 // Whether the host runs exchanges off its loop (it installed a waker).
 function __sbHttpAsyncEnabled() {
   let res = false;

package/src/transport-embedded.js

@@ -2086,6 +2086,11 @@ function __sbHttpAsyncResult(asyncId) {
 // placeholder timer cleared, the reply is dropped when it arrives.
 function __sbCancelAsync() {}
 
+// sproutd ran fetch() off its loop, as a promise, at every compatibility date (B18).
+function __sbAsyncAtAnyDate() {
+  return true;
+}
+
 // Whether the host runs async requests (sb_async_enable was called).
 function __sbHttpAsyncEnabled() {
   let res = false;

package/src/wrap.ts

@@ -113,7 +113,33 @@ function hasBindings(b: Bindings): boolean {
  * and re-exports at the end (`export { src_default as default, Counter }`) —
  * #89 made the second shape the normal case. Returns null when neither matches.
  */
+/**
+ * `cloudflare:workers` is not a module here: WorkerEntrypoint, DurableObject, RpcTarget
+ * and env are globals the prelude defines. Each import of it becomes a destructuring
+ * of globalThis, `as` renames included, so the handler's names still resolve. The CLI
+ * leaves the specifier external for this.
+ */
+export function inlineWorkersImports(source: string): string {
+  return source.replace(
+    /^import\s*\{([^}]*)\}\s*from\s*["']cloudflare:workers["'];?[ \t]*$/gm,
+    (_match, names: string) => {
+      const pairs = names
+        .split(",")
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map((part) => part.replace(/^(\S+)\s+as\s+(\S+)$/, "$1: $2"));
+      return `const { ${pairs.join(", ")} } = globalThis;`;
+    },
+  );
+}
+
 export function neutraliseExports(source: string): string | null {
+  // `export default class Name extends WorkerEntrypoint {`: the class is the handler.
+  if (/^\s*export\s+default\s+class\b/m.test(source)) {
+    return source
+      .replace(/^(\s*)export\s+default\s+class\b/m, "$1const __sbHandlers = class")
+      .replace(/^export\s+(async\s+function|function|class|const|let|var)\b/gm, "$1");
+  }
   if (/\bexport\s+default\s*\{/.test(source)) {
     return source
       .replace(/^(\s*)export\s+default\s*/m, "$1const __sbHandlers = ")
@@ -182,9 +208,10 @@ export function wrapNativeFetchHandler(
    */
   versionMetadata?: { binding: string; id: string; tag: string; timestamp: string },
 ): string {
-  const neutralised = neutraliseExports(source);
-  if (neutralised === null || !/\bfetch\s*\(/.test(source)) {
-    throw new Error("handler must default-export an object with a fetch(request) method");
+  const neutralised = neutraliseExports(inlineWorkersImports(source));
+  // A WorkerEntrypoint may serve only RPC, with no fetch() at all.
+  if (neutralised === null || (!/\bfetch\s*\(/.test(source) && !/\bextends\s+WorkerEntrypoint\b/.test(source))) {
+    throw new Error("handler must default-export an object with a fetch(request) method, or a WorkerEntrypoint class");
   }
 
   const env = `const env = ${JSON.stringify(vars)};\nglobalThis.env = env;\n`;

package/test/native-base64.ts

@@ -18,7 +18,13 @@ const handler = `export default {fetch() {
     const decoded=Array.from(Uint8Array.fromBase64(url,{alphabet:"base64url"}));
     rows.push({padded,url,decoded});
   }
-  return Response.json(rows);
+  // atob/btoa on strings that are not literals (from JSON.parse, from TextDecoder): they
+  // used to read the string's UTF-16 storage and return the wrong bytes.
+  const parsed=JSON.parse('{"latin":"h\\u00e9llo w\\u00f6rld","b64":"AQL/"}');
+  const decodedText=new TextDecoder().decode(new TextEncoder().encode("AQL/"));
+  const codes=(s)=>Array.from(s,(c)=>c.charCodeAt(0));
+  const strings={btoa:btoa(parsed.latin),atob:codes(atob(parsed.b64)),fromDecoder:codes(atob(decodedText))};
+  return Response.json({rows,strings});
 }};`;
 
 function freePort(): number {
@@ -78,7 +84,10 @@ try {
   }
   assert(response, "compiled streams handler did not start");
   assert.equal(response.status, 200);
-  assert.deepEqual(await response.json(), expected);
+  assert.deepEqual(await response.json(), {
+    rows: expected,
+    strings: { btoa: btoa("h\u00e9llo w\u00f6rld"), atob: [1, 2, 255], fromDecoder: [1, 2, 255] },
+  });
   console.log("Native base64 and base64url round-trip zero to nine bytes with correct padding");
 } finally {
   if (server) {

package/test/native-service-bindings.ts

@@ -15,7 +15,9 @@ import { EMPTY_BINDINGS, preludePath, TRANSPORT_MARKER, transportPath, wrapNativ
 // From compatibility date 2026-10-22, redirects are followed as Fetch does. A stand-in
 // edge plays the platform's.
 const handler = `
-export default {
+import { WorkerEntrypoint } from "cloudflare:workers";
+
+export default class Service extends WorkerEntrypoint {
   async fetch(request, env) {
     const url = new URL(request.url);
     if (url.pathname === "/ping") return new Response("pong");
@@ -86,6 +88,22 @@ export default {
       for (let i = 0; bigOk && i < big.length; i += 4093) bigOk = big[i] === (i & 255);
       return Response.json({ firstEarly: firstMs >= 0 && firstMs < 250, text, whole, bigOk });
     }
+    if (url.pathname === "/rpc") {
+      // RPC to this deployment's own WorkerEntrypoint, through the vouched SELF binding.
+      const sum = await env.SELF.add(2, 3);
+      const trip = await env.SELF.roundTrip({ d: new Date(5), b: new Uint8Array([7, 255]), m: new Map([["k", -0]]), u: undefined, n: NaN });
+      const kept = {
+        d: trip.d instanceof Date && trip.d.getTime() === 5,
+        b: trip.b instanceof Uint8Array && trip.b.length === 2 && trip.b[1] === 255,
+        m: trip.m instanceof Map && Object.is(trip.m.get("k"), -0),
+        u: "u" in trip && trip.u === undefined,
+        n: Number.isNaN(trip.n),
+      };
+      const thrown = await env.SELF.fail("nope").then(() => null, (e) => [e.name, e.message, e instanceof RangeError]);
+      const unknown = await env.SELF.noSuchMethod().then(() => null, (e) => [e.name, e.message]);
+      const context = await env.SELF.whoAmI();
+      return Response.json({ sum, kept, thrown, unknown, context });
+    }
     if (url.pathname === "/whoami") {
       return Response.json({ url: request.url, internal: [...request.headers.keys()].filter((k) => k.startsWith("x-sb-")) });
     }
@@ -101,8 +119,24 @@ export default {
       return Response.json({ who, thrown });
     }
     return new Response("no route", { status: 404 });
-  },
-};
+  }
+
+  add(a, b) {
+    return a + b;
+  }
+
+  roundTrip(value) {
+    return value;
+  }
+
+  fail(message) {
+    throw new RangeError(message);
+  }
+
+  whoAmI() {
+    return { env: this.env !== undefined && this.env.SELF !== undefined, waitUntil: this.ctx.waitUntil instanceof Function };
+  }
+}
 `;
 
 function freePort(): number {
@@ -136,7 +170,8 @@ const edge = Bun.serve({
         const callerUrl = request.headers.get("x-sb-url");
         if (callerUrl) headers.set("x-sb-url", callerUrl);
       }
-      return fetch(`http://127.0.0.1:${port}${url.pathname}${url.search}`, { method: request.method, headers });
+      const body = request.method === "GET" || request.method === "HEAD" ? undefined : await request.arrayBuffer();
+      return fetch(`http://127.0.0.1:${port}${url.pathname}${url.search}`, { method: request.method, headers, body });
     }
     if (url.pathname === "/echo") {
       return Response.json({
@@ -204,6 +239,7 @@ const broker = createBroker({
 });
 const brokerServer = listen(broker, "127.0.0.1", 0);
 let server: ReturnType<typeof Bun.spawn> | undefined;
+let legacy: ReturnType<typeof Bun.spawn> | undefined;
 const get = async (path: string) => {
   const t0 = performance.now();
   const res = await fetch(`http://127.0.0.1:${port}${path}`, { signal: AbortSignal.timeout(20_000) });
@@ -321,24 +357,75 @@ try {
   assert.equal(publicBoom.status, 500);
   assert.equal(publicBoom.headers.get("x-sb-uncaught"), null);
 
-  // Streamed responses (compatibility date 2026-10-21 on): the call resolves on the
+  // Streamed responses (compatibility date 2026-10-22 on): the call resolves on the
   // head, the first chunk arrives before the rest, and a 12 MiB body arrives intact.
   const streamed = await get("/streamed");
   assert.equal(streamed.status, 200, streamed.text);
   assert.deepEqual(JSON.parse(streamed.text), { firstEarly: true, text: "0 1 2 3 ", whole: "0 1 2 3 ", bigOk: true });
 
+  // RPC: methods of the WorkerEntrypoint, called on the binding, with values copied as
+  // structured clone does and errors thrown as in workerd.
+  const rpc = await get("/rpc");
+  assert.equal(rpc.status, 200, rpc.text);
+  assert.deepEqual(JSON.parse(rpc.text), {
+    sum: 5,
+    kept: { d: true, b: true, m: true, u: true, n: true },
+    thrown: ["RangeError", "nope", true],
+    unknown: ["TypeError", 'The RPC receiver does not implement the method "noSuchMethod".'],
+    context: { env: true, waitUntil: true },
+  });
+  // A client cannot call a method: without the edge's vouching, x-sb-rpc is just a header.
+  const forgedRpc = await fetch(`http://127.0.0.1:${port}/ping`, { method: "POST", headers: { "x-sb-rpc": "fail" }, body: "[\"x\"]" });
+  assert.equal(await forgedRpc.text(), "pong");
+
   // A deployment calling itself, 30 levels deep: every level waits on the next at once.
   const self = await get("/self");
   assert.equal(self.text, "bottom 30");
+  // Before compatibility date 2026-10-22 a binding call answers at once, as it always
+  // did: a handler that uses the Response without awaiting it keeps working.
+  const legacyHandler = `
+export default {
+  fetch(request, env) {
+    const res = env.PEER.fetch("https://peer/echo?legacy=1");
+    return new Response(String(res instanceof Response) + ":" + res.status + ":" + res.json().path);
+  },
+};
+`;
+  const legacyPort = freePort();
+  const legacySource = join(workdir, "legacy.generated.js");
+  const legacyBinary = join(workdir, "legacy-native");
+  await writeFile(legacySource, wrapNativeFetchHandler(legacyHandler, core.replace(TRANSPORT_MARKER, transport), {}, bindings, undefined, "2026-10-21"));
+  const legacyCompile = Bun.spawnSync([node, resolve(porffor, "runtime/index.js"), "native", legacySource, "-o", legacyBinary, "-s", "-O0"], { cwd: workdir });
+  assert.equal(legacyCompile.exitCode, 0, `legacy compile failed:\n${legacyCompile.stderr}`);
+  legacy = Bun.spawn([legacyBinary], {
+    cwd: workdir,
+    env: { ...process.env, PORT: String(legacyPort), SB_BROKER_PORT: String(brokerServer.port), SB_BROKER_TOKEN: "native-services" },
+    stdout: "ignore",
+    stderr: "inherit",
+  });
+  let legacyText = "";
+  for (let attempt = 0; attempt < 50 && !legacyText; attempt++) {
+    try {
+      legacyText = await (await fetch(`http://127.0.0.1:${legacyPort}/`, { signal: AbortSignal.timeout(20_000) })).text();
+    } catch {
+      await Bun.sleep(100);
+    }
+  }
+  assert.equal(legacyText, "true:200:/echo?legacy=1", "before 2026-10-22 a binding call answers synchronously");
+
   console.log(
     `Service bindings return promises and run off the loop: /ping ${Math.round(ping.ms)} ms during a call, ` +
-      `8x500 ms in ${Math.round(total)} ms, self-recursion ok; URL, Request+init, stream bodies, Set-Cookie and missing content types preserved; redirects follow Fetch; aborted calls stop upstream; vouched calls see the caller's URL and rethrow the callee's errors; responses stream`,
+      `8x500 ms in ${Math.round(total)} ms, self-recursion ok; URL, Request+init, stream bodies, Set-Cookie and missing content types preserved; redirects follow Fetch; aborted calls stop upstream; before 2026-10-22 calls answer at once; vouched calls see the caller's URL and rethrow the callee's errors; responses stream; RPC calls WorkerEntrypoint methods`,
   );
 } finally {
   if (server) {
     server.kill(9);
     await server.exited;
   }
+  if (legacy) {
+    legacy.kill(9);
+    await legacy.exited;
+  }
   brokerServer.stop();
   broker.close();
   edge.stop(true);