capnweb 0.0.0-c2bb17b → 0.0.0-cfa1b95

package/dist/index.d.cts

@@ -12,18 +12,26 @@ import { IncomingMessage, ServerResponse, OutgoingHttpHeaders, OutgoingHttpHeade
 // accept `WorkerEntrypoint` from `cloudflare:workers`, not any other class with the same shape)
 declare const __RPC_STUB_BRAND: '__RPC_STUB_BRAND';
 declare const __RPC_TARGET_BRAND: '__RPC_TARGET_BRAND';
+// Distinguishes mapper placeholders from regular values so param unwrapping can accept them.
+declare const __RPC_MAP_VALUE_BRAND: unique symbol;
 interface RpcTargetBranded {
   [__RPC_TARGET_BRAND]: never;
 }
 
 // Types that can be used through `Stub`s
-type Stubable = RpcTargetBranded | ((...args: any[]) => any);
+// `never[]` preserves compatibility with strongly-typed function signatures without introducing
+// `any` into inference.
+type Stubable = RpcTargetBranded | ((...args: never[]) => unknown);
+
+type IsUnknown<T> = unknown extends T ? ([T] extends [unknown] ? true : false) : false;
 
 // Types that can be passed over RPC
 // The reason for using a generic type here is to build a serializable subset of structured
 //   cloneable composite types. This allows types defined with the "interface" keyword to pass the
 //   serializable check as well. Otherwise, only types defined with the "type" keyword would pass.
 type RpcCompatible<T> =
+  // Allow `unknown` as a leaf so records/interfaces with `unknown` fields remain compatible.
+  | (IsUnknown<T> extends true ? unknown : never)
   // Structured cloneables
   | BaseType
   // Structured cloneable composites
@@ -45,7 +53,7 @@ type RpcCompatible<T> =
 
 // Base type for all RPC stubs, including common memory management methods.
 // `T` is used as a marker type for unwrapping `Stub`s later.
-interface StubBase<T extends RpcCompatible<T>> extends Disposable {
+interface StubBase<T = unknown> extends Disposable {
   [__RPC_STUB_BRAND]: T;
   dup(): this;
   onRpcBroken(callback: (error: any) => void): void;
@@ -102,7 +110,7 @@ type Stubify<T> =
   : T extends ReadonlyArray<infer V> ? ReadonlyArray<Stubify<V>>
   : T extends BaseType ? T
   // When using "unknown" instead of "any", interfaces are not stubified.
-  : T extends { [key: string | number]: any } ? { [K in keyof T]: Stubify<T[K]> }
+  : T extends { [key: string | number]: any } ? { [K in keyof T as K extends string | number ? K : never]: Stubify<T[K]> }
   : T;
 
 // Recursively rewrite all `Stub<T>`s with the corresponding `T`s.
@@ -110,7 +118,10 @@ type Stubify<T> =
 // `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`.
 // prettier-ignore
 type UnstubifyInner<T> =
-  T extends StubBase<infer V> ? (T | V)  // can provide either stub or local RpcTarget
+  // Preserve local RpcTarget acceptance, but avoid needless `Stub | Value` unions when the stub
+  // is already assignable to the value type (important for callback contextual typing).
+  T extends StubBase<infer V> ? (T extends V ? UnstubifyInner<V> : (T | UnstubifyInner<V>))
+  : T extends Promise<infer U> ? UnstubifyInner<U>
   : T extends Map<infer K, infer V> ? Map<Unstubify<K>, Unstubify<V>>
   : T extends Set<infer V> ? Set<Unstubify<V>>
   : T extends [] ? []
@@ -120,14 +131,30 @@ type UnstubifyInner<T> =
   : T extends Array<infer V> ? Array<Unstubify<V>>
   : T extends ReadonlyArray<infer V> ? ReadonlyArray<Unstubify<V>>
   : T extends BaseType ? T
-  : T extends { [key: string | number]: unknown } ? { [K in keyof T]: Unstubify<T[K]> }
+  : T extends { [key: string | number]: unknown } ? { [K in keyof T as K extends string | number ? K : never]: Unstubify<T[K]> }
   : T;
 
 // You can put promises anywhere in the params and they'll be resolved before delivery.
 // (This also covers RpcPromise, because it's defined as being a Promise.)
-type Unstubify<T> = UnstubifyInner<T> | Promise<UnstubifyInner<T>>
+// Map placeholders are also allowed so primitive map callback inputs can be forwarded directly
+// into RPC params.
+//
+// Keep raw non-stub members so generic assignability still works when UnstubifyInner<T> is deferred.
+// Remove stub members from mixed unions so callback params don’t get both stub and unstubbed signatures.
+// Marker carried by map() callback inputs. This lets primitive placeholders flow through params.
+type Unstubify<T> =
+  | NonStubMembers<T>
+  | UnstubifyInner<T>
+  | Promise<UnstubifyInner<T>>
+  | MapValuePlaceholder<UnstubifyInner<T>>;
+
+type UnstubifyAll<A extends readonly unknown[]> = { [I in keyof A]: Unstubify<A[I]> };
 
-type UnstubifyAll<A extends any[]> = { [I in keyof A]: Unstubify<A[I]> };
+interface MapValuePlaceholder<T> {
+  [__RPC_MAP_VALUE_BRAND]: T;
+}
+
+type NonStubMembers<T> = Exclude<T, StubBase<any>>;
 
 // Utility type for adding `Disposable`s to `object` types only.
 // Note `unknown & T` is equivalent to `T`.
@@ -142,17 +169,22 @@ type MaybeDisposable<T> = T extends object ? Disposable : unknown;
 // Intersecting with `(Maybe)Provider` allows pipelining.
 // prettier-ignore
 type Result<R> =
-  R extends Stubable ? Promise<Stub<R>> & Provider<R> & StubBase<R>
+  IsAny<R> extends true ? UnknownResult
+  : IsUnknown<R> extends true ? UnknownResult
+  : R extends Stubable ? Promise<Stub<R>> & Provider<R> & StubBase<R>
   : R extends RpcCompatible<R> ? Promise<Stubify<R> & MaybeDisposable<R>> & Provider<R> & StubBase<R>
   : never;
 
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+type UnknownResult = Promise<unknown> & Provider<unknown> & StubBase<unknown>;
+
 // Type for method or property on an RPC interface.
 // For methods, unwrap `Stub`s in parameters, and rewrite returns to be `Result`s.
 // Unwrapping `Stub`s allows calling with `Stubable` arguments.
 // For properties, rewrite types to be `Result`s.
 // In each case, unwrap `Promise`s.
 type MethodOrProperty<V> = V extends (...args: infer P) => infer R
-  ? (...args: UnstubifyAll<P>) => Result<Awaited<R>>
+  ? (...args: UnstubifyAll<P>) => IsAny<R> extends true ? UnknownResult : Result<Awaited<R>>
   : Result<Awaited<V>>;
 
 // Type for the callable part of an `Provider` if `T` is callable.
@@ -161,22 +193,62 @@ type MaybeCallableProvider<T> = T extends (...args: any[]) => any
   ? MethodOrProperty<T>
   : unknown;
 
+type TupleIndexKeys<T extends ReadonlyArray<unknown>> = Extract<keyof T, `${number}`>;
+type MapCallbackValue<T> =
+  // `Omit` removes call signatures, so re-intersect callable provider behavior.
+  T extends unknown
+    ? Omit<Result<T>, keyof Promise<unknown>> &
+        MaybeCallableProvider<T> &
+        MapValuePlaceholder<T>
+    : never;
+type InvalidNativePromiseInMapResult<T, Seen = never> =
+  T extends unknown ? InvalidNativePromiseInMapResultImpl<T, Seen> : never;
+type InvalidNativePromiseInMapResultImpl<T, Seen> =
+  [T] extends [Seen] ? never
+  // RpcPromise is modeled as Promise & StubBase, so allow promise-like stub values.
+  : T extends StubBase<any> ? never
+  // Native thenables cannot be represented in map recordings, even when typed as PromiseLike.
+  : T extends PromiseLike<unknown> ? T
+  : T extends Map<infer K, infer V>
+    ? InvalidNativePromiseInMapResult<K, Seen | T> |
+        InvalidNativePromiseInMapResult<V, Seen | T>
+  : T extends Set<infer V> ? InvalidNativePromiseInMapResult<V, Seen | T>
+  : T extends readonly [] ? never
+  : T extends readonly [infer Head, ...infer Tail]
+    ? InvalidNativePromiseInMapResult<Head, Seen | T> |
+        InvalidNativePromiseInMapResult<Tail[number], Seen | T>
+  : T extends ReadonlyArray<infer V> ? InvalidNativePromiseInMapResult<V, Seen | T>
+  : T extends { [key: string | number]: unknown }
+    ? InvalidNativePromiseInMapResult<
+        T[Extract<keyof T, string | number>],
+        Seen | T
+      >
+  : never;
+type MapCallbackReturn<T> =
+  InvalidNativePromiseInMapResult<T> extends never ? T : never;
+type ArrayProvider<E> = {
+  [K in number]: MethodOrProperty<E>;
+} & {
+  map<V>(callback: (elem: MapCallbackValue<E>) => MapCallbackReturn<V>): Result<Array<V>>;
+};
+type TupleProvider<T extends ReadonlyArray<unknown>> = {
+  [K in TupleIndexKeys<T>]: MethodOrProperty<T[K]>;
+} & ArrayProvider<T[number]>;
+
 // Base type for all other types providing RPC-like interfaces.
 // Rewrites all methods/properties to be `MethodOrProperty`s, while preserving callable types.
 type Provider<T> = MaybeCallableProvider<T> &
-  (T extends Array<infer U>
-    ? {
-        [key: number]: MethodOrProperty<U>;
-      } & {
-        map<V>(callback: (elem: U) => V): Result<Array<V>>;
-      }
+  (T extends ReadonlyArray<unknown>
+    ? number extends T["length"] ? ArrayProvider<T[number]> : TupleProvider<T>
     : {
         [K in Exclude<
           keyof T,
           symbol | keyof StubBase<never>
         >]: MethodOrProperty<T[K]>;
       } & {
-        map<V>(callback: (value: NonNullable<T>) => V): Result<Array<V>>;
+        map<V>(
+          callback: (value: MapCallbackValue<NonNullable<T>>) => MapCallbackReturn<V>
+        ): Result<Array<V>>;
       });
 
 /**

package/dist/index.d.ts

@@ -12,18 +12,26 @@ import { IncomingMessage, ServerResponse, OutgoingHttpHeaders, OutgoingHttpHeade
 // accept `WorkerEntrypoint` from `cloudflare:workers`, not any other class with the same shape)
 declare const __RPC_STUB_BRAND: '__RPC_STUB_BRAND';
 declare const __RPC_TARGET_BRAND: '__RPC_TARGET_BRAND';
+// Distinguishes mapper placeholders from regular values so param unwrapping can accept them.
+declare const __RPC_MAP_VALUE_BRAND: unique symbol;
 interface RpcTargetBranded {
   [__RPC_TARGET_BRAND]: never;
 }
 
 // Types that can be used through `Stub`s
-type Stubable = RpcTargetBranded | ((...args: any[]) => any);
+// `never[]` preserves compatibility with strongly-typed function signatures without introducing
+// `any` into inference.
+type Stubable = RpcTargetBranded | ((...args: never[]) => unknown);
+
+type IsUnknown<T> = unknown extends T ? ([T] extends [unknown] ? true : false) : false;
 
 // Types that can be passed over RPC
 // The reason for using a generic type here is to build a serializable subset of structured
 //   cloneable composite types. This allows types defined with the "interface" keyword to pass the
 //   serializable check as well. Otherwise, only types defined with the "type" keyword would pass.
 type RpcCompatible<T> =
+  // Allow `unknown` as a leaf so records/interfaces with `unknown` fields remain compatible.
+  | (IsUnknown<T> extends true ? unknown : never)
   // Structured cloneables
   | BaseType
   // Structured cloneable composites
@@ -45,7 +53,7 @@ type RpcCompatible<T> =
 
 // Base type for all RPC stubs, including common memory management methods.
 // `T` is used as a marker type for unwrapping `Stub`s later.
-interface StubBase<T extends RpcCompatible<T>> extends Disposable {
+interface StubBase<T = unknown> extends Disposable {
   [__RPC_STUB_BRAND]: T;
   dup(): this;
   onRpcBroken(callback: (error: any) => void): void;
@@ -102,7 +110,7 @@ type Stubify<T> =
   : T extends ReadonlyArray<infer V> ? ReadonlyArray<Stubify<V>>
   : T extends BaseType ? T
   // When using "unknown" instead of "any", interfaces are not stubified.
-  : T extends { [key: string | number]: any } ? { [K in keyof T]: Stubify<T[K]> }
+  : T extends { [key: string | number]: any } ? { [K in keyof T as K extends string | number ? K : never]: Stubify<T[K]> }
   : T;
 
 // Recursively rewrite all `Stub<T>`s with the corresponding `T`s.
@@ -110,7 +118,10 @@ type Stubify<T> =
 // `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`.
 // prettier-ignore
 type UnstubifyInner<T> =
-  T extends StubBase<infer V> ? (T | V)  // can provide either stub or local RpcTarget
+  // Preserve local RpcTarget acceptance, but avoid needless `Stub | Value` unions when the stub
+  // is already assignable to the value type (important for callback contextual typing).
+  T extends StubBase<infer V> ? (T extends V ? UnstubifyInner<V> : (T | UnstubifyInner<V>))
+  : T extends Promise<infer U> ? UnstubifyInner<U>
   : T extends Map<infer K, infer V> ? Map<Unstubify<K>, Unstubify<V>>
   : T extends Set<infer V> ? Set<Unstubify<V>>
   : T extends [] ? []
@@ -120,14 +131,30 @@ type UnstubifyInner<T> =
   : T extends Array<infer V> ? Array<Unstubify<V>>
   : T extends ReadonlyArray<infer V> ? ReadonlyArray<Unstubify<V>>
   : T extends BaseType ? T
-  : T extends { [key: string | number]: unknown } ? { [K in keyof T]: Unstubify<T[K]> }
+  : T extends { [key: string | number]: unknown } ? { [K in keyof T as K extends string | number ? K : never]: Unstubify<T[K]> }
   : T;
 
 // You can put promises anywhere in the params and they'll be resolved before delivery.
 // (This also covers RpcPromise, because it's defined as being a Promise.)
-type Unstubify<T> = UnstubifyInner<T> | Promise<UnstubifyInner<T>>
+// Map placeholders are also allowed so primitive map callback inputs can be forwarded directly
+// into RPC params.
+//
+// Keep raw non-stub members so generic assignability still works when UnstubifyInner<T> is deferred.
+// Remove stub members from mixed unions so callback params don’t get both stub and unstubbed signatures.
+// Marker carried by map() callback inputs. This lets primitive placeholders flow through params.
+type Unstubify<T> =
+  | NonStubMembers<T>
+  | UnstubifyInner<T>
+  | Promise<UnstubifyInner<T>>
+  | MapValuePlaceholder<UnstubifyInner<T>>;
+
+type UnstubifyAll<A extends readonly unknown[]> = { [I in keyof A]: Unstubify<A[I]> };
 
-type UnstubifyAll<A extends any[]> = { [I in keyof A]: Unstubify<A[I]> };
+interface MapValuePlaceholder<T> {
+  [__RPC_MAP_VALUE_BRAND]: T;
+}
+
+type NonStubMembers<T> = Exclude<T, StubBase<any>>;
 
 // Utility type for adding `Disposable`s to `object` types only.
 // Note `unknown & T` is equivalent to `T`.
@@ -142,17 +169,22 @@ type MaybeDisposable<T> = T extends object ? Disposable : unknown;
 // Intersecting with `(Maybe)Provider` allows pipelining.
 // prettier-ignore
 type Result<R> =
-  R extends Stubable ? Promise<Stub<R>> & Provider<R> & StubBase<R>
+  IsAny<R> extends true ? UnknownResult
+  : IsUnknown<R> extends true ? UnknownResult
+  : R extends Stubable ? Promise<Stub<R>> & Provider<R> & StubBase<R>
   : R extends RpcCompatible<R> ? Promise<Stubify<R> & MaybeDisposable<R>> & Provider<R> & StubBase<R>
   : never;
 
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+type UnknownResult = Promise<unknown> & Provider<unknown> & StubBase<unknown>;
+
 // Type for method or property on an RPC interface.
 // For methods, unwrap `Stub`s in parameters, and rewrite returns to be `Result`s.
 // Unwrapping `Stub`s allows calling with `Stubable` arguments.
 // For properties, rewrite types to be `Result`s.
 // In each case, unwrap `Promise`s.
 type MethodOrProperty<V> = V extends (...args: infer P) => infer R
-  ? (...args: UnstubifyAll<P>) => Result<Awaited<R>>
+  ? (...args: UnstubifyAll<P>) => IsAny<R> extends true ? UnknownResult : Result<Awaited<R>>
   : Result<Awaited<V>>;
 
 // Type for the callable part of an `Provider` if `T` is callable.
@@ -161,22 +193,62 @@ type MaybeCallableProvider<T> = T extends (...args: any[]) => any
   ? MethodOrProperty<T>
   : unknown;
 
+type TupleIndexKeys<T extends ReadonlyArray<unknown>> = Extract<keyof T, `${number}`>;
+type MapCallbackValue<T> =
+  // `Omit` removes call signatures, so re-intersect callable provider behavior.
+  T extends unknown
+    ? Omit<Result<T>, keyof Promise<unknown>> &
+        MaybeCallableProvider<T> &
+        MapValuePlaceholder<T>
+    : never;
+type InvalidNativePromiseInMapResult<T, Seen = never> =
+  T extends unknown ? InvalidNativePromiseInMapResultImpl<T, Seen> : never;
+type InvalidNativePromiseInMapResultImpl<T, Seen> =
+  [T] extends [Seen] ? never
+  // RpcPromise is modeled as Promise & StubBase, so allow promise-like stub values.
+  : T extends StubBase<any> ? never
+  // Native thenables cannot be represented in map recordings, even when typed as PromiseLike.
+  : T extends PromiseLike<unknown> ? T
+  : T extends Map<infer K, infer V>
+    ? InvalidNativePromiseInMapResult<K, Seen | T> |
+        InvalidNativePromiseInMapResult<V, Seen | T>
+  : T extends Set<infer V> ? InvalidNativePromiseInMapResult<V, Seen | T>
+  : T extends readonly [] ? never
+  : T extends readonly [infer Head, ...infer Tail]
+    ? InvalidNativePromiseInMapResult<Head, Seen | T> |
+        InvalidNativePromiseInMapResult<Tail[number], Seen | T>
+  : T extends ReadonlyArray<infer V> ? InvalidNativePromiseInMapResult<V, Seen | T>
+  : T extends { [key: string | number]: unknown }
+    ? InvalidNativePromiseInMapResult<
+        T[Extract<keyof T, string | number>],
+        Seen | T
+      >
+  : never;
+type MapCallbackReturn<T> =
+  InvalidNativePromiseInMapResult<T> extends never ? T : never;
+type ArrayProvider<E> = {
+  [K in number]: MethodOrProperty<E>;
+} & {
+  map<V>(callback: (elem: MapCallbackValue<E>) => MapCallbackReturn<V>): Result<Array<V>>;
+};
+type TupleProvider<T extends ReadonlyArray<unknown>> = {
+  [K in TupleIndexKeys<T>]: MethodOrProperty<T[K]>;
+} & ArrayProvider<T[number]>;
+
 // Base type for all other types providing RPC-like interfaces.
 // Rewrites all methods/properties to be `MethodOrProperty`s, while preserving callable types.
 type Provider<T> = MaybeCallableProvider<T> &
-  (T extends Array<infer U>
-    ? {
-        [key: number]: MethodOrProperty<U>;
-      } & {
-        map<V>(callback: (elem: U) => V): Result<Array<V>>;
-      }
+  (T extends ReadonlyArray<unknown>
+    ? number extends T["length"] ? ArrayProvider<T[number]> : TupleProvider<T>
     : {
         [K in Exclude<
           keyof T,
           symbol | keyof StubBase<never>
         >]: MethodOrProperty<T[K]>;
       } & {
-        map<V>(callback: (value: NonNullable<T>) => V): Result<Array<V>>;
+        map<V>(
+          callback: (value: MapCallbackValue<NonNullable<T>>) => MapCallbackReturn<V>
+        ): Result<Array<V>>;
       });
 
 /**

package/dist/index.js

@@ -24,6 +24,7 @@ var RpcTarget = workersModule ? workersModule.RpcTarget : class {
 };
 var AsyncFunction = (async function() {
 }).constructor;
+var BUFFER_PROTOTYPE = typeof Buffer !== "undefined" ? Buffer.prototype : void 0;
 function typeForRpc(value) {
   switch (typeof value) {
     case "boolean":
@@ -55,11 +56,18 @@ function typeForRpc(value) {
     case Date.prototype:
       return "date";
     case Uint8Array.prototype:
+    case BUFFER_PROTOTYPE:
       return "bytes";
     case WritableStream.prototype:
       return "writable";
     case ReadableStream.prototype:
       return "readable";
+    case Headers.prototype:
+      return "headers";
+    case Request.prototype:
+      return "request";
+    case Response.prototype:
+      return "response";
     // TODO: All other structured clone types.
     case RpcStub.prototype:
       return "stub";
@@ -613,6 +621,22 @@ var RpcPayload = class _RpcPayload {
         this.hooks.push(hook);
         return stream;
       }
+      case "headers":
+        return new Headers(value);
+      case "request": {
+        let req = value;
+        if (req.body) {
+          this.deepCopy(req.body, req, "body", req, dupStubs, owner);
+        }
+        return new Request(req);
+      }
+      case "response": {
+        let resp = value;
+        if (resp.body) {
+          this.deepCopy(resp.body, resp, "body", resp, dupStubs, owner);
+        }
+        return new Response(resp.body, resp);
+      }
       default:
         throw new Error("unreachable");
     }
@@ -792,6 +816,18 @@ var RpcPayload = class _RpcPayload {
       }
       case "rpc-thenable":
         return;
+      case "headers":
+        return;
+      case "request": {
+        let req = value;
+        if (req.body) this.disposeImpl(req.body, req);
+        return;
+      }
+      case "response": {
+        let resp = value;
+        if (resp.body) this.disposeImpl(resp.body, resp);
+        return;
+      }
       case "writable": {
         let stream = value;
         let hook = this.rpcTargets?.get(stream);
@@ -847,6 +883,9 @@ var RpcPayload = class _RpcPayload {
       case "rpc-target":
       case "writable":
       case "readable":
+      case "headers":
+      case "request":
+      case "response":
         return;
       case "array": {
         let array = value;
@@ -930,6 +969,9 @@ function followPath(value, parent, path, owner) {
       case "bytes":
       case "date":
       case "error":
+      case "headers":
+      case "request":
+      case "response":
         value = void 0;
         break;
       case "undefined":
@@ -1344,12 +1386,86 @@ var Devaluator = class _Devaluator {
         let bytes = value;
         if (bytes.toBase64) {
           return ["bytes", bytes.toBase64({ omitPadding: true })];
-        } else {
-          return [
-            "bytes",
-            btoa(String.fromCharCode.apply(null, bytes).replace(/=*$/, ""))
-          ];
         }
+        let b64;
+        if (typeof Buffer !== "undefined") {
+          let buf = bytes instanceof Buffer ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+          b64 = buf.toString("base64");
+        } else {
+          let binary = "";
+          for (let i = 0; i < bytes.length; i++) {
+            binary += String.fromCharCode(bytes[i]);
+          }
+          b64 = btoa(binary);
+        }
+        return ["bytes", b64.replace(/=+$/, "")];
+      }
+      case "headers":
+        return ["headers", [...value]];
+      case "request": {
+        let req = value;
+        let init = {};
+        if (req.method !== "GET") init.method = req.method;
+        let headers = [...req.headers];
+        if (headers.length > 0) {
+          init.headers = headers;
+        }
+        if (req.body) {
+          init.body = this.devaluateImpl(req.body, req, depth + 1);
+          init.duplex = req.duplex || "half";
+        } else if (req.body === void 0 && !["GET", "HEAD", "OPTIONS", "TRACE", "DELETE"].includes(req.method)) {
+          let bodyPromise = req.arrayBuffer();
+          let readable = new ReadableStream({
+            async start(controller) {
+              try {
+                controller.enqueue(new Uint8Array(await bodyPromise));
+                controller.close();
+              } catch (err) {
+                controller.error(err);
+              }
+            }
+          });
+          let hook = streamImpl.createReadableStreamHook(readable);
+          let importId = this.exporter.createPipe(readable, hook);
+          init.body = ["readable", importId];
+          init.duplex = req.duplex || "half";
+        }
+        if (req.cache && req.cache !== "default") init.cache = req.cache;
+        if (req.redirect !== "follow") init.redirect = req.redirect;
+        if (req.integrity) init.integrity = req.integrity;
+        if (req.mode && req.mode !== "cors") init.mode = req.mode;
+        if (req.credentials && req.credentials !== "same-origin") {
+          init.credentials = req.credentials;
+        }
+        if (req.referrer && req.referrer !== "about:client") init.referrer = req.referrer;
+        if (req.referrerPolicy) init.referrerPolicy = req.referrerPolicy;
+        if (req.keepalive) init.keepalive = req.keepalive;
+        let cfReq = req;
+        if (cfReq.cf) init.cf = cfReq.cf;
+        if (cfReq.encodeResponseBody && cfReq.encodeResponseBody !== "automatic") {
+          init.encodeResponseBody = cfReq.encodeResponseBody;
+        }
+        return ["request", req.url, init];
+      }
+      case "response": {
+        let resp = value;
+        let body = this.devaluateImpl(resp.body, resp, depth + 1);
+        let init = {};
+        if (resp.status !== 200) init.status = resp.status;
+        if (resp.statusText) init.statusText = resp.statusText;
+        let headers = [...resp.headers];
+        if (headers.length > 0) {
+          init.headers = headers;
+        }
+        let cfResp = resp;
+        if (cfResp.cf) init.cf = cfResp.cf;
+        if (cfResp.encodeBody && cfResp.encodeBody !== "automatic") {
+          init.encodeBody = cfResp.encodeBody;
+        }
+        if (cfResp.webSocket) {
+          throw new TypeError("Can't serialize a Response containing a webSocket.");
+        }
+        return ["response", body, init];
       }
       case "error": {
         let e = value;
@@ -1450,6 +1566,14 @@ var NullImporter = class {
   }
 };
 var NULL_IMPORTER = new NullImporter();
+function fixBrokenRequestBody(request, body) {
+  let promise = new Response(body).arrayBuffer().then((arrayBuffer) => {
+    let bytes = new Uint8Array(arrayBuffer);
+    let result = new Request(request, { body: bytes });
+    return new PayloadStubHook(RpcPayload.fromAppReturn(result));
+  });
+  return new RpcPromise(new PromiseStubHook(promise), []);
+}
 var Evaluator = class _Evaluator {
   constructor(importer) {
     this.importer = importer;
@@ -1490,10 +1614,11 @@ var Evaluator = class _Evaluator {
           }
           break;
         case "bytes": {
-          let b64 = Uint8Array;
           if (typeof value[1] == "string") {
-            if (b64.fromBase64) {
-              return b64.fromBase64(value[1]);
+            if (typeof Buffer !== "undefined") {
+              return Buffer.from(value[1], "base64");
+            } else if (Uint8Array.fromBase64) {
+              return Uint8Array.fromBase64(value[1]);
             } else {
               let bs = atob(value[1]);
               let len = bs.length;
@@ -1527,6 +1652,56 @@ var Evaluator = class _Evaluator {
           return -Infinity;
         case "nan":
           return NaN;
+        case "headers":
+          if (value.length === 2 && value[1] instanceof Array) {
+            return new Headers(value[1]);
+          }
+          break;
+        case "request": {
+          if (value.length !== 3 || typeof value[1] !== "string") break;
+          let url = value[1];
+          let init = value[2];
+          if (typeof init !== "object" || init === null) break;
+          if (init.body) {
+            init.body = this.evaluateImpl(init.body, init, "body");
+            if (init.body === null || typeof init.body === "string" || init.body instanceof Uint8Array || init.body instanceof ReadableStream) ; else {
+              throw new TypeError("Request body must be of type ReadableStream.");
+            }
+          }
+          if (init.signal) {
+            init.signal = this.evaluateImpl(init.signal, init, "signal");
+            if (!(init.signal instanceof AbortSignal)) {
+              throw new TypeError("Request siganl must be of type AbortSignal.");
+            }
+          }
+          if (init.headers && !(init.headers instanceof Array)) {
+            throw new TypeError("Request headers must be serialized as an array of pairs.");
+          }
+          let result = new Request(url, init);
+          if (init.body instanceof ReadableStream && result.body === void 0) {
+            let promise = fixBrokenRequestBody(result, init.body);
+            this.promises.push({ promise, parent, property });
+            return promise;
+          } else {
+            return result;
+          }
+        }
+        case "response": {
+          if (value.length !== 3) break;
+          let body = this.evaluateImpl(value[1], parent, property);
+          if (body === null || typeof body === "string" || body instanceof Uint8Array || body instanceof ReadableStream) ; else {
+            throw new TypeError("Response body must be of type ReadableStream.");
+          }
+          let init = value[2];
+          if (typeof init !== "object" || init === null) break;
+          if (init.webSocket) {
+            throw new TypeError("Can't deserialize a Response containing a webSocket.");
+          }
+          if (init.headers && !(init.headers instanceof Array)) {
+            throw new TypeError("Request headers must be serialized as an array of pairs.");
+          }
+          return new Response(body, init);
+        }
         case "import":
         case "pipeline": {
           if (value.length < 2 || value.length > 4) {