@sproutboat/runtime 0.19.2 → 0.21.0

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,86 +5218,421 @@ 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.
+  // 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.
   for (let i = 0; i < (bindings.services || []).length; i++) {
     const binding = bindings.services[i].binding;
-    target[binding] = {
-      fetch(input, init) {
-        const url = __sbIsStr(input) ? input : String((input && input.url) || "https://service/");
-        const opts = init || (!__sbIsStr(input) && input) || {};
-        const headers = [];
-        if (opts.headers) {
-          if (__sbIsFn(opts.headers.forEach)) opts.headers.forEach((v, k) => headers.push([k, v]));
-          else for (const k in opts.headers) headers.push([k, opts.headers[k]]);
-        }
-        const r = globalThis.__sbFetchUpstream("service.fetch", {
-          binding,
-          url,
-          method: opts.method || "GET",
-          headers,
-          ...__sbRequestBody(opts instanceof Request ? __sbRawBody(opts) : opts.body),
-        });
-        const respHeaders = new Headers();
-        for (let j = 0; j < (r.headers || []).length; j++) respHeaders.set(r.headers[j][0], r.headers[j][1]);
-        // #176: wire bytes from another deployment, not a string this handler
-        // built -- must not be re-encoded if the handler proxies it straight
-        // through (see the assets binding for the same reasoning).
-        if (r.body != null) respHeaders.set("x-sb-raw-body", "1");
-        return __sbRawBodyResponse(r.body, { status: r.status || 502, headers: respHeaders });
+    const fetcher = {
+      async fetch(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;
       },
     };
+    // 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);
+      },
+    });
   }
 
 };
 
-// fetch() reaches any public address; the transport refuses private and
-// reserved ones at connect (baronunread/sproutboat#174). No config, like a
-// Worker's fetch. Installed by the generated module (wrap.ts), not here: the
-// prelude must not replace fetch just by being evaluated.
-globalThis.__sbInstallFetch = function () {
-  globalThis.fetch = function (input, init) {
-    // A Request's method, headers and body apply unless init overrides them; a URL
-    // object stands for its href.
-    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 || {};
-    const source = opts.headers != null ? opts.headers : req ? req.headers : null;
-    const headers = [];
-    if (source) {
-      if (__sbIsFn(source.forEach)) source.forEach((v, k) => headers.push([k, v]));
-      else for (const k in source) headers.push([k, source[k]]);
-    }
-    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 msg = { url, method, headers, ...__sbRequestBody(body) };
-    const respond = (r) => {
-      const respHeaders = new Headers();
-      for (let j = 0; j < (r.headers || []).length; j++) respHeaders.set(r.headers[j][0], r.headers[j][1]);
-      // #176: bytes from an outbound HTTP response, not a string this handler
-      // built -- must not be re-encoded if the handler proxies it straight
-      // through (see the assets binding for the same reasoning).
-      if (r.body != null) respHeaders.set("x-sb-raw-body", "1");
-      return __sbRawBodyResponse(r.body, { status: r.status || 502, headers: respHeaders });
+// 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) {
+  let name = "Error";
+  let message = "";
+  try {
+    const parsed = JSON.parse(decodeURIComponent(marker));
+    name = String(parsed.name || "Error");
+    message = String(parsed.message == null ? "" : parsed.message);
+  } catch {
+    /* a marker we cannot read still means the callee threw */
+  }
+  const error =
+    name === "TypeError" ? new TypeError(message)
+    : name === "RangeError" ? new RangeError(message)
+    : name === "SyntaxError" ? new SyntaxError(message)
+    : name === "ReferenceError" ? new ReferenceError(message)
+    : new Error(message);
+  if (error.name !== name) error.name = name;
+  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);
+  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) {
+  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 || {};
+  const source = opts.headers != null ? opts.headers : req ? req.headers : null;
+  const headers = [];
+  if (source) {
+    if (__sbIsFn(source.forEach)) source.forEach((v, k) => headers.push([k, v]));
+    else for (const k in source) headers.push([k, source[k]]);
+  }
+  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 };
+}
+
+// An upstream reply (fetch or service.fetch) -> a Response. Headers are appended,
+// so each Set-Cookie survives, and a reply without a content type keeps none: the
+// body reaches Response as a string, which would otherwise default to text/plain.
+function __sbUpstreamResponse(r) {
+  const respHeaders = new Headers();
+  let typed = false;
+  for (let j = 0; j < (r.headers || []).length; j++) {
+    respHeaders.append(r.headers[j][0], r.headers[j][1]);
+    if (String(r.headers[j][0]).toLowerCase() === "content-type") typed = true;
+  }
+  // #176: bytes from another server or deployment, not a string this handler
+  // built -- must not be re-encoded if the handler proxies it straight
+  // through (see the assets binding for the same reasoning).
+  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;
+}
+
+// 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
+// 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
+// as before. Cancelling the body, or the signal, drops the exchange, which stops the
+// upstream request.
+function __sbUpstreamStreamed(op, msg, label, signal) {
+  return new Promise((resolve, reject) => {
+    let controller = null;
+    let onAbort = null;
+    let done = false;
+    const finish = () => {
+      done = true;
+      clearInterval(id);
+      if (onAbort) signal.removeEventListener("abort", onAbort);
     };
-    if (!__sbHttpAsyncEnabled()) return respond(globalThis.__sbFetchUpstream("fetch", msg));
-    // B18: the host runs the request off the event loop. Its reply fires a timer
-    // that never fires on its own; the timer table keeps the callback alive.
-    return new Promise((resolve, reject) => {
-      const id = setTimeout(() => {
+    const id = setInterval(() => {
+      if (done) return;
+      const raw = __sbHttpAsyncResult(id);
+      if (controller === null) {
+        let reply;
         try {
-          resolve(respond(__sbFetchReply(__sbHttpAsyncResult(id))));
+          reply = JSON.parse(raw);
         } catch (e) {
-          reject(new Error("sproutboat fetch: " + ((e && e.message) || e)));
+          reply = { ok: false, error: String((e && e.message) || e) };
         }
-      }, 2147483647);
+        if (reply.ok === false || !reply.stream) {
+          finish();
+          try {
+            resolve(__sbUpstreamResponse(__sbFetchReply(raw)));
+          } catch (e) {
+            reject(new Error(label + ": " + ((e && e.message) || e)));
+          }
+          return;
+        }
+        const headers = new Headers();
+        for (let j = 0; j < (reply.headers || []).length; j++) headers.append(reply.headers[j][0], reply.headers[j][1]);
+        const body = new ReadableStream({
+          start(c) {
+            controller = c;
+          },
+          cancel() {
+            if (done) return;
+            finish();
+            __sbCancelAsync(id);
+          },
+        });
+        resolve(new Response(body, { status: reply.status || 502, headers }));
+        return;
+      }
+      const frame = JSON.parse(raw);
+      const bytes = __sbTakeBin();
+      if (frame.chunk) {
+        if (bytes.length) controller.enqueue(new Uint8Array(__sbBufFrom(bytes)));
+        return;
+      }
+      finish();
+      if (frame.ok === false) controller.error(new Error(label + ": " + (frame.error || "failed")));
+      else controller.close();
+    }, 2147483647);
+    if (signal) {
+      onAbort = () => {
+        if (done) return;
+        finish();
+        __sbCancelAsync(id);
+        if (controller === null) reject(signal.reason);
+        else controller.error(signal.reason);
+      };
+      signal.addEventListener("abort", onAbort);
+    }
+    try {
+      msg.asyncId = id;
+      msg.stream = true;
+      globalThis.__sbFetchUpstream(op, msg);
+    } catch (e) {
+      finish();
+      reject(e);
+    }
+  });
+}
+
+// Fetch's redirect handling, from compatibility date 2026-10-22 (before it, a 3xx came
+// back as it was, whatever the mode). "follow" sends the request again to the new
+// location, up to 20 times; each hop goes back through the broker, so outbound hops
+// are vetted like the first. A 303, or a 301/302 to a POST, becomes a bodiless GET;
+// a hop to another origin drops Authorization. A service binding follows through
+// the same binding, as in workerd. "error" rejects; "manual" returns the 3xx.
+function __sbFetchFollowing(op, msg, label, mode, signal) {
+  return __sbFollowHop(op, msg, label, mode, signal, 0);
+}
+function __sbFollowHop(op, msg, label, mode, signal, hops) {
+  const step = (res) => {
+    const location = res.headers.get("location");
+    const redirect = res.status === 301 || res.status === 302 || res.status === 303 || res.status === 307 || res.status === 308;
+    if (!(globalThis.__sbCompat >= "2026-10-22") || mode === "manual" || !redirect || location == null) return res;
+    if (mode === "error") throw new TypeError(label + ": redirect not allowed (redirect: \"error\")");
+    if (hops >= 20) throw new TypeError(label + ": too many redirects");
+    const dropped = __sbRawBody(res);
+    if (dropped instanceof ReadableStream) dropped.cancel();
+    const from = new URL(msg.url);
+    const to = new URL(location, from);
+    const next = { ...msg, url: to.href };
+    delete next.asyncId;
+    const toGet = res.status === 303 ? msg.method !== "GET" && msg.method !== "HEAD" : res.status !== 307 && res.status !== 308 && msg.method === "POST";
+    const drop = (name) =>
+      (toGet && /^content-(type|length|encoding|language|location)$/.test(name)) || (to.origin !== from.origin && name === "authorization");
+    next.headers = msg.headers.filter((pair) => !drop(String(pair[0]).toLowerCase()));
+    if (toGet) {
+      next.method = "GET";
+      next.body = null;
+      delete next.bodyBinary;
+    }
+    return __sbFollowHop(op, next, label, mode, signal, hops + 1);
+  };
+  const out = __sbUpstream(op, msg, label, signal);
+  return out instanceof Promise ? out.then(step) : step(out);
+}
+
+// Sends `msg` as `op` and answers with the Response: at once on a synchronous
+// transport, or (B18) as a promise when the host runs requests off its event loop.
+// The reply fires a timer that never fires on its own; the timer table keeps the
+// 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) {
+  if (signal) signal.throwIfAborted();
+  if (!__sbHttpAsyncEnabled()) return __sbUpstreamResponse(globalThis.__sbFetchUpstream(op, msg));
+  if (globalThis.__sbCompat >= "2026-10-21") return __sbUpstreamStreamed(op, msg, label, signal);
+  return new Promise((resolve, reject) => {
+    let onAbort = null;
+    const settled = () => {
+      if (onAbort) signal.removeEventListener("abort", onAbort);
+    };
+    const id = setTimeout(() => {
+      settled();
       try {
-        msg.asyncId = id;
-        globalThis.__sbFetchUpstream("fetch", msg);
+        resolve(__sbUpstreamResponse(__sbFetchReply(__sbHttpAsyncResult(id))));
       } catch (e) {
-        clearTimeout(id);
-        reject(e);
+        reject(new Error(label + ": " + ((e && e.message) || e)));
       }
-    });
+    }, 2147483647);
+    if (signal) {
+      onAbort = () => {
+        settled();
+        clearTimeout(id);
+        __sbCancelAsync(id);
+        reject(signal.reason);
+      };
+      signal.addEventListener("abort", onAbort);
+    }
+    try {
+      msg.asyncId = id;
+      globalThis.__sbFetchUpstream(op, msg);
+    } catch (e) {
+      settled();
+      clearTimeout(id);
+      reject(e);
+    }
+  });
+}
+
+// fetch() reaches any public address; the transport refuses private and
+// reserved ones at connect (baronunread/sproutboat#174). No config, like a
+// Worker's fetch. Installed by the generated module (wrap.ts), not here: the
+// 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);
   };
 };
 
@@ -5744,7 +6114,7 @@ function __sbStreamResponse(response) {
   return response;
 }
 
-async function __sbFetchWithDrain(res, tasks) {
+async function __sbFetchWithDrain(res, tasks, bindingCall) {
   let r;
   try {
     r = res && __sbIsFn(res.then) ? await res : res;
@@ -5754,7 +6124,7 @@ async function __sbFetchWithDrain(res, tasks) {
     }
   } catch (error) {
     // #179 — a rejected handler promise must not take the process down with it.
-    r = __sbErrorResponse(error);
+    r = __sbErrorResponse(error, bindingCall);
   }
   // The response goes out now and ctx.waitUntil work keeps running after it, as in
   // workerd; it was awaited first, so a 1.5 s background task delayed the response by
@@ -5767,14 +6137,42 @@ async function __sbFetchWithDrain(res, tasks) {
 // propagate past __sbEntry and crash the whole server. Logged first, the way a
 // Worker logs "Uncaught Error: ...": a swallowed exception left a 500 with
 // nothing on stderr, which hid #168 entirely.
-function __sbErrorResponse(error) {
+function __sbErrorResponse(error, bindingCall) {
   __sbLogUncaught("fetch", error);
   // Untyped, as workerd sends it: the text/plain default is for handlers' bodies.
   const response = new Response("Internal Server Error", { status: 500 });
   response.headers.delete("content-type");
+  // A service-binding caller rethrows the error, as in workerd. Only on a call the
+  // edge vouched for: the marker carries the message, and the edge strips it from
+  // anything that goes to a client.
+  if (bindingCall) {
+    const name = (error && error.name) || "Error";
+    const message = error && error.message != null ? String(error.message) : String(error);
+    response.headers.set("x-sb-uncaught", encodeURIComponent(JSON.stringify({ name: String(name), message: message.slice(0, 1000) })));
+  }
   return response;
 }
 
+// A service-binding call the platform's edge vouched for: it carries the token the edge
+// gave this sprout (SB_EDGE_TOKEN), so no client can claim one. Such a call sees the URL
+// its caller passed (x-sb-url), not the deployment's hostname, and no remote address,
+// as in workerd. The edge's headers are removed from every request before the handler
+// sees it. Returns whether the edge vouched for this one.
+function __sbBindingCallIngress(request) {
+  const headers = request.headers;
+  const want = __sbEnv("SB_EDGE_TOKEN");
+  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;
+    headers.delete("x-sb-remote-addr");
+  }
+  for (const name of ["x-sb-binding-call", "x-sb-url", "x-sb-edge-token"]) {
+    if (headers.get(name) != null) headers.delete(name);
+  }
+  return vouched;
+}
+
 function __sbLogUncaught(where, error) {
   try {
     let text = "";
@@ -5830,6 +6228,7 @@ globalThis.__sbEntry = function (handlers, request) {
   __sbDecodeIngress(request);
   const trigger = request.headers.get("x-sb-trigger");
   if (!trigger) {
+    const bindingCall = __sbBindingCallIngress(request);
     // #163/#128 — expose the request metadata the edge already has, the
     // Workers way, before the handler runs. httpProtocol/tlsVersion/tlsCipher
     // are only set when a trusted front proxy forwarded them; colo, ASN and
@@ -5862,23 +6261,28 @@ 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.
-      return __sbErrorResponse(error);
+      return __sbErrorResponse(error, bindingCall);
     }
     // Same promise-identity rule as above applies to `__sbFetchWithDrain`'s
     // own return, which is why it's tail-called rather than chained on here.
-    if (__sbTasks.length || (__res && __sbIsFn(__res.then)) || __sbHasStreamBody(__res)) return __sbFetchWithDrain(__res, __sbTasks);
+    if (__sbTasks.length || (__res && __sbIsFn(__res.then)) || __sbHasStreamBody(__res)) return __sbFetchWithDrain(__res, __sbTasks, bindingCall);
     return __sbTagCpu(__res, __t0);
   }
   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
@@ -5892,9 +6296,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);
@@ -5905,7 +6310,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,
@@ -5920,7 +6325,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") {