@igoforth/ws-rpc 1.0.0

package/dist/adapters/types.d.ts

@@ -0,0 +1,125 @@
+import { f as MethodDef, h as StringKeys, i as EventHandler, l as InferOutput, m as RpcSchema, s as InferInput, t as Driver } from "../schema-CN5HHHku.js";
+import "../factory-C1v0AEHY.js";
+import "../json-54Z2bIIs.js";
+import "../index-Be7jjS77.js";
+import "../protocol-DA84zrc2.js";
+import { a as IRpcOptions, n as IMethodController, t as IEventController } from "../types-Be-qmQu0.js";
+import { t as RpcPeer } from "../default-xDNNMrg0.js";
+import { n as calculateReconnectDelay, r as defaultReconnectOptions, t as ReconnectOptions } from "../reconnect-DbcN0R_1.js";
+
+//#region src/adapters/types.d.ts
+
+/**
+ * Options for driver method calls on multi-connection adapters
+ */
+interface MultiCallOptions {
+  /** Connection ID(s) to call. If omitted, calls all connections. */
+  ids?: string | string[];
+  /** Request timeout in milliseconds */
+  timeout?: number;
+}
+/**
+ * Result of a driver method call on a multi-connection adapter
+ *
+ * Each result contains the peer ID and either a success value or an error.
+ *
+ * @typeParam T - The expected return type of the remote method
+ *
+ * @example
+ * ```ts
+ * const results = await server.driver.ping({});
+ * for (const { id, result } of results) {
+ *   if (result.success) {
+ *     console.log(`Peer ${id} responded:`, result.value);
+ *   } else {
+ *     console.error(`Peer ${id} failed:`, result.error);
+ *   }
+ * }
+ * ```
+ */
+type MultiCallResult<T> = {
+  /** Peer ID that this result is from */
+  id: string;
+  /** Success or failure result */
+  result: {
+    success: true;
+    value: T;
+  } | {
+    success: false;
+    error: Error;
+  };
+};
+/**
+ * Driver type for multi-connection adapters
+ *
+ * Methods accept an optional second argument with `ids` and `timeout`.
+ * Returns an array of results, one per connection called.
+ *
+ * @typeParam TRemoteSchema - Schema defining the remote methods available
+ *
+ * @example
+ * ```ts
+ * // Call all connected peers
+ * const allResults = await server.driver.getData({});
+ *
+ * // Call specific peer by ID
+ * const oneResult = await server.driver.getData({}, { ids: "peer-123" });
+ *
+ * // Call multiple peers with timeout
+ * const someResults = await server.driver.getData({}, {
+ *   ids: ["peer-1", "peer-2"],
+ *   timeout: 5000,
+ * });
+ * ```
+ */
+type MultiDriver<TRemoteSchema extends RpcSchema> = TRemoteSchema["methods"] extends Record<string, MethodDef> ? { [K in StringKeys<TRemoteSchema["methods"]>]: <O extends MultiCallOptions>(input: TRemoteSchema["methods"] extends Record<string, MethodDef> ? InferInput<TRemoteSchema["methods"][K]> : never, options?: O) => Promise<O extends {
+  ids: infer I;
+} ? string extends I ? MultiCallResult<TRemoteSchema["methods"] extends Record<string, MethodDef> ? InferOutput<TRemoteSchema["methods"][K]> : never> : Array<MultiCallResult<TRemoteSchema["methods"] extends Record<string, MethodDef> ? InferOutput<TRemoteSchema["methods"][K]> : never>> : never> } : never;
+/**
+ * Event emitter type for client callbacks
+ */
+interface IAdapterHooks<TRemoteSchema extends RpcSchema> {
+  /** Called when WebSocket connection opens */
+  onConnect?(): void;
+  /** Called when WebSocket connection closes */
+  onDisconnect?(code: number, reason: string): void;
+  /** Called when attempting to reconnect */
+  onReconnect?(attempt: number, delay: number): void;
+  /** Called when reconnection fails after max attempts */
+  onReconnectFailed?(): void;
+  /** Called when receiving an event from the server */
+  onEvent?: EventHandler<TRemoteSchema>;
+}
+interface IMultiAdapterHooks<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> {
+  /** Called when a peer connects */
+  onConnect?(peer: RpcPeer<TLocalSchema, TRemoteSchema>): void;
+  /** Called when a peer disconnects */
+  onDisconnect?(peer: RpcPeer<TLocalSchema, TRemoteSchema>): void;
+  /** Called when an event is received from a peer */
+  onEvent?: EventHandler<TRemoteSchema, [peer: RpcPeer<TLocalSchema, TRemoteSchema>]>;
+  /** Called when a peer encounters an error */
+  onError?(peer: RpcPeer<TLocalSchema, TRemoteSchema> | null, error: Error): void;
+  onClose?(): void;
+}
+interface IConnectionAdapter<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> extends IRpcOptions<TLocalSchema, TRemoteSchema>, IMethodController<TLocalSchema>, IEventController<TLocalSchema, TRemoteSchema> {
+  /** Driver for calling remote methods on connected peer */
+  readonly driver: Driver<TRemoteSchema>;
+  readonly hooks: IAdapterHooks<TRemoteSchema>;
+}
+/**
+ * Interface for adapters that manage multiple connections
+ *
+ * Extends IRpcConnection - `emit()` broadcasts to all connected peers.
+ * Implemented by RpcServer and Cloudflare DO adapter.
+ */
+interface IMultiConnectionAdapter<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> extends IRpcOptions<TLocalSchema, TRemoteSchema>, IMethodController<TLocalSchema>, IEventController<TLocalSchema, TRemoteSchema, [ids?: string[]]> {
+  /** Driver for calling remote methods on connected peers */
+  readonly driver: MultiDriver<TRemoteSchema>;
+  readonly hooks: IMultiAdapterHooks<TLocalSchema, TRemoteSchema>;
+  /** Get count of connected peers */
+  getConnectionCount(): number;
+  /** Get all connected peer IDs */
+  getConnectionIds(): string[];
+}
+//#endregion
+export { IAdapterHooks, IConnectionAdapter, IMultiAdapterHooks, IMultiConnectionAdapter, MultiCallOptions, MultiCallResult, MultiDriver, type ReconnectOptions, calculateReconnectDelay, defaultReconnectOptions };

package/dist/adapters/types.js

@@ -0,0 +1,3 @@
+import { n as defaultReconnectOptions, t as calculateReconnectDelay } from "../reconnect-CGAA_1Gf.js";
+
+export { calculateReconnectDelay, defaultReconnectOptions };

package/dist/codecs/cbor.d.ts

@@ -0,0 +1,16 @@
+import "../schema-CN5HHHku.js";
+import { n as CodecFactory } from "../factory-C1v0AEHY.js";
+import * as z from "zod";
+
+//#region src/codecs/cbor.d.ts
+
+declare const createCborCodec: CodecFactory<Uint8Array<ArrayBuffer>>;
+/**
+ * Default CBOR codec for unknown values
+ *
+ * Use when you need to serialize arbitrary data without schema validation.
+ * The decoded value will be `unknown` and should be validated separately.
+ */
+declare const CborCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, unknown>, z.ZodUnknown>;
+//#endregion
+export { CborCodec, createCborCodec };

package/dist/codecs/cbor.js

@@ -0,0 +1,36 @@
+import { t as createBinaryCodecFactory } from "../factory-3ziwTuZe.js";
+import * as z from "zod";
+import { Decoder, Encoder } from "cbor-x";
+
+//#region src/codecs/cbor.ts
+/**
+* CBOR codec using cbor-x
+*
+* Requires optional peer dependency: cbor-x
+*
+* @example
+* ```ts
+* import { createCborCodec, CborCodec } from "@igoforth/ws-rpc/codecs/cbor";
+*
+* // Create a typed codec
+* const MyDataCodec = createCborCodec(MyDataSchema);
+* const bytes = MyDataCodec.encode(data); // Uint8Array
+* const decoded = MyDataCodec.decode(bytes); // validated MyData
+*
+* // Or use the generic codec
+* const bytes = CborCodec.encode({ any: "data" });
+* ```
+*/
+const decode = (data) => new Decoder({ bundleStrings: true }).decode(data);
+const encode = (data) => new Encoder({ bundleStrings: true }).encode(data);
+const createCborCodec = createBinaryCodecFactory((value) => encode(value), (bytes) => decode(bytes), "cbor");
+/**
+* Default CBOR codec for unknown values
+*
+* Use when you need to serialize arbitrary data without schema validation.
+* The decoded value will be `unknown` and should be validated separately.
+*/
+const CborCodec = createCborCodec(z.unknown());
+
+//#endregion
+export { CborCodec, createCborCodec };

package/dist/codecs/factory.d.ts

@@ -0,0 +1,3 @@
+import "../schema-CN5HHHku.js";
+import { a as WireCodec, c as createStringCodecFactory, i as StringCodec, l as isBinaryCodec, n as CodecFactory, o as WireData, r as CodecOptions, s as createBinaryCodecFactory, t as BinaryCodec, u as isStringCodec } from "../factory-C1v0AEHY.js";
+export { BinaryCodec, CodecFactory, CodecOptions, StringCodec, WireCodec, WireData, createBinaryCodecFactory, createStringCodecFactory, isBinaryCodec, isStringCodec };

package/dist/codecs/factory.js

@@ -0,0 +1,3 @@
+import { i as isStringCodec, n as createStringCodecFactory, r as isBinaryCodec, t as createBinaryCodecFactory } from "../factory-3ziwTuZe.js";
+
+export { createBinaryCodecFactory, createStringCodecFactory, isBinaryCodec, isStringCodec };

package/dist/codecs/index.d.ts

@@ -0,0 +1,5 @@
+import "../schema-CN5HHHku.js";
+import { a as WireCodec, c as createStringCodecFactory, i as StringCodec, l as isBinaryCodec, n as CodecFactory, o as WireData, r as CodecOptions, s as createBinaryCodecFactory, t as BinaryCodec, u as isStringCodec } from "../factory-C1v0AEHY.js";
+import { n as createJsonCodec, t as JsonCodec } from "../json-54Z2bIIs.js";
+import "../index-Be7jjS77.js";
+export { BinaryCodec, CodecFactory, CodecOptions, JsonCodec, StringCodec, WireCodec, WireData, createBinaryCodecFactory, createJsonCodec, createStringCodecFactory, isBinaryCodec, isStringCodec };

package/dist/codecs/index.js

@@ -0,0 +1,5 @@
+import { i as isStringCodec, n as createStringCodecFactory, r as isBinaryCodec, t as createBinaryCodecFactory } from "../factory-3ziwTuZe.js";
+import { n as createJsonCodec, t as JsonCodec } from "../json-Bshec-bZ.js";
+import "../codecs-BmYG2d_U.js";
+
+export { JsonCodec, createBinaryCodecFactory, createJsonCodec, createStringCodecFactory, isBinaryCodec, isStringCodec };

package/dist/codecs/json.d.ts

@@ -0,0 +1,4 @@
+import "../schema-CN5HHHku.js";
+import "../factory-C1v0AEHY.js";
+import { n as createJsonCodec, t as JsonCodec } from "../json-54Z2bIIs.js";
+export { JsonCodec, createJsonCodec };

package/dist/codecs/json.js

@@ -0,0 +1,4 @@
+import "../factory-3ziwTuZe.js";
+import { n as createJsonCodec, t as JsonCodec } from "../json-Bshec-bZ.js";
+
+export { JsonCodec, createJsonCodec };

package/dist/codecs/msgpack.d.ts

@@ -0,0 +1,16 @@
+import "../schema-CN5HHHku.js";
+import { n as CodecFactory } from "../factory-C1v0AEHY.js";
+import * as z from "zod";
+
+//#region src/codecs/msgpack.d.ts
+
+declare const createMsgpackCodec: CodecFactory<Uint8Array<ArrayBuffer>>;
+/**
+ * Default MessagePack codec for unknown values
+ *
+ * Use when you need to serialize arbitrary data without schema validation.
+ * The decoded value will be `unknown` and should be validated separately.
+ */
+declare const MsgpackCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, unknown>, z.ZodUnknown>;
+//#endregion
+export { MsgpackCodec, createMsgpackCodec };

package/dist/codecs/msgpack.js

@@ -0,0 +1,34 @@
+import { t as createBinaryCodecFactory } from "../factory-3ziwTuZe.js";
+import * as z from "zod";
+import { decode, encode } from "@msgpack/msgpack";
+
+//#region src/codecs/msgpack.ts
+/**
+* MessagePack codec using @msgpack/msgpack
+*
+* Requires optional peer dependency: @msgpack/msgpack
+*
+* @example
+* ```ts
+* import { createMsgpackCodec, MsgpackCodec } from "@igoforth/ws-rpc/codecs/msgpack";
+*
+* // Create a typed codec
+* const MyDataCodec = createMsgpackCodec(MyDataSchema);
+* const bytes = MyDataCodec.encode(data); // Uint8Array
+* const decoded = MyDataCodec.decode(bytes); // validated MyData
+*
+* // Or use the generic codec
+* const bytes = MsgpackCodec.encode({ any: "data" });
+* ```
+*/
+const createMsgpackCodec = createBinaryCodecFactory((value) => encode(value), (bytes) => decode(bytes), "msgpack");
+/**
+* Default MessagePack codec for unknown values
+*
+* Use when you need to serialize arbitrary data without schema validation.
+* The decoded value will be `unknown` and should be validated separately.
+*/
+const MsgpackCodec = createMsgpackCodec(z.unknown());
+
+//#endregion
+export { MsgpackCodec, createMsgpackCodec };

package/dist/default-BkrMd28n.js

@@ -0,0 +1,253 @@
+import { n as RpcErrorCodes, t as JsonProtocol } from "./protocol-_mpoOPp6.js";
+import { a as RpcTimeoutError, i as RpcRemoteError, o as RpcValidationError, r as RpcMethodNotFoundError, t as RpcConnectionClosed } from "./errors-5BfreE63.js";
+import { v7 } from "uuid";
+
+//#region src/peers/default.ts
+/**
+* RPC Peer
+*
+* Core bidirectional RPC implementation. Both client and server are "peers"
+* that can call methods on each other.
+*/
+/**
+* Bidirectional RPC peer
+*
+* Both sides of a WebSocket connection are "peers" - they each implement
+* some methods (provider) and can call methods on the other side (driver).
+*/
+var RpcPeer = class {
+	/** Unique identifier for this peer */
+	id;
+	/** WebSocket instance - protected for subclass access */
+	ws;
+	/** Protocol instance - protected for subclass access */
+	protocol;
+	localSchema;
+	remoteSchema;
+	provider;
+	onEventHandler;
+	defaultTimeout;
+	generateId;
+	pendingRequests = /* @__PURE__ */ new Map();
+	requestCounter = 0;
+	closed = false;
+	/** Proxy for calling remote methods */
+	driver;
+	constructor(options) {
+		this.id = options.id ?? v7();
+		this.ws = options.ws;
+		this.protocol = options.protocol ?? JsonProtocol;
+		this.localSchema = options.localSchema;
+		this.remoteSchema = options.remoteSchema;
+		this.provider = options.provider;
+		this.onEventHandler = options.onEvent;
+		this.defaultTimeout = options.timeout ?? 3e4;
+		this.generateId = options.generateId ?? (() => `${++this.requestCounter}`);
+		this.driver = this.createDriver();
+	}
+	/**
+	* Create a proxy that allows calling remote methods
+	*/
+	createDriver() {
+		const methods = this.remoteSchema.methods ?? {};
+		const driver = {};
+		for (const methodName of Object.keys(methods)) driver[methodName] = (input) => this.callMethod(methodName, input);
+		return driver;
+	}
+	/**
+	* Call a remote method and wait for the response (used by driver proxy)
+	*/
+	async callMethod(method, input, timeout) {
+		if (this.closed || this.ws.readyState !== 1) throw new RpcConnectionClosed();
+		const methodDef = this.remoteSchema.methods?.[method];
+		if (!methodDef) throw new RpcMethodNotFoundError(method);
+		const parseResult = methodDef.input.safeParse(input);
+		if (!parseResult.success) throw new RpcValidationError(`Invalid input for method '${method}'`, parseResult.error);
+		const id = this.generateId();
+		const timeoutMs = timeout ?? this.defaultTimeout;
+		return new Promise((resolve, reject) => {
+			const timeoutHandle = setTimeout(() => {
+				this.pendingRequests.delete(id);
+				reject(new RpcTimeoutError(method, timeoutMs));
+			}, timeoutMs);
+			this.pendingRequests.set(id, {
+				resolve,
+				reject,
+				timeout: timeoutHandle,
+				method
+			});
+			this.ws.send(this.protocol.createRequest(id, method, parseResult.data));
+		});
+	}
+	/**
+	* Emit an event to the remote peer (fire-and-forget)
+	*/
+	emit(event, data) {
+		if (this.closed || this.ws.readyState !== 1) {
+			console.warn(`Cannot emit event '${String(event)}': connection closed`);
+			return;
+		}
+		const eventName = event;
+		const eventDef = this.localSchema.events?.[eventName];
+		if (!eventDef) {
+			console.warn(`Unknown event '${eventName}'`);
+			return;
+		}
+		const parseResult = eventDef.data.safeParse(data);
+		if (!parseResult.success) {
+			console.warn(`Invalid data for event '${eventName}':`, parseResult.error);
+			return;
+		}
+		this.ws.send(this.protocol.createEvent(eventName, parseResult.data));
+	}
+	/**
+	* Handle an incoming WebSocket message
+	*
+	* Accepts string, ArrayBuffer, Uint8Array (including Node.js Buffer),
+	* or Uint8Array[] (for ws library's fragmented messages).
+	*
+	* @example
+	* ```ts
+	* // Works directly with ws library's message event
+	* ws.on("message", (data) => peer.handleMessage(data));
+	* ```
+	*/
+	handleMessage(data) {
+		const message = this.protocol.safeDecodeMessage(data);
+		if (!message) {
+			console.error("Failed to parse RPC message");
+			return;
+		}
+		switch (message.type) {
+			case "rpc:request":
+				this.handleRequest(message);
+				break;
+			case "rpc:response":
+				this.handleResponse(message);
+				break;
+			case "rpc:error":
+				this.handleError(message);
+				break;
+			case "rpc:event":
+				this.handleEvent(message);
+				break;
+		}
+	}
+	/**
+	* Handle an incoming RPC request
+	*/
+	async handleRequest(request) {
+		const { id, method, params } = request;
+		const methodDef = this.localSchema.methods?.[method];
+		if (!methodDef) {
+			this.sendError(id, RpcErrorCodes.METHOD_NOT_FOUND, `Method '${method}' not found`);
+			return;
+		}
+		const parseResult = methodDef.input.safeParse(params);
+		if (!parseResult.success) {
+			this.sendError(id, RpcErrorCodes.INVALID_PARAMS, `Invalid params for '${method}'`, parseResult.error);
+			return;
+		}
+		const handler = this.provider[method];
+		if (!handler) {
+			this.sendError(id, RpcErrorCodes.METHOD_NOT_FOUND, `Method '${method}' not implemented`);
+			return;
+		}
+		try {
+			const result = await handler.call(this.provider, parseResult.data);
+			const outputResult = methodDef.output.safeParse(result);
+			if (!outputResult.success) {
+				this.sendError(id, RpcErrorCodes.INTERNAL_ERROR, `Invalid output from '${method}'`, outputResult.error);
+				return;
+			}
+			this.ws.send(this.protocol.createResponse(id, outputResult.data));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			this.sendError(id, RpcErrorCodes.INTERNAL_ERROR, message);
+		}
+	}
+	/**
+	* Handle an incoming RPC response
+	*/
+	handleResponse(response) {
+		const pending = this.pendingRequests.get(response.id);
+		if (!pending) {
+			console.warn(`Received response for unknown request: ${response.id}`);
+			return;
+		}
+		clearTimeout(pending.timeout);
+		this.pendingRequests.delete(response.id);
+		pending.resolve(response.result);
+	}
+	/**
+	* Handle an incoming RPC error
+	*/
+	handleError(error) {
+		const pending = this.pendingRequests.get(error.id);
+		if (!pending) {
+			console.warn(`Received error for unknown request: ${error.id}`);
+			return;
+		}
+		clearTimeout(pending.timeout);
+		this.pendingRequests.delete(error.id);
+		pending.reject(new RpcRemoteError(pending.method, error.code, error.message, error.data));
+	}
+	/**
+	* Handle an incoming event
+	*/
+	handleEvent(event) {
+		if (!this.onEventHandler) return;
+		const eventDef = this.remoteSchema.events?.[event.event];
+		if (!eventDef) {
+			console.warn(`Unknown event: ${event.event}`);
+			return;
+		}
+		const parseResult = eventDef.data.safeParse(event.data);
+		if (!parseResult.success) {
+			console.warn(`Invalid data for event '${event.event}':`, parseResult.error);
+			return;
+		}
+		this.onEventHandler(event.event, parseResult.data);
+	}
+	/**
+	* Send an error response
+	*/
+	sendError(id, code, message, data) {
+		if (this.ws.readyState !== 1) return;
+		this.ws.send(this.protocol.createError(id, code, message, data));
+	}
+	/**
+	* Mark the peer as closed and reject all pending requests
+	*/
+	close() {
+		this.closed = true;
+		for (const [, pending] of this.pendingRequests) {
+			clearTimeout(pending.timeout);
+			pending.reject(new RpcConnectionClosed());
+		}
+		this.pendingRequests.clear();
+	}
+	/**
+	* Check if the peer connection is open
+	*/
+	get isOpen() {
+		return !this.closed && this.ws.readyState === 1;
+	}
+	/**
+	* Get the underlying WebSocket
+	*
+	* Use for advanced scenarios like DurableRpcPeer integration.
+	*/
+	getWebSocket() {
+		return this.ws;
+	}
+	/**
+	* Get the number of pending requests
+	*/
+	get pendingCount() {
+		return this.pendingRequests.size;
+	}
+};
+
+//#endregion
+export { RpcPeer as t };

package/dist/default-xDNNMrg0.d.ts

@@ -0,0 +1,129 @@
+import { a as InferEventData, h as StringKeys, i as EventHandler, m as RpcSchema, n as EventDef, p as Provider, t as Driver } from "./schema-CN5HHHku.js";
+import { g as WireInput, u as RpcProtocol } from "./protocol-DA84zrc2.js";
+import { a as IRpcOptions, r as IMinWebSocket } from "./types-Be-qmQu0.js";
+
+//#region src/peers/default.d.ts
+
+/**
+ * Options for creating an RpcPeer
+ */
+interface RpcPeerOptions<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> extends IRpcOptions<TLocalSchema, TRemoteSchema> {
+  /** Unique identifier for this peer (auto-generated if not provided) */
+  id?: string;
+  /** WebSocket instance */
+  ws: IMinWebSocket;
+  /** Implementation of local methods */
+  provider: Partial<Provider<TLocalSchema>>;
+  /**
+   * Protocol for encoding/decoding messages
+   *
+   * Defaults to JSON. Use createProtocol() with a binary codec for better performance.
+   *
+   * @example
+   * ```ts
+   * import { createProtocol, RpcMessageSchema } from "@igoforth/ws-rpc/protocol";
+   * import { createMsgpackCodec } from "@igoforth/ws-rpc/codecs/msgpack";
+   *
+   * const peer = new RpcPeer({
+   *   protocol: createProtocol(createMsgpackCodec(RpcMessageSchema)),
+   *   // ...
+   * });
+   * ```
+   */
+  protocol?: RpcProtocol | undefined;
+  /** Handler for incoming events */
+  onEvent?: EventHandler<TRemoteSchema> | undefined;
+  /** Generate unique request IDs */
+  generateId?: (() => string) | undefined;
+}
+/**
+ * Bidirectional RPC peer
+ *
+ * Both sides of a WebSocket connection are "peers" - they each implement
+ * some methods (provider) and can call methods on the other side (driver).
+ */
+declare class RpcPeer<TLocalSchema extends RpcSchema, TRemoteSchema extends RpcSchema> {
+  /** Unique identifier for this peer */
+  readonly id: string;
+  /** WebSocket instance - protected for subclass access */
+  protected readonly ws: IMinWebSocket;
+  /** Protocol instance - protected for subclass access */
+  protected readonly protocol: RpcProtocol;
+  private readonly localSchema;
+  private readonly remoteSchema;
+  private readonly provider;
+  private readonly onEventHandler?;
+  private readonly defaultTimeout;
+  private readonly generateId;
+  private readonly pendingRequests;
+  private requestCounter;
+  private closed;
+  /** Proxy for calling remote methods */
+  readonly driver: Driver<TRemoteSchema>;
+  constructor(options: RpcPeerOptions<TLocalSchema, TRemoteSchema>);
+  /**
+   * Create a proxy that allows calling remote methods
+   */
+  private createDriver;
+  /**
+   * Call a remote method and wait for the response (used by driver proxy)
+   */
+  private callMethod;
+  /**
+   * Emit an event to the remote peer (fire-and-forget)
+   */
+  emit<K extends StringKeys<TLocalSchema["events"]>>(event: K, data: TLocalSchema["events"] extends Record<string, EventDef> ? InferEventData<TLocalSchema["events"][K]> : never): void;
+  /**
+   * Handle an incoming WebSocket message
+   *
+   * Accepts string, ArrayBuffer, Uint8Array (including Node.js Buffer),
+   * or Uint8Array[] (for ws library's fragmented messages).
+   *
+   * @example
+   * ```ts
+   * // Works directly with ws library's message event
+   * ws.on("message", (data) => peer.handleMessage(data));
+   * ```
+   */
+  handleMessage(data: WireInput): void;
+  /**
+   * Handle an incoming RPC request
+   */
+  private handleRequest;
+  /**
+   * Handle an incoming RPC response
+   */
+  private handleResponse;
+  /**
+   * Handle an incoming RPC error
+   */
+  private handleError;
+  /**
+   * Handle an incoming event
+   */
+  private handleEvent;
+  /**
+   * Send an error response
+   */
+  private sendError;
+  /**
+   * Mark the peer as closed and reject all pending requests
+   */
+  close(): void;
+  /**
+   * Check if the peer connection is open
+   */
+  get isOpen(): boolean;
+  /**
+   * Get the underlying WebSocket
+   *
+   * Use for advanced scenarios like DurableRpcPeer integration.
+   */
+  getWebSocket(): IMinWebSocket;
+  /**
+   * Get the number of pending requests
+   */
+  get pendingCount(): number;
+}
+//#endregion
+export { RpcPeerOptions as n, RpcPeer as t };