capnweb 0.0.0-e3fa093 → 0.0.0-ee7ca6f

package/dist/index.d.cts

@@ -1,139 +1,75 @@
-import { IncomingMessage, ServerResponse, OutgoingHttpHeaders, OutgoingHttpHeader } from 'node:http';
+import { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from "node:http";
 
+//#region src/types.d.ts
 // 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';
+// 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);
-
-// 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
+// `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 the serializable subset of RPC-compatible
+//   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 RpcCompatible<T> = // Allow `unknown` as a leaf so records/interfaces with `unknown` fields remain compatible.
+(IsUnknown<T> extends true ? unknown : never) // RPC-compatible base values
+| BaseType // RPC-compatible 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;
 // 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;
 }
-type Stub<T extends RpcCompatible<T>> =
-    T extends object ? Provider<T> & StubBase<T> : StubBase<T>;
-
-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<Uint8Array>
-  | Request
-  | Response
-  | Headers;
-// Recursively rewrite all `Stubable` types with `Stub`s, and resolve promises.
+type Stub<T extends RpcCompatible<T>> = T extends object ? Provider<T> & StubBase<T> : StubBase<T>;
+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 | Blob | ReadableStream<Uint8Array> | WritableStream<any> // Chunk type can be any RPC-compatible type
+| Request | Response | Headers; // 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]: Stubify<T[K]> }
-  : T;
-
+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> =
-  T extends StubBase<infer V> ? (T | V)  // can provide either stub or local RpcTarget
-  : 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]: Unstubify<T[K]> }
-  : T;
-
-// You can put promises anywhere in the params and they'll be resolved before delivery.
+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 any[]> = { [I in keyof A]: Unstubify<A[I]> };
-
-// Utility type for adding `Disposable`s to `object` types only.
+// 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]> };
+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`.
-type MaybeDisposable<T> = T extends object ? Disposable : unknown;
-
-// Type for method return or property on an RPC interface.
+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`.
@@ -141,44 +77,62 @@ type MaybeDisposable<T> = T extends object ? Disposable : unknown;
 // Technically, we use custom thenables here, but they quack like `Promise`s.
 // Intersecting with `(Maybe)Provider` allows pipelining.
 // prettier-ignore
-type Result<R> =
-  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.
+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 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>>
-  : Result<Awaited<V>>;
-
-// Type for the callable part of an `Provider` if `T` is callable.
+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;
-
-// Base type for all other types providing RPC-like interfaces.
+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>>;
-      }
-    : {
-        [K in Exclude<
-          keyof T,
-          symbol | keyof StubBase<never>
-        >]: MethodOrProperty<T[K]>;
-      } & {
-        map<V>(callback: (value: NonNullable<T>) => V): Result<Array<V>>;
-      });
-
+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>>) => MapCallbackReturn<V>): Result<Array<V>>;
+});
+//#endregion
+//#region src/serialize.d.ts
+/**
+ * Encoding levels determine what representation the RPC system hands to the transport.
+ * Each level names what the transport can assume about message values.
+ *
+ * - `"string"`: JSON string. Default, used by HTTP batch and WebSocket transports.
+ * - `"jsonCompatible"`: JSON-compatible JS value tree. For custom encoders.
+ * - `"jsonCompatibleWithBytes"`: Like `"jsonCompatible"` but Uint8Array stays raw.
+ * - `"structuredClonable"`: Structured-clonable native values pass through where possible.
+ *
+ * @example
+ * ```ts
+ * // What happens to Uint8Array([1, 2, 3]) at each level:
+ * "string"          → '["bytes","AQID"]'           // JSON string with base64
+ * "jsonCompatible"          → ["bytes", "AQID"]      // JS array with base64
+ * "jsonCompatibleWithBytes" → ["bytes", Uint8Array]  // JS array with raw bytes
+ * "structuredClonable"      → ["bytes", Uint8Array]  // + Date, BigInt stay native
+ * ```
+ */
+type EncodingLevel = "string" | "jsonCompatible" | "jsonCompatibleWithBytes" | "structuredClonable";
+interface RpcLimits {
+  maxBigIntDigits: number;
+  maxDepth: number;
+  maxMessageSize: number;
+}
+declare const DEFAULT_MAX_DEPTH = 256;
+declare const DEFAULT_LIMITS: RpcLimits;
 /**
  * Serialize a value, using Cap'n Web's underlying serialization. This won't be able to serialize
  * RPC stubs, but it will support basic data types.
@@ -188,59 +142,129 @@ declare function serialize(value: unknown): string;
  * Deserialize a value serialized using serialize().
  */
 declare function deserialize(value: string): unknown;
-
+//#endregion
+//#region src/rpc.d.ts
 /**
- * Interface for an RPC transport, which is a simple bidirectional message stream. Implement this
- * interface if the built-in transports (e.g. for HTTP batch and WebSocket) don't meet your needs.
+ * Interface for a string-based RPC transport. This is the default transport type — no
+ * `encodingLevel` field is needed. Messages are JSON strings. Implement this interface if the
+ * built-in transports (e.g. for HTTP batch and WebSocket) don't meet your needs.
  */
 interface RpcTransport {
-    /**
-     * Sends a message to the other end.
-     */
-    send(message: string): Promise<void>;
-    /**
-     * Receives a message sent by the other end.
-     *
-     * If and when the transport becomes disconnected, this will reject. The thrown error will be
-     * propagated to all outstanding calls and future calls on any stubs associated with the session.
-     * If there are no outstanding calls (and none are made in the future), then the error does not
-     * propagate anywhere -- this is considered a "clean" shutdown.
-     */
-    receive(): Promise<string>;
-    /**
-     * Indicates that the RPC system has suffered an error that prevents the session from continuing.
-     * The transport should ideally try to send any queued messages if it can, and then close the
-     * connection. (It's not strictly necessary to deliver queued messages, but the last message sent
-     * before abort() is called is often an "abort" message, which communicates the error to the
-     * peer, so if that is dropped, the peer may have less information about what happened.)
-     */
-    abort?(reason: any): void;
+  /**
+   * The encoding level this transport works with. For this interface it is always "string";
+   * it may be omitted. (See `RpcTransportWithCustomEncoding` for the other levels.)
+   */
+  readonly encodingLevel?: "string";
+  /**
+   * Sends a message to the other end. May optionally return a promise; if the promise rejects,
+   * the session is aborted.
+   */
+  send(message: string): void | Promise<void>;
+  /**
+   * Receives a message sent by the other end.
+   *
+   * If and when the transport becomes disconnected, this will reject. The thrown error will be
+   * propagated to all outstanding calls and future calls on any stubs associated with the session.
+   * If there are no outstanding calls (and none are made in the future), then the error does not
+   * propagate anywhere -- this is considered a "clean" shutdown.
+   */
+  receive(): Promise<string>;
+  /**
+   * Indicates that the RPC system has suffered an error that prevents the session from continuing.
+   * The transport should ideally try to send any queued messages if it can, and then close the
+   * connection. (It's not strictly necessary to deliver queued messages, but the last message sent
+   * before abort() is called is often an "abort" message, which communicates the error to the
+   * peer, so if that is dropped, the peer may have less information about what happened.)
+   */
+  abort?(reason: any): void;
+}
+/**
+ * Interface for a transport that receives partially encoded JS values instead of JSON strings.
+ * The selected `encodingLevel` describes what the transport can assume about message values.
+ */
+interface RpcTransportWithCustomEncoding {
+  /**
+   * The encoding level this transport works with.
+   *
+   * - "jsonCompatible": JSON-compatible JS value tree; transport handles final serialization.
+   * - "jsonCompatibleWithBytes": Like "jsonCompatible" but Uint8Array values are left raw.
+   * - "structuredClonable": Structured-clonable native values pass through where possible.
+   */
+  readonly encodingLevel: "jsonCompatible" | "jsonCompatibleWithBytes" | "structuredClonable";
+  /**
+   * Encodes and sends a message to the other end. Returns the encoded byte size if known.
+   * If the size is unavailable, return void; Cap'n Web will estimate stream message sizes for
+   * flow control. Send errors should be propagated via `receive()` rejecting.
+   */
+  send(message: unknown): number | void;
+  /**
+   * Receives and decodes a message sent by the other end.
+   *
+   * If and when the transport becomes disconnected, this will reject. The thrown error will be
+   * propagated to all outstanding calls and future calls on any stubs associated with the session.
+   * If there are no outstanding calls (and none are made in the future), then the error does not
+   * propagate anywhere -- this is considered a "clean" shutdown.
+   */
+  receive(): Promise<unknown>;
+  /**
+   * Indicates that the RPC system has suffered an error that prevents the session from continuing.
+   * The transport should ideally try to send any queued messages if it can, and then close the
+   * connection. (It's not strictly necessary to deliver queued messages, but the last message sent
+   * before abort() is called is often an "abort" message, which communicates the error to the
+   * peer, so if that is dropped, the peer may have less information about what happened.)
+   */
+  abort?(reason: any): void;
 }
+/** Any supported transport type. */
+type AnyRpcTransport = RpcTransport | RpcTransportWithCustomEncoding;
 /**
  * Options to customize behavior of an RPC session. All functions which start a session should
  * optionally accept this.
  */
 type RpcSessionOptions = {
-    /**
-     * If provided, this function will be called whenever an `Error` object is serialized (for any
-     * reason, not just because it was thrown). This can be used to log errors, and also to redact
-     * them.
-     *
-     * If `onSendError` returns an Error object, than object will be substituted in place of the
-     * original. If it has a stack property, the stack will be sent to the client.
-     *
-     * If `onSendError` doesn't return anything (or is not provided at all), the default behavior is
-     * to serialize the error with the stack omitted.
-     */
-    onSendError?: (error: Error) => Error | void;
+  /**
+   * If provided, this function will be called whenever an `Error` object is serialized (for any
+   * reason, not just because it was thrown). This can be used to log errors, and also to redact
+   * them.
+   *
+   * If `onSendError` returns an Error object, than object will be substituted in place of the
+   * original. If it has a stack property, the stack will be sent to the client.
+   *
+   * If `onSendError` doesn't return anything (or is not provided at all), the default behavior is
+   * to serialize the error with the stack omitted.
+   */
+  onSendError?: (error: Error) => Error | void;
+  /**
+   * Overrides for the resource limits enforced while deserializing messages from the peer. Any
+   * field left unset falls back to `DEFAULT_LIMITS`. These guard against resource-exhaustion
+   * attacks from untrusted peers; see `RpcLimits` for the meaning and defaults of each field.
+   *
+   * Limits are a purely local, receiver-side decision -- the protocol has no negotiation step, so
+   * the peer never learns these values. A message that exceeds a limit is rejected, aborting the
+   * session.
+   */
+  limits?: Partial<RpcLimits>;
 };
-
+//#endregion
+//#region src/websocket.d.ts
 /**
  * For use in Cloudflare Workers: Construct an HTTP response that starts a WebSocket RPC session
  * with the given `localMain`.
  */
 declare function newWorkersWebSocketRpcResponse(request: Request, localMain?: any, options?: RpcSessionOptions): Response;
-
+/**
+ * Generic WebSocket transport. Default `T = string` is backward-compatible and satisfies
+ * `RpcTransport`. Use `T = ArrayBuffer` as a building block for binary transports.
+ */
+declare class WebSocketTransport<T extends string | ArrayBuffer = string> {
+  #private;
+  constructor(webSocket: WebSocket);
+  send(message: T): void;
+  receive(): Promise<T>;
+  abort(reason: any): void;
+}
+//#endregion
+//#region src/batch.d.ts
 /**
  * Implements the server end of an HTTP batch session, using standard Fetch API types to represent
  * HTTP requests and responses.
@@ -261,9 +285,10 @@ declare function newHttpBatchRpcResponse(request: Request, localMain: any, optio
  * @param options Optional RPC session options. You can also pass headers to set on the response.
  */
 declare function nodeHttpBatchRpcResponse(request: IncomingMessage, response: ServerResponse, localMain: any, options?: RpcSessionOptions & {
-    headers?: OutgoingHttpHeaders | OutgoingHttpHeader[];
+  headers?: OutgoingHttpHeaders | OutgoingHttpHeader[];
 }): Promise<void>;
-
+//#endregion
+//#region src/index.d.ts
 /**
  * Represents a reference to a remote object, on which methods may be remotely invoked via RPC.
  *
@@ -276,7 +301,7 @@ declare function nodeHttpBatchRpcResponse(request: IncomingMessage, response: Se
  */
 type RpcStub<T extends RpcCompatible<T>> = Stub<T>;
 declare const RpcStub: {
-    new <T extends RpcCompatible<T>>(value: T): RpcStub<T>;
+  new <T extends RpcCompatible<T>>(value: T): RpcStub<T>;
 };
 /**
  * Represents the result of an RPC call.
@@ -304,15 +329,15 @@ declare const RpcPromise: {};
  * Most people won't use this. You only need it if you've implemented your own `RpcTransport`.
  */
 interface RpcSession<T extends RpcCompatible<T> = undefined> {
-    getRemoteMain(): RpcStub<T>;
-    getStats(): {
-        imports: number;
-        exports: number;
-    };
-    drain(): Promise<void>;
+  getRemoteMain(): RpcStub<T>;
+  getStats(): {
+    imports: number;
+    exports: number;
+  };
+  drain(): Promise<void>;
 }
 declare const RpcSession: {
-    new <T extends RpcCompatible<T> = undefined>(transport: RpcTransport, localMain?: any, options?: RpcSessionOptions): RpcSession<T>;
+  new <T extends RpcCompatible<T> = undefined>(transport: AnyRpcTransport, localMain?: any, options?: RpcSessionOptions): RpcSession<T>;
 };
 /**
  * Classes which are intended to be passed by reference and called over RPC must extend
@@ -322,17 +347,15 @@ declare const RpcSession: {
  * Note that on Cloudflare Workers, this `RpcTarget` is an alias for the one exported from the
  * "cloudflare:workers" module, so they can be used interchangably.
  */
-interface RpcTarget extends RpcTargetBranded {
-}
+interface RpcTarget extends RpcTargetBranded {}
 declare const RpcTarget: {
-    new (): RpcTarget;
+  new (): RpcTarget;
 };
 /**
  * Empty interface used as default type parameter for sessions where the other side doesn't
  * necessarily export a main interface.
  */
-interface Empty {
-}
+interface Empty {}
 /**
  * Start a WebSocket session given either an already-open WebSocket or a URL.
  *
@@ -367,6 +390,7 @@ declare let newMessagePortRpcSession: <T extends RpcCompatible<T> = Empty>(port:
  * credentials as parameters and returns the authorized API), then cross-origin requests should
  * be safe.
  */
-declare function newWorkersRpcResponse(request: Request, localMain: any): Promise<Response>;
-
-export { type RpcCompatible, RpcPromise, RpcSession, type RpcSessionOptions, RpcStub, RpcTarget, type RpcTransport, deserialize, newHttpBatchRpcResponse, newHttpBatchRpcSession, newMessagePortRpcSession, newWebSocketRpcSession, newWorkersRpcResponse, newWorkersWebSocketRpcResponse, nodeHttpBatchRpcResponse, serialize };
+declare function newWorkersRpcResponse(request: Request, localMain: any, options?: RpcSessionOptions): Promise<Response>;
+//#endregion
+export { type AnyRpcTransport, DEFAULT_LIMITS, DEFAULT_MAX_DEPTH, type EncodingLevel, type RpcCompatible, type RpcLimits, RpcPromise, RpcSession, type RpcSessionOptions, RpcStub, RpcTarget, type RpcTransport, type RpcTransportWithCustomEncoding, WebSocketTransport, deserialize, newHttpBatchRpcResponse, newHttpBatchRpcSession, newMessagePortRpcSession, newWebSocketRpcSession, newWorkersRpcResponse, newWorkersWebSocketRpcResponse, nodeHttpBatchRpcResponse, serialize };
+//# sourceMappingURL=index.d.cts.map