npm - @vastblast/capnweb - Versions diffs - 0.4.3 → 0.5.0 - Mend

@vastblast/capnweb 0.4.3 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of @vastblast/capnweb might be problematic. Click here for more details.

Files changed (12) hide show

package/README.md +1 -1
package/dist/index-workers.cjs +165 -0
package/dist/index-workers.cjs.map +1 -1
package/dist/index-workers.js +165 -0
package/dist/index-workers.js.map +1 -1
package/dist/index.cjs +165 -0
package/dist/index.cjs.map +1 -1
package/dist/index.d.cts +207 -202
package/dist/index.d.ts +207 -202
package/dist/index.js +165 -0
package/dist/index.js.map +1 -1
package/package.json +1 -1

package/dist/index.d.ts CHANGED Viewed

@@ -1,207 +1,212 @@
 import { IncomingMessage, ServerResponse, OutgoingHttpHeaders, OutgoingHttpHeader } from 'node:http';
-// Copyright (c) 2025 Cloudflare, Inc.
-// Licensed under the MIT license found in the LICENSE.txt file or at:
-//     https://opensource.org/license/mit
-// This file borrows heavily from `types/defines/rpc.d.ts` in workerd.
-// Branded types for identifying `WorkerEntrypoint`/`DurableObject`/`Target`s.
-// TypeScript uses *structural* typing meaning anything with the same shape as type `T` is a `T`.
-// For the classes exported by `cloudflare:workers` we want *nominal* typing (i.e. we only want to
-// 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';
-interface RpcTargetBranded {
-  [__RPC_TARGET_BRAND]: never;
-}
-type IsAny<T> = 0 extends (1 & T) ? true : false;
-type IsUnknown<T> = unknown extends T ? ([T] extends [unknown] ? true : false) : false;
-// Types that can be used through `Stub`s.
-// `never[]` preserves compatibility with strongly-typed function signatures without introducing
-// `any` into inference.
-type Stubable = RpcTargetBranded | ((...args: never[]) => unknown);
-type TypedArray =
-  | Uint8Array
-  | Uint8ClampedArray
-  | Uint16Array
-  | Uint32Array
-  | Int8Array
-  | Int16Array
-  | Int32Array
-  | BigUint64Array
-  | BigInt64Array
-  | Float32Array
-  | Float64Array;
-// This represents all the types that can be sent as-is over an RPC boundary.
-type BaseType =
-  | void
-  | undefined
-  | null
-  | boolean
-  | number
-  | bigint
-  | string
-  | TypedArray
-  | ArrayBuffer
-  | DataView
-  | Date
-  | Error
-  | RegExp
-  | ReadableStream<Uint8Array>
-  | WritableStream<any>  // Chunk type can be any RPC-compatible type
-  | Request
-  | Response
-  | Headers;
-// 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 = unknown> extends Disposable {
-  [__RPC_STUB_BRAND]: T;
-  dup(): this;
-  onRpcBroken(callback: (error: any) => void): void;
-}
-// 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> =
-  // Structured cloneables
-  | BaseType
-  // Structured cloneable composites
-  | Map<
-      T extends Map<infer U, unknown> ? RpcCompatible<U> : never,
-      T extends Map<unknown, infer U> ? RpcCompatible<U> : never
-    >
-  | Set<T extends Set<infer U> ? RpcCompatible<U> : never>
-  | Array<T extends Array<infer U> ? RpcCompatible<U> : never>
-  | ReadonlyArray<T extends ReadonlyArray<infer U> ? RpcCompatible<U> : never>
-  | {
-      [K in keyof T as K extends string | number ? K : never]: RpcCompatible<T[K]>;
-    }
-  | Promise<T extends Promise<infer U> ? RpcCompatible<U> : never>
-  // Special types
-  | Stub<Stubable>
-  // Serialized as stubs, see `Stubify`
-  | Stubable;
-type Stub<T extends RpcCompatible<T>> =
-  T extends object ? Provider<T> & StubBase<T> : StubBase<T>;
-// Recursively rewrite all `Stubable` types with `Stub`s, and resolve promises.
-// prettier-ignore
-type Stubify<T> =
-  T extends Stubable ? Stub<T>
-  : T extends Promise<infer U> ? Stubify<U>
-  : T extends StubBase<any> ? T
-  : T extends Map<infer K, infer V> ? Map<Stubify<K>, Stubify<V>>
-  : T extends Set<infer V> ? Set<Stubify<V>>
-  : T extends [] ? []
-  : T extends [infer Head, ...infer Tail] ? [Stubify<Head>, ...Stubify<Tail>]
-  : T extends readonly [] ? readonly []
-  : T extends readonly [infer Head, ...infer Tail] ? readonly [Stubify<Head>, ...Stubify<Tail>]
-  : T extends Array<infer V> ? Array<Stubify<V>>
-  : 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 as K extends string | number ? K : never]: Stubify<T[K]>;
-      }
-  : T;
-// Recursively rewrite all `Stub<T>`s with the corresponding `T`s.
-// Note we use `StubBase` instead of `Stub` here to avoid circular dependencies:
-// `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`.
-// prettier-ignore
-type UnstubifyInner<T> =
-  // 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 [] ? []
-  : T extends [infer Head, ...infer Tail] ? [Unstubify<Head>, ...Unstubify<Tail>]
-  : T extends readonly [] ? readonly []
-  : T extends readonly [infer Head, ...infer Tail] ? readonly [Unstubify<Head>, ...Unstubify<Tail>]
-  : 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 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>>;
-type UnstubifyAll<A extends readonly unknown[]> = { [I in keyof A]: Unstubify<A[I]> };
-// Utility type for adding `Disposable`s to `object` types only.
-// Note `unknown & T` is equivalent to `T`.
-type MaybeDisposable<T> = T extends object ? Disposable : unknown;
-// Type for method return or property on an RPC interface.
-// - Stubable types are replaced by stubs.
-// - RpcCompatible types are passed by value, with stubable types replaced by stubs
-//   and a top-level `Disposer`.
-// Everything else can't be passed over RPC.
-// Technically, we use custom thenables here, but they quack like `Promise`s.
-// Intersecting with `(Maybe)Provider` allows pipelining.
-type UnknownResult = Promise<unknown> & Provider<unknown> & StubBase<unknown>;
-// prettier-ignore
-type Result<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 HasAnyFunctionParts<P extends readonly unknown[], R> =
-  IsAny<R> extends true ? true : IsAny<P[number]>;
-// 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
-  ? HasAnyFunctionParts<P, R> extends true
-    ? (...args: unknown[]) => UnknownResult
-    : (...args: UnstubifyAll<P>) => Result<Awaited<R>>
-  : Result<Awaited<V>>;
-// Type for the callable part of a `Provider` if `T` is callable.
-// This is intersected with methods/properties.
-type MaybeCallableProvider<T> = T extends (...args: any[]) => any
-  ? MethodOrProperty<T>
-  : unknown;
-// 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: Result<U>) => V): Result<Array<V>>;
-      }
-    : {
-        [K in Exclude<
-          keyof T,
-          symbol | keyof StubBase<never>
-        >]: MethodOrProperty<T[K]>;
-      } & {
-        map<V>(callback: (value: Result<NonNullable<T>>) => V): Result<Array<V>>;
+// Copyright (c) 2025 Cloudflare, Inc.
+// Licensed under the MIT license found in the LICENSE.txt file or at:
+//     https://opensource.org/license/mit
+// This file borrows heavily from `types/defines/rpc.d.ts` in workerd.
+// Branded types for identifying `WorkerEntrypoint`/`DurableObject`/`Target`s.
+// TypeScript uses *structural* typing meaning anything with the same shape as type `T` is a `T`.
+// For the classes exported by `cloudflare:workers` we want *nominal* typing (i.e. we only want to
+// 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';
+interface RpcTargetBranded {
+  [__RPC_TARGET_BRAND]: never;
+}
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+type IsUnknown<T> = unknown extends T ? ([T] extends [unknown] ? true : false) : false;
+// Types that can be used through `Stub`s.
+// `never[]` preserves compatibility with strongly-typed function signatures without introducing
+// `any` into inference.
+type Stubable = RpcTargetBranded | ((...args: never[]) => unknown);
+type TypedArray =
+  | Uint8Array
+  | Uint8ClampedArray
+  | Uint16Array
+  | Uint32Array
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | BigUint64Array
+  | BigInt64Array
+  | Float32Array
+  | Float64Array;
+// This represents all the types that can be sent as-is over an RPC boundary
+type BaseType =
+  | void
+  | undefined
+  | null
+  | boolean
+  | number
+  | bigint
+  | string
+  | TypedArray
+  | ArrayBuffer
+  | DataView
+  | Date
+  | Error
+  | RegExp
+  | ReadableStream<Uint8Array>
+  | WritableStream<any>  // Chunk type can be any RPC-compatible type
+  | Request
+  | Response
+  | Headers;
+// 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 = unknown> extends Disposable {
+  [__RPC_STUB_BRAND]: T;
+  dup(): this;
+  onRpcBroken(callback: (error: any) => void): void;
+}
+// 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> =
+  // Structured cloneables
+  | BaseType
+  // Structured cloneable composites
+  | Map<
+      T extends Map<infer U, unknown> ? RpcCompatible<U> : never,
+      T extends Map<unknown, infer U> ? RpcCompatible<U> : never
+    >
+  | Set<T extends Set<infer U> ? RpcCompatible<U> : never>
+  | Array<T extends Array<infer U> ? RpcCompatible<U> : never>
+  | ReadonlyArray<T extends ReadonlyArray<infer U> ? RpcCompatible<U> : never>
+  | {
+      [K in keyof T as K extends string | number ? K : never]: RpcCompatible<T[K]>;
+    }
+  | Promise<T extends Promise<infer U> ? RpcCompatible<U> : never>
+  // Special types
+  | Stub<Stubable>
+  // Serialized as stubs, see `Stubify`
+  | Stubable;
+type Stub<T extends RpcCompatible<T>> =
+  T extends object ? Provider<T> & StubBase<T> : StubBase<T>;
+// Recursively rewrite all `Stubable` types with `Stub`s, and resolve promises.
+// prettier-ignore
+type Stubify<T> =
+  T extends Stubable ? Stub<T>
+  : T extends Promise<infer U> ? Stubify<U>
+  : T extends StubBase<any> ? T
+  : T extends Map<infer K, infer V> ? Map<Stubify<K>, Stubify<V>>
+  : T extends Set<infer V> ? Set<Stubify<V>>
+  : T extends [] ? []
+  : T extends [infer Head, ...infer Tail] ? [Stubify<Head>, ...Stubify<Tail>]
+  : T extends readonly [] ? readonly []
+  : T extends readonly [infer Head, ...infer Tail] ? readonly [Stubify<Head>, ...Stubify<Tail>]
+  : T extends Array<infer V> ? Array<Stubify<V>>
+  : 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 as K extends string | number ? K : never]: Stubify<T[K]>;
+      }
+  : T;
+// Recursively rewrite all `Stub<T>`s with the corresponding `T`s.
+// Note we use `StubBase` instead of `Stub` here to avoid circular dependencies:
+// `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`.
+// prettier-ignore
+type UnstubifyInner<T> =
+  // 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 [] ? []
+  : T extends [infer Head, ...infer Tail] ? [Unstubify<Head>, ...Unstubify<Tail>]
+  : T extends readonly [] ? readonly []
+  : T extends readonly [infer Head, ...infer Tail] ? readonly [Unstubify<Head>, ...Unstubify<Tail>]
+  : 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 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>>;
+type UnstubifyAll<A extends readonly unknown[]> = { [I in keyof A]: Unstubify<A[I]> };
+// Utility type for adding `Disposable`s to `object` types only.
+// Note `unknown & T` is equivalent to `T`.
+type MaybeDisposable<T> = T extends object ? Disposable : unknown;
+// Type for method return or property on an RPC interface.
+// - Stubable types are replaced by stubs.
+// - RpcCompatible types are passed by value, with stubable types replaced by stubs
+//   and a top-level `Disposer`.
+// Everything else can't be passed over RPC.
+// Technically, we use custom thenables here, but they quack like `Promise`s.
+// Intersecting with `(Maybe)Provider` allows pipelining.
+type UnknownResult = Promise<unknown> & Provider<unknown> & StubBase<unknown>;
+// prettier-ignore
+type Result<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 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>) => (IsAny<R> extends true ? UnknownResult : Result<Awaited<R>>)
+  : Result<Awaited<V>>;
+// Type for the callable part of an `Provider` if `T` is callable.
+// This is intersected with methods/properties.
+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> : never;
+type ArrayProvider<E> = {
+  [K in number]: MethodOrProperty<E>;
+} & {
+  map<V>(callback: (elem: MapCallbackValue<E>) => 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 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: MapCallbackValue<NonNullable<T>>) => V): Result<Array<V>>;
       });
 /**

package/dist/index.js CHANGED Viewed

@@ -60,6 +60,12 @@ function typeForRpc(value) {
       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 +619,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 +814,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 +881,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 +967,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":
@@ -1351,6 +1391,73 @@ var Devaluator = class _Devaluator {
           ];
         }
       }
+      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;
         let rewritten = this.exporter.onSendError(e);
@@ -1450,6 +1557,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;
@@ -1527,6 +1642,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) {